<message>
    <action>
        <name>Do Something</name>
        <param_count>2</param_count>
        <param ordinal="1" value="With this..." />
        <param ordinal="2" value="...and this!" />
    </action>
</message>

C>а протокол говорит, что ты мол получил, 1013 байт

C>короче возюкаться нужно... а так всё прекрасно начиналось.... (до большой частоты обращений к серверу )

so_4::ret_code_t
client_connection_t::read()
{
    // Пытаемся прочитать очередную порцию данных.
    unsigned int bytes_to_read = query_read_buf_size();
    auto_ptr_3::vect_ptr_t< char > buf(
        new char[ bytes_to_read ], bytes_to_read );
    unsigned int bytes_read;

    so_4::ret_code_t rc;
    /* m_phys_channel_ptr -- это объект, который физически работает с сокетом. */
    rc = m_phys_channel_ptr->read(
        buf.query(), bytes_to_read, bytes_read );
    if( rc == success )
    {
        // Чтение прошло без ошибок.
        size_t size;
        /* В моем случае данные могут быть заархивированны, метод transform_incoming распаковывает их и помещает в атрибут m_ibuf. */
        rc = transform_incoming( buf.query(), bytes_read, size );

        // Если что-то трансформировали, то нужно
        // поместить это в промежуточный буфер и
        // попробовать разобрать.
        if( rc == success && size )
            /* parse_ibuf -- это виртуальный метод, который переопределяется для разных типов соединений. */
            rc = parse_ibuf();
    }

    return rc;
}

/* Вот в этом производном классе разбираются данные, в которых есть специальный заголовок с длиной сообщения. */
so_4::ret_code_t
sop_client_connection_t::parse_ibuf()
{
    /* Идем в начало буфера чтобы начать его новый просмотр. */
    m_ibuf.set_pos( 0 );
    while( so_4::sop::package_header_t::e_image_size <= m_ibuf.size() )
    {
        // Считываем заголовок пакета и проверяем его.
        so_4::sop::package_header_t header;
        m_ibuf >> header;
        if( header.is_valid() )
        {
            // Заголовок корректен. Обрабатываем тело пакета.
            unsigned int body_size = header.size();
            // Если все тело пакета находится в буфере, то
            // изымаем его и отсылаем на обработку.
            if( so_4::sop::package_header_t::e_image_size +
                body_size <= m_ibuf.size() )
            {
                /* Сюда попадаем только, если в буфере сообщение находится целиком. */
                so_4::rt::msg_auto_ptr_t< msg_sop_package >
                    msg( new msg_sop_package() );
                msg->m_channel = m_comm_channel;
                msg->m_package.insert( 0, m_ibuf,
                    m_ibuf.pos(), body_size );
                // Заблокирован ли канал?
                bool is_blocked = ( msg->m_is_blocked =
                    in_package_processed( body_size ) );
                msg.send( communicator_agent_name(),
                    "msg_sop_package" );

                // Обработанные данные из буфера нужно изъять.
                /* Вот так данные из промежуточного буфера удаляются. После этого указатель перемещается в начало буфера. */
                m_ibuf.erase( 0,
                    so_4::sop::package_header_t::e_image_size +
                    body_size );

                // Если канал оказался заблокированным, то разбор
                // буфера нужно прекратить.
                if( is_blocked )
                    break;
            }
            else
                // В буфере недостаточно данных.
                // Просмотр буфера можно прекратить.
                break;
        }
        else
        {
            // Обнаружен некорректный заголовок.
            return so_4_make_rc( invalid_package_header,
                "Invalid SOP package header" );
        }
    }

    // Если после просмотра в буфере оказалось слишком
    // много данных, то это ошибка.
    if( m_ibuf.size() > m_ibuf_max_size )
    {
        return so_4_make_rc( ibuf_too_large,
            "Input buffer is too large" );
    }

    return so_4::ret_code_t();
}

CX>Приведи минимальный код, на котором проявляется ошибка. Думается, баг будет быстро найден.

bool process_data(SOCKET sock)
{
    /////////////////
        if ((received = recv(sock, buf, RECVBUFSIZ, 0)) != SOCKET_ERROR && received>2) {
      // здесь вот buf может являться тем злополучным сообщением (а может и не быть им).
      buf[received] = '\0';
            pushToStack(buf,received); // тут просто парсером прогоняю сообщение и кладу в стек сообщений
            return true;
    }
    return false;
}

/////////////////////////////////////////////////////////////////////////////
UINT ListenSockets(LPVOID lpvoid)
{
    while (true) {
            ///////////
        if ((accepted = accept(ssocket, (struct sockaddr *) &ca, (socklen_t *)&cal)) != SOCKET_ERROR){
                    int size=sizeof(sockaddr);
                    sockaddr_in adr;
                    int ret=getpeername(accepted,(sockaddr*)&adr,&size);
                    if(adr.sin_addr.S_un.S_addr==IP_CLIENT){
                if(clients.size()==0){
                    sprintf(buffer,"Client connected [%s]",inet_ntoa(adr.sin_addr));
                    clients.push_back(accepted);
                }else{
                    sprintf(buffer,"Client already connected [%s]. Ignored",inet_ntoa(adr.sin_addr));
                    shutdown_socket(&accepted);
                }
            }else{
                sprintf(buffer,"Illegal client want to connect [%s]",inet_ntoa(adr.sin_addr));
                shutdown_socket(&accepted);
            }
            toLog(buffer);
        }
        
        // Preparing descriptor sets
        FD_ZERO(&readfds);
        FD_ZERO(&exfds);
        FD_SET(ssocket, &exfds);
        tv.tv_sec = 1;
        tv.tv_usec = 0;
        maxfd = ssocket;

        for (CL::iterator ii = clients.begin(); ii != clients.end(); ++ii) {
            FD_SET((SOCKET )*ii, &readfds);
            FD_SET((SOCKET )*ii, &exfds);
            maxfd = max(maxfd, (SOCKET )*ii);
        }
    
        // select failing breaks the work
        if (select(maxfd + 1, &readfds, NULL, &exfds, &tv) == -1) break;
        
         // On exception in server socket also breaks immediately
        if(FD_ISSET(ssocket, &exfds)) break;
    
        // Test events on client sockets
        for (ii = clients.begin(); ii != clients.end(); ++ii) {
            if (FD_ISSET(*ii, &exfds)) {
                                toLog("Client exception");
                if (*ii != INVALID_SOCKET) shutdown_socket(&(*ii));
                if ((ii = clients.erase(ii)) == clients.end()) break;
            }
            if (FD_ISSET(*ii, &readfds) && !process_data(*ii)) {
                                toLog("Failed to read client");
                if (*ii != INVALID_SOCKET) shutdown_socket(&(*ii));
                if ((ii = clients.erase(ii)) == clients.end()) break;
            }
        }
    }
    for (CL::iterator ii = clients.begin(); ii != clients.end(); ++ii) {
        if (*ii != INVALID_SOCKET) shutdown_socket(&(*ii));
        if ((ii = clients.erase(ii)) == clients.end()) break;
    }
    /////////////////
  shutdown_socket(&ssocket);
    /////////////////
}

            if (FD_ISSET(*ii, &readfds) && !process_data(*ii)) {
                                toLog("Failed to read client");
                if (*ii != INVALID_SOCKET) shutdown_socket(&(*ii));
                if ((ii = clients.erase(ii)) == clients.end()) break;
            }

bool process_data(SOCKET sock)
{
    int received = 0, required = 2;
    while((received = recv(sock, buf + received, required - received, 0)) > 0);
    if(received == SOCKET_ERROR) return false;

    // Тут нужно особое внимание обратить на byte order. Если у тебя архитектура little-endian,
    // а значение высылается в сетевом порядке байт, то ntohs обязательна
    // short здесь в предположении что sizeof(short) == 2
    short size = ntohs(*reinterpret_cast<short *>(buf));
    
    required = size;
    received = 0;
    while((received = recv(sock, buf + received, required - received, 0)) > 0);
    if(received == SOCKET_ERROR) return false;
    
    buf[size] = '\0';
    pushToStack(buf, size);
    return true;
}

bool process_data(SOCKET sock)
{
    int received = 0, required = 2;
    while((received = recv(sock, buf + received, required - received, 0)) > 0);
    if(received == SOCKET_ERROR) return false;
    short size = ntohs(*reinterpret_cast<short *>(buf));
    
    required = size;
    received = 0;
    
        
        while((received = recv(sock, buf + received, required - received, 0)) > 0);
    if(received == SOCKET_ERROR) return false;
    
    
        buf[size] = '\0';
    pushToStack(buf, size);
    return true;
}

Первые два    Оставшаяся часть
байта             сообщения
    |                 |
+--------+------------------------+
| xx  xx | xx  xx  xx  xx  xx  xx |
+--------+------------------------+

C>bool process_data(SOCKET sock)
C>{
C>    int received = 0, required = 2;
C>    while((received = recv(sock, buf + received, required - received, 0)) > 0);
C>    if(received == SOCKET_ERROR) return false;
C>    short size = ntohs(*reinterpret_cast<short *>(buf));
    
C>    required = size;
C>    received = 0;
    
C>        
C>        while((received = recv(sock, buf + received, required - received, 0)) > 0);
C>    if(received == SOCKET_ERROR) return false;
C>    
    
C>        buf[size] = '\0';
C>    pushToStack(buf, size);
C>    return true;
C>}

C>