Прокомментировать - объяснить значение строк в коде

struct Package
{
    short numberOfFragment;
    short countofFragment;
    short sizeOfMessage;
    CHAR message[DATA_LENGTH+1];
};

struct Package
{    
     struct Package
{
    CHAR recipients[4096];
    CHAR message[1024];
};
};

#include <winsock2.h>
#include <Windows.h>
#include <WindowsX.h>
#include <tchar.h>
#include <locale.h>
#include <CommCtrl.h>
#include <Strsafe.h>
#include <string.h>
#include <process.h>
#include <math.h> 
 
#pragma comment (lib, "ws2_32.lib")
#define IDC_EDIT_IP             2001
#define IDC_EDIT_MESSAGE        2002
#define IDC_BUTTON_BROADCAST    2003
#define IDC_BUTTON_CLEAR        2004
#define IDC_BUTTON_SEND         2005
#define IDC_LISTBOX             2009
#define DATA_LENGTH_FLOAT       29.0
#define DATA_LENGTH             29
#define PORT                    5150
struct hostent *hst;
#pragma pack(1)
struct Package
{
    short numberOfFragment;
    short countofFragment;
    short sizeOfMessage;
    CHAR message[DATA_LENGTH+1];
};
#pragma pack()
LRESULT CALLBACK windowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lparam);
// обработчик сообщения WM_CREATE
BOOL OnCreate(HWND hwnd, LPCREATESTRUCT lpCreateStruct);
// обработчик сообщения WM_COMMAND
void OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify);
// обработчик сообщения WM_DESTROY
void OnDestroy(HWND hwnd);
HWND hDlg = NULL;
 
BOOL PreTranslateMessage(LPMSG lpMsg);
 
WSADATA wsaData;
SOCKET  s;
HANDLE hThread, hMutex;
HWND hWnd;
sockaddr_in SIN = { 0 };
char *host;
char *messages;
 
unsigned int CALLBACK ThreadFunc(LPVOID lpParameter);
int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE, LPTSTR lpszCmdLine, int nCmdShow)
    {
    setlocale(LC_ALL, "Russian");
    WNDCLASSEX wcex = { sizeof(WNDCLASSEX) };
    wcex.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
    wcex.lpfnWndProc = windowProc; // оконная процедура
    wcex.hInstance = hInstance;
    wcex.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
    wcex.lpszMenuName = NULL;
    wcex.lpszClassName = TEXT("winClass"); // имя класса
    wcex.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
if (0 == RegisterClassEx(&wcex))
        return -1;
 
    LoadLibrary(TEXT("ComCtl32.dll"));
    hWnd = CreateWindowEx(0, TEXT("winClass"),
        TEXT("UDP"), 
        WS_OVERLAPPEDWINDOW & (~WS_MAXIMIZEBOX) ^ WS_THICKFRAME,
        CW_USEDEFAULT, 0,
        CW_USEDEFAULT, 0, 
        NULL, NULL, 
        hInstance, NULL);
 
    if (NULL == hWnd)
        return -1;
 
    ShowWindow(hWnd, nCmdShow);
    MSG msg;
    BOOL bRet;
 
    for (;;)
    {
        // определяем наличие сообщений в очереди
        while (!PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE))
        {
 
        } // while
        // извлекаем сообщение из очереди
        bRet = GetMessage(&msg, NULL, 0, 0);
        if (bRet == -1)
        {
            /* обработка ошибки и возможно выход из цикла */
        } // if
        else if (FALSE == bRet)
        {
            break; // получено WM_QUIT, выход из цикла
        } // if
        else if (PreTranslateMessage(&msg) == FALSE)
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        } // if
 
    } // for
    return (int)msg.wParam; // завершаем работу приложения
} // _tWinMain
LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
        HANDLE_MSG(hWnd, WM_CREATE, OnCreate);
        HANDLE_MSG(hWnd, WM_DESTROY, OnDestroy);
        HANDLE_MSG(hWnd, WM_COMMAND, OnCommand);
 
    }//switch
    
    return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
BOOL PreTranslateMessage(LPMSG lpMsg)
{
    return IsDialogMessage(hDlg, lpMsg);
} // PreTranslateMessage
BOOL OnCreate(HWND hwnd, LPCREATESTRUCT lpCreateStruct)
{
    if (NULL != hwnd)
    {
        CreateWindowExA(0, "Edit", "",
            WS_CHILD | WS_VISIBLE | WS_BORDER, 20, 50, 220, 25, hwnd, (HMENU)IDC_EDIT_IP, lpCreateStruct->hInstance, NULL);
 
        CreateWindowExA(0, "Edit", "",
            WS_CHILD | WS_VISIBLE | WS_BORDER, 20, 120, 850, 100, hwnd, (HMENU)IDC_EDIT_MESSAGE, lpCreateStruct->hInstance, NULL);
 
        CreateWindowEx(0, TEXT("Button"), TEXT("255.255.255.255"),
            WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 540, 50, 160, 25, hwnd, (HMENU)IDC_BUTTON_BROADCAST, lpCreateStruct->hInstance, NULL);
 
        CreateWindowEx(0, TEXT("Button"), TEXT("очистить"),
            WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 710, 50, 160, 25, hwnd, (HMENU)IDC_BUTTON_CLEAR, lpCreateStruct->hInstance, NULL);
 
        CreateWindowEx(0, TEXT("Button"), TEXT("отправить"),
            WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 20, 250, 150, 50, hwnd, (HMENU)IDC_BUTTON_SEND, lpCreateStruct->hInstance, NULL);
        CreateWindowEx(0, TEXT("ListBox"), NULL,
            WS_CHILD | WS_VISIBLE | WS_BORDER | WS_HSCROLL | LBS_STANDARD | !LBS_SORT, 20, 320, 850, 170, hwnd, (HMENU)IDC_LISTBOX, lpCreateStruct->hInstance, NULL);
int err = WSAStartup(MAKEWORD(2, 2), &wsaData);
 
        if (0 == err)
        {
            /* Инициализация WinSock выполнена успешно */
        } // if
        s = socket(AF_INET, SOCK_DGRAM, 0);
        if (s == INVALID_SOCKET)
        {
            printf("Socket error: %d\n", WSAGetLastError());
            WSACleanup();
        }
BOOL optvalue;
        int optlen = sizeof(optvalue);
 
        // определяем значение флага SO_BROADCAST
        int res = getsockopt(s, SOL_SOCKET, SO_BROADCAST, (char *)&optvalue, &optlen);
 
        if (SOCKET_ERROR != res && TRUE != optvalue)
        {
            optvalue = TRUE;
            optlen = sizeof(optvalue);
 
            // изменяем значение флага SO_BROADCAST
            res = setsockopt(s, SOL_SOCKET, SO_BROADCAST, (char *)&optvalue, optlen);
        } // if
if (SOCKET_ERROR == res)
        {
            /* Не удалось установить флаг SO_BROADCAST */
        } // if
 
        SIN.sin_family = AF_INET; // семейство адресов = IPv4
        SIN.sin_port = htons(PORT); 
        DWORD cchSize = 0;
GetComputerName(NULL, &cchSize);
host = new CHAR[cchSize];
 
        BOOL bRet = GetComputerNameA(host, &cchSize);
 
        if (FALSE != bRet)
        {
            if ((hst = gethostbyname(host)) && hst->h_addrtype == AF_INET)
                SIN.sin_addr = *(struct in_addr *) hst->h_addr_list[0];
        }
err = bind(s, (sockaddr *)&SIN, sizeof(SIN));
 
        if (SOCKET_ERROR != err)
        {
            hThread = (HANDLE)_beginthreadex(NULL, 0, ThreadFunc, NULL, 0, NULL);
            /* Сокет успешно ассоциирован */
        } // if
        else
        {
            //ошибка
        }
        hMutex = CreateMutexEx(NULL, TEXT("Mutex"), 0, MUTEX_ALL_ACCESS);
    } // if
    return TRUE;
}
void OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify)
{
    if (BN_CLICKED == codeNotify)
    {
        HINSTANCE hInstance = GetWindowInstance(hwnd);
        switch (id)
        {
        case IDC_BUTTON_SEND:
        {
            Package msg;
            HWND hwndEdit = GetDlgItem(hwnd, IDC_EDIT_IP);
            int size = Edit_GetTextLength(hwndEdit);
            char *szBuffer = new char[size + 1];
            GetDlgItemTextA(hwnd, IDC_EDIT_IP, szBuffer, size + 1);
 
            HWND hwndEdit1 = GetDlgItem(hwnd, IDC_EDIT_MESSAGE);
            int sizeText = Edit_GetTextLength(hwndEdit1);
            CHAR *szBuff = new CHAR[sizeText + 1];
            GetDlgItemTextA(hwnd, IDC_EDIT_MESSAGE, szBuff, sizeText + 1);
            sockaddr_in sin_adress = { 0 };
            sin_adress.sin_family = AF_INET; // семейство адресов = IPv4
            sin_adress.sin_port = htons(5150); // номер порта 
              if (inet_addr(szBuffer) != INADDR_NONE)
                sin_adress.sin_addr.s_addr = inet_addr(szBuffer);
            else
                {
                // попытка получить IP адрес по доменному имени сервера
                if (hst = gethostbyname(szBuffer))
                // hst->h_addr_list содержит не массив адресов,
                // а массив указателей на адреса
                ((unsigned long *)&sin_adress.sin_addr)[0] =
                ((unsigned long **)hst->h_addr_list)[0][0];
            }
 
if (sizeText < DATA_LENGTH)
            {
                msg.sizeOfMessage = sizeText;
                msg.numberOfFragment = 0;
                unsigned int kol;
                kol=sizeof(msg.message);
                msg.countofFragment = 0;
                StringCchCopyA(msg.message, _countof(msg.message), szBuff);
                int n = sendto(s, (const char *)&msg, sizeof(msg), 0, (struct sockaddr *)&sin_adress, sizeof(sin_adress));
                if (SOCKET_ERROR != n) // сообщение успешно отправлено
                {
                    SetDlgItemTextA(hwnd, IDC_EDIT_IP, "");
                    SetDlgItemTextA(hwnd, IDC_EDIT_MESSAGE, "");
                } // if
                else MessageBox(hwnd, TEXT("Сообщение не отправлено"), TEXT("Ошибка!"), MB_OK | MB_ICONERROR);
                }
            else
            {
                double x = sizeText;
                int k = DATA_LENGTH;
                msg.countofFragment=ceil(x / 29.0);
                for (int i = 0; i < msg.countofFragment; ++i)
                {
                    char Buff[DATA_LENGTH + 1];
                    msg.sizeOfMessage = sizeText;
                    msg.numberOfFragment = i;
                    strncpy(Buff, &szBuff[k*i], DATA_LENGTH + 1);
                    if (i==msg.countofFragment-1)
                        msg.sizeOfMessage = sizeText % (i*(DATA_LENGTH + 1)) +3;
                    else
                        msg.sizeOfMessage = DATA_LENGTH + 1;
                    StringCchCopy(msg.message, msg.sizeOfMessage, Buff);
                    int n = sendto(s, (const char *)&msg, sizeof(msg), 0, (struct sockaddr *)&sin_adress, sizeof(sin_adress));
                    if (SOCKET_ERROR == n)
                    {
                        MessageBox(hwnd, TEXT("Сообщение не отправлено"), TEXT("Ошибка!"), MB_OK | MB_ICONERROR);
                        break;
                    } // if
                }
            SetDlgItemTextA(hwnd, IDC_EDIT_IP, "");
            SetDlgItemTextA(hwnd, IDC_EDIT_MESSAGE, "");
            }
        }
            break;
            case IDC_BUTTON_BROADCAST:
        {
            SetDlgItemTextA(hwnd, IDC_EDIT_IP, "255.255.255.255");
        }
            break;
            case IDC_BUTTON_CLEAR:
        {
            SetDlgItemTextA(hwnd, IDC_EDIT_IP, "");
        }
            break;
        }
    }//if
}
void OnDestroy(HWND hwnd)
{
    closesocket(s);
    WaitForSingleObject(hThread, INFINITE);
    CloseHandle(hThread);
    PostQuitMessage(0); // отправляем сообщение WM_QUIT
}
unsigned int CALLBACK ThreadFunc(LPVOID lpParameter)
{
int sizeOfMessage = 0;
    Package Msg;
    int n, i, j;
    for (;;)
    {
int len = sizeof(SIN);
        // получаем текстовое сообщение
        n = recvfrom(s, (char *)&Msg, sizeof(Msg), 0, (struct sockaddr *)&SIN, &len);
if (SOCKET_ERROR != n) // сообщение успешно получено
        {
            HWND hwndListBox = GetDlgItem(hWnd, IDC_LISTBOX);
            if (Msg.countofFragment==0)
                {
                ListBox_AddString(hwndListBox, Msg.message);
            }
           else
            {
                if (Msg.numberOfFragment == 0)
                {
                    messages = new char[(DATA_LENGTH+1)*Msg.countofFragment];
                }
                j = 0;
                for (i = DATA_LENGTH * Msg.numberOfFragment; i < DATA_LENGTH * Msg.numberOfFragment+Msg.sizeOfMessage; ++i)
                    {
                    messages[i] = Msg.message[j];
                    j++;
                }
 
                if (Msg.numberOfFragment==(Msg.countofFragment-1))
                {
                    ListBox_AddString(hwndListBox, messages);
                    sizeOfMessage = 0;
                }
            }
        } // if 
        else
            break;
    }
    return 0;
}

#include <winsock2.h>
#include <Windows.h>
#include <WindowsX.h>
#include <tchar.h>
#include <locale.h>
#include <CommCtrl.h>
#include <Strsafe.h>
#include <string.h>
#include <process.h>
#include <iostream>
 
#pragma comment ( lib, "ws2_32.lib" )
using namespace std;
 
#define SHUTDOWN(sock) if(sock != NULL) {shutdown(sock, SD_BOTH); closesocket(sock); sock = NULL;}
 
struct hostent *hst;
SRWLOCK SrwLock;
WSADATA wsaData;
SOCKET  s;
HANDLE hThread;
HWND hWnd;
HANDLE handleOfClients[20];
 
 
sockaddr_in SIN = { 0 };
 
#pragma pack(push,1)
struct Package
{
    CHAR recipients[4096];
    CHAR message[1024];
};
#pragma pack(pop)
 
char *host;
int nclients = 0;
Package msg;
 
SOCKET SocketClients[1024];
char *BaseNameClients[1024];
void GetClientNames(char string[]);
int WritePerSymbol(SOCKET s, char* buf, size_t length);
int ReadPerSymbol(SOCKET s, char* buf, size_t length);
 
unsigned int WINAPI ClientTread(LPVOID client_socket)
{
    SOCKET my_sock;
    my_sock = ((SOCKET *)client_socket)[0];
    char *NameClients;
    for (;;)
    {
        int n = ReadPerSymbol(my_sock, (char *)&msg, sizeof(msg));
        if (n != SOCKET_ERROR)
        {
            if (strcmp(msg.recipients, "1") == 0)
            {
                int size = 0;
                for (int i = 0; i < nclients; ++i)
                {
                    size = size + strlen(BaseNameClients[i])+1;
                }
                NameClients = new char[size + 1];
                strcpy(NameClients, "");
                for (int i = 0; i < nclients; ++i)
                {
                    char c = strlen(BaseNameClients[i]);
                    StringCchPrintf(NameClients, size + 1, "%s%c%s",NameClients,c,BaseNameClients[i]);
                    //StringCchCat(NameClients, 2, &c);
                    //StringCchCat(NameClients, strlen(BaseNameClients[i])+1, BaseNameClients[i]);
                    //strcat(NameClients,&c);
                    //strcat(NameClients,BaseNameClients[i]);
                }
                StringCchCopy(msg.message, 2, "");
                StringCchCopy(msg.recipients, strlen(NameClients) + 1, NameClients);
                StringCchCat(msg.recipients, 1, '\0');
                WritePerSymbol(my_sock, (char *)&msg, sizeof(msg));
                delete[] NameClients;
            }
            
            else
            {
                if (strcmp(msg.recipients, "0") == 0)
                {
                    break;
                }
                GetClientNames(msg.recipients);
            }
        }
        else break;
    }
    int currentNameLen = 0;
    getsockname(my_sock, NULL, &currentNameLen);
    char *CurrentName = new char[currentNameLen + 1];
    int err = getsockname(my_sock, (sockaddr*)CurrentName, &currentNameLen);
    if (err != SOCKET_ERROR)
    {
        AcquireSRWLockExclusive(&SrwLock);
        for (int i = 0; i < nclients; ++i)
        {
            if (strcpy(CurrentName, BaseNameClients[i]) == 0)
            {
                CloseHandle(handleOfClients[i]);
                for (int j = i; j < nclients; ++j)
                {
                    BaseNameClients[j] = BaseNameClients[j + 1];
                    SocketClients[j] = SocketClients[j + 1];
                    handleOfClients[j] = handleOfClients[j + 1];
                }
            }
        }
        ReleaseSRWLockShared(&SrwLock);
    }
    delete[]BaseNameClients[nclients];
    nclients--;
    printf("-отключен\n");
    SHUTDOWN(my_sock);
    return 0;
}
 
int _tmain()
{
    setlocale(LC_ALL, "Russian");
    int err = WSAStartup(MAKEWORD(2, 2), &wsaData);
    s = socket(AF_INET, SOCK_STREAM, 0);
    if (s == INVALID_SOCKET)
    {
        printf("Socket error: %d\n", WSAGetLastError());
        WSACleanup();
    }
    SIN.sin_family = AF_INET;
    SIN.sin_port = htons(5150);
    SIN.sin_addr.s_addr = INADDR_ANY;
 
    err = bind(s, (sockaddr *)&SIN, sizeof(SIN));
 
    if (SOCKET_ERROR != err)
    {
        err = listen(s, 5);
    }
 
    if (SOCKET_ERROR != err)
    {
        for (;;)
        {
            sockaddr_in client_addr; 
            int client_addr_size = sizeof(client_addr);
            SOCKET client_socket =  accept(s, (sockaddr *)&client_addr, &client_addr_size);
            if (INVALID_SOCKET == client_socket)
            {
                nclients++;
                if (WSAEINTR == WSAGetLastError()) break;
            }
            else
            {
                SocketClients[nclients] = client_socket;
                hst = gethostbyaddr((char *)&client_addr.sin_addr.s_addr, 4, AF_INET);
                printf("+%s [%s] был подключен\n",
                    (hst) ? hst->h_name : "", inet_ntoa(client_addr.sin_addr));
                BaseNameClients[nclients] = new char[strlen(hst->h_name)];
                strcpy(BaseNameClients[nclients], hst->h_name);
                //strcat(BaseNameClients[nclients], "%");
                nclients++;
                InitializeSRWLock(&SrwLock);
                handleOfClients[nclients] = (HANDLE)_beginthreadex(NULL, NULL, ClientTread, &client_socket, NULL, NULL);
            } 
        } 
        WaitForMultipleObjects(nclients, handleOfClients, TRUE, INFINITE);
        SHUTDOWN(s);
    } 
}
 
int ReadPerSymbol(SOCKET s, char* buf, size_t length)
{
    int all = length;
    int received = 0;
    while (all > 0)
    {
        received = recv(s, buf, all, 0);
        if (received < 0) return SOCKET_ERROR;
        buf += received;
        all -= received;
    }
    return length;
}
 
int WritePerSymbol(SOCKET s, char* buf, size_t length)
{
    int all = length;
    int sended = 0;
    while (all > 0)
    {
        sended = send(s, buf, all, 0);
        if (sended < 0) return SOCKET_ERROR;
        buf += sended;
        all -= sended;
    }
    return length;
}
 
void GetClientNames(char string[])
{
    unsigned int i = 0;
    unsigned int numOfClients = 0;
    do
    {
            int n = string[i];
            char *clientName = new char[n + 1];
            for (int k = 0; k < n; k++)
            {
                clientName[k] = string[i+1+k];
            }
            clientName[n] = '\0';
            cout << clientName << endl;
            for (int j = 0; j < nclients; ++j)
            {
                if (strcmp(clientName, BaseNameClients[j]) == 0)
                {
                    int n = WritePerSymbol(SocketClients[j], (char*)&msg, sizeof(msg));
                }
            }
            numOfClients++;
            delete[]clientName;
            i += n+1;
    } while (i < 4096 && string[i] != '\0');
    cout << numOfClients << endl; 
}

#include <winsock2.h>
#include <Windows.h>
#include <WindowsX.h>
#include <tchar.h>
#include <locale.h>
#include <CommCtrl.h>
#include <Strsafe.h>
#include <string.h>
#include <process.h>
#include <math.h> 
#include <iostream>
 
#pragma comment (lib, "ws2_32.lib")
using namespace std;
 
#define SERVER "192.168.43.206"
 
#define IDC_STATIC_MESSAGE 2001
#define IDC_EDIT_MESSAGE 2002
#define IDC_LISTBOX 2003
#define IDC_BUTTON_SEND 2004
#define IDC_BUTTON_UPDATE 2005
#define IDC_LISTB2 2006
#define IDC_STATIC_DIALOG 2007
#define IDC_COMBOBOX 2008
#define IDC_BUTTON_ADD 2009
#define IDC_BUTTON_CLEAR 2010
 
#define SHUTDOWN(sock) if(sock != NULL) {shutdown(sock, SD_BOTH); closesocket(sock); sock = NULL;}
struct hostent *hst;
sockaddr_in SIN = { 0 };
 
#pragma pack(push,1)
struct Package
{
    CHAR recipients[4096];
    CHAR message[1024];
};
#pragma pack(pop)
 
 
LRESULT CALLBACK windowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lparam);
BOOL OnCreate(HWND hwnd, LPCREATESTRUCT lpCreateStruct);
void OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify);
void OnDestroy(HWND hwnd);
 
void GetClientNames(char string[], HWND hwndLB);
int WritePerSymbol(SOCKET s, char* buf, size_t length);
int ReadPerSymbol(SOCKET s, char* buf, size_t length);
void ButtonSend(HWND hwnd);
void ButtonUpdate(HWND hwnd);
void ButtonAdd(HWND hwnd);
void ButtonClearLB(HWND hwnd);
 
HWND hDlg = NULL;
 
BOOL PreTranslateMessage(LPMSG lpMsg);
 
WSADATA wsaData;
SOCKET  s;
HANDLE hThread;
HWND hWnd;
char host[50];
 
unsigned int CALLBACK ThreadFunc(LPVOID lpParameter);
 
int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE, LPTSTR lpszCmdLine, int nCmdShow)
{
    setlocale(LC_ALL, "Russian");
    WNDCLASSEX wcex = { sizeof(WNDCLASSEX) };
    wcex.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
    wcex.lpfnWndProc = windowProc; // оконная процедура
    wcex.hInstance = hInstance;
    wcex.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
    wcex.lpszMenuName = NULL;
    wcex.lpszClassName = TEXT("winClass"); // имя класса
    wcex.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
 
    if (0 == RegisterClassEx(&wcex))
        return -1;
 
    LoadLibrary(TEXT("ComCtl32.dll"));
    hWnd = CreateWindowEx(0, TEXT("winClass"),
        TEXT("ИКС и сети. ЛР4. TCP клиент"),
        WS_OVERLAPPEDWINDOW & (~WS_MAXIMIZEBOX) ^ WS_THICKFRAME,
        CW_USEDEFAULT, 0,
        CW_USEDEFAULT, 0,
        NULL, NULL,
        hInstance, NULL);
 
    if (NULL == hWnd)
        return -1;
 
    ShowWindow(hWnd, nCmdShow);
 
    MSG msg;
    BOOL bRet;
 
    for (;;)
    {
        // определяем наличие сообщений в очереди
        while (!PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE))
        {
 
        } // while
 
        // извлекаем сообщение из очереди
        bRet = GetMessage(&msg, NULL, 0, 0);
 
        if (bRet == -1)
        {
            /* обработка ошибки и возможно выход из цикла */
        } // if
        else if (FALSE == bRet)
        {
            break; // получено WM_QUIT, выход из цикла
        } // if
        else if (PreTranslateMessage(&msg) == FALSE)
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        } // if
 
    } // for
    return (int)msg.wParam; // завершаем работу приложения
} // _tWinMain
 
 
LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
        HANDLE_MSG(hWnd, WM_CREATE, OnCreate);
        HANDLE_MSG(hWnd, WM_DESTROY, OnDestroy);
        HANDLE_MSG(hWnd, WM_COMMAND, OnCommand);
    }
    return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
 
BOOL PreTranslateMessage(LPMSG lpMsg)
{
    return IsDialogMessage(hDlg, lpMsg);
} // PreTranslateMessage
 
BOOL OnCreate(HWND hwnd, LPCREATESTRUCT lpCreateStruct)
{
    if (NULL != hwnd)
    {
        CreateWindowEx(0, TEXT("Static"), TEXT("Сообщение:"),
            ES_AUTOHSCROLL | ES_LEFT | WS_CHILD | WS_VISIBLE, 250, 90, 225, 25, hwnd, (HMENU)IDC_STATIC_MESSAGE, lpCreateStruct->hInstance, NULL);
        CreateWindowExA(0, "Edit", "",
            WS_CHILD | WS_VISIBLE | WS_BORDER, 250, 120, 620, 25, hwnd, (HMENU)IDC_EDIT_MESSAGE, lpCreateStruct->hInstance, NULL);
        CreateWindowEx(0, TEXT("Button"), TEXT("отправить"),
            WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 250, 160, 620, 25, hwnd, (HMENU)IDC_BUTTON_SEND, lpCreateStruct->hInstance, NULL);
        CreateWindowEx(0, TEXT("Button"), TEXT("обновить"),
            WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 360, 10, 100, 25, hwnd, (HMENU)IDC_BUTTON_UPDATE, lpCreateStruct->hInstance, NULL);
        CreateWindowEx(0, TEXT("Button"), TEXT("добавить"),
            WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 250, 10, 100, 25, hwnd, (HMENU)IDC_BUTTON_ADD, lpCreateStruct->hInstance, NULL);
        CreateWindowEx(0, TEXT("Button"), TEXT("очистить контакты"),
            WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 250, 40, 210, 25, hwnd, (HMENU)IDC_BUTTON_CLEAR, lpCreateStruct->hInstance, NULL);
        CreateWindowEx(0, TEXT("Static"), TEXT("Диалог:"),
            ES_AUTOHSCROLL | ES_LEFT | WS_CHILD | WS_VISIBLE, 20, 210, 225, 25, hwnd, (HMENU)IDC_STATIC_DIALOG, lpCreateStruct->hInstance, NULL);
        CreateWindowEx(0, TEXT("ListBox"), NULL,
            WS_CHILD | WS_VISIBLE | WS_BORDER | WS_HSCROLL, 20, 240, 850, 210, hwnd, (HMENU)IDC_LISTBOX, lpCreateStruct->hInstance, NULL);
        CreateWindowEx(0, TEXT("ComboBox"), NULL, 
            WS_CHILD | WS_VISIBLE | CBS_SORT | CBS_DROPDOWNLIST, 20, 10, 220, 400,hwnd, (HMENU)IDC_COMBOBOX, lpCreateStruct->hInstance, NULL);
        CreateWindowExA(0, "ListBox", NULL,
            WS_CHILD | WS_VISIBLE | WS_BORDER | WS_HSCROLL | WS_VSCROLL | LBS_MULTIPLESEL, 20, 40, 220, 150, hwnd, (HMENU)IDC_LISTB2, lpCreateStruct->hInstance, NULL);
 
        int err = WSAStartup(MAKEWORD(2, 2), &wsaData);
 
        if (0 == err)
        {
            /* Инициализация WinSock выполнена успешно */
        } // if
        s = socket(AF_INET, SOCK_STREAM, 0);
        if (s == INVALID_SOCKET)
        {
            printf("Socket error: %d\n", WSAGetLastError());
            WSACleanup();
        }
 
        SIN.sin_family = AF_INET; // семейство адресов = IPv4
        SIN.sin_port = htons(5150);
        SIN.sin_addr.s_addr = inet_addr(SERVER);
 
        if (SOCKET_ERROR != err)
        {
            err = connect(s, (sockaddr *)&SIN, sizeof(SIN));
 
            /* Сокет успешно ассоциирован */
            if (SOCKET_ERROR == err)
            {
                MessageBox(hwnd, TEXT("Ошибка!Не удалось установить соединение"), TEXT("Установка соеденения с сервером"), MB_OK | MB_ICONERROR);
            }
            hThread = (HANDLE)_beginthreadex(NULL, NULL, ThreadFunc, NULL, NULL, NULL);
        } // if
    } // if
    DWORD cchSize = 50;
    GetComputerNameEx(ComputerNamePhysicalDnsHostname,host,&cchSize);
    return TRUE;
}
 
void OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify)
{
    if (BN_CLICKED == codeNotify)
    {
        HINSTANCE hInstance = GetWindowInstance(hwnd);
        switch (id)
        {
        case IDC_BUTTON_SEND:
        { 
            ButtonSend(hwnd);
        }
            break;
        case IDC_BUTTON_UPDATE:
        {
            ButtonUpdate(hwnd);
        }
            break;
        case IDC_BUTTON_ADD:
        {
            ButtonAdd(hwnd);
        }
            break;
        case IDC_BUTTON_CLEAR:
        {
            ButtonClearLB(hwnd);
        }
            break;
        }
    }//if
}
 
void OnDestroy(HWND hwnd)
{
    Package msg;
    StringCchCopyA(msg.recipients, 2, "0");
    WritePerSymbol(s, (char *)&msg, sizeof(msg));
    SHUTDOWN(s);
    WaitForSingleObject(hThread, INFINITE);
    CloseHandle(hThread);
    PostQuitMessage(0); // отправляем сообщение WM_QUIT
}
 
 
unsigned int CALLBACK ThreadFunc(LPVOID lpParameter)
{
    Package msg;
    for (;;)
    {
 
 
        // получаем текстовое сообщение
        int   n = ReadPerSymbol(s, (char *)&msg, sizeof(msg));
 
        if (SOCKET_ERROR != n) // сообщение успешно получено
        {
 
            if (strcmp(msg.message, "") == 0)
            {
 
                HWND hwndCB = GetDlgItem(hWnd, IDC_COMBOBOX);
                GetClientNames(msg.recipients, hwndCB);
 
 
            }
            else
            {
                HWND hwndLB = GetDlgItem(hWnd, IDC_LISTBOX);
 
                SendMessageA(hwndLB, LB_ADDSTRING, NULL, (LPARAM)msg.message);
            }
 
 
        } // if 
        else
        if (WSAEINTR == WSAGetLastError()) break;
 
 
    }
    return 0;
}
void GetClientNames(char string[], HWND hwndCB)
{
    ComboBox_ResetContent(hwndCB);
    int j = 0;
    unsigned int i = 0;
    do
    {
            int n = string[i];
            char *clientName = new char[n + 1];
            for (int k = 0; k < n; k++)
            {
                clientName[k] = string[i+1+k];
            }
            clientName[n] = '\0';
            ComboBox_AddString(hwndCB,clientName);
            delete[]clientName;
            i += n+1;
    } while (i < 4096 && string[i] != '\0');
    ComboBox_SetCurSel(hwndCB, 0);
}
int ReadPerSymbol(SOCKET s, char* buf, size_t length)
{
    int all = length;
    int received = 0;
    while (all > 0)
    {
        received = recv(s, buf, all, 0);
        if (received < 0) return SOCKET_ERROR;
        buf += received;
        all -= received;
    }
    return length;
}
 
int WritePerSymbol(SOCKET s, char* buf, size_t length)
{
    int all = length;
    int sended = 0;
    while (all > 0)
    {
        sended = send(s, buf, all, 0);
        if (sended < 0) return SOCKET_ERROR;
        buf += sended;
        all -= sended;
    }
    return length;
}
 
void ButtonSend(HWND hwnd)
{
    Package msg;
    HWND hwndEdit = GetDlgItem(hwnd, IDC_EDIT_MESSAGE);
    HWND hwndLB = GetDlgItem(hWnd, IDC_LISTB2);
    int sizeText = Edit_GetTextLength(hwndEdit);
    GetDlgItemTextA(hwnd, IDC_EDIT_MESSAGE, msg.message, sizeText + 1);
    char Buff[1024];
    StringCchPrintf(Buff, 1024, "%s",msg.message);
    StringCchPrintf(msg.message, 1024, "[%s]: %s",host,Buff);
    int cItems = ListBox_GetCount(hwndLB);
    int* indexes = new int[cItems];
    int numOfSelected = ListBox_GetSelItems(hwndLB, cItems, indexes);
    int size = 0;
    strcpy(msg.recipients, "");
    for (int i = 0; i < cItems; ++i)
    {
        ListBox_GetText(hwndLB, indexes[i], Buff);
        char c = strlen(Buff);
        StringCchPrintf(msg.recipients, 4096, "%s%c%s",msg.recipients,c,Buff);
    }
    WritePerSymbol(s, (char *)&msg, sizeof(msg));
    SetDlgItemTextA(hwnd, IDC_EDIT_MESSAGE, "");
}
 
void ButtonUpdate(HWND hwnd)
{
    Package msg;
    StringCchCopyA(msg.recipients, 2, "1");
    WritePerSymbol(s, (char *)&msg, sizeof(msg));
}
 
void ButtonAdd(HWND hwnd)
{
    HWND hwndCB = GetDlgItem(hwnd, IDC_COMBOBOX);
    HWND hwndLB = GetDlgItem(hwnd, IDC_LISTB2);
    char buf[MAX_PATH];
    int ind = ComboBox_GetCurSel(hwndCB);
    SendMessage(hwndCB, CB_GETLBTEXT, ind, (LPARAM)buf);
    SendMessageA(hwndLB, LB_ADDSTRING, NULL, (LPARAM)buf);
}
 
void ButtonClearLB(HWND hwnd)
{
    HWND hwndLB = GetDlgItem(hwnd, IDC_LISTB2);
    ListBox_ResetContent(hwndLB);
}