Boost Tcp Client收到崩溃

Question

I have been working recently with the Boost library for windows visual studio 2015. I have been recently working on a server and client that can easily transfer data via tcp connection. But recently I was trying to send a Base64 encoded file string to the client which is roughly 366,660 Bytes of data. To do this I split up the data into packets that are about 1000 in size. (not sure what the max size is) But anyway the server sends the data completely fine but when the client receives more than 160,000 bytes it crashes with no exceptions.

Client:

try
{
    for (static int i = 1000; i <= sizeofpackets /*(366,660) (currently 170,000 for testing)*/; i += 1000)
    {
        char Buffer[1000];
        memset(Buffer, 0, 1000);
        boost::asio::read(s, boost::asio::buffer(Buffer, 1000));
        std::cout << i << std::endl;
    }
}
catch (std::exception& e)
{
    std::cerr << "Exception: " << e.what() << "\n";
}

Server:

for (int i = 1000; i <= 170000; i += 1000)
{
    std::string NewData = encodedBuffer.substr(i - 1000, i);
    NewData.erase(0, i - 1000);
    boost::asio::write(*sock, boost::asio::buffer(NewData, 1000));
    std::cout << NewData.size() + i - 1000 << std::endl;
    NewData.clear();
}

Any comments or suggestion would help greatly!

Answer 1

You haven't posted your complete code, so it is hard to tell, but your problem might be the way you are handling strings, not the way you are handling the socket transfers (the substr() member function takes a start offset and a size, and it looks like you are trying to use an ever-increasing size for NewData).

The following (complete) code, which uses your client and server code as a reference, but with the string handling changed, does transfer 170000 bytes just fine on my machine, so it may help:

#include <boost/asio/io_service.hpp>
#include <boost/asio/write.hpp>
#include <boost/asio/read.hpp>
#include <boost/asio/buffer.hpp>
#include <boost/asio/streambuf.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <array>
#include <string>
#include <iostream>


namespace
{
    const size_t BIG_MESSAGE_SIZE = 170000;
    const size_t BLOCK_SIZE = 1000;

    void doTX(boost::asio::ip::tcp::socket& socket, size_t& TXsize)
    {
        char rawBuffer[BIG_MESSAGE_SIZE] = { 0 }; // raw data to send
        std::string encodedBuffer(rawBuffer, BIG_MESSAGE_SIZE);
        for (size_t i = 0; i < BIG_MESSAGE_SIZE; i += BLOCK_SIZE)
        {
            std::string NewData = encodedBuffer.substr(i, BLOCK_SIZE);
            TXsize += boost::asio::write(socket, boost::asio::buffer(NewData, BLOCK_SIZE));
        }
    }

    void doRX(boost::asio::ip::tcp::socket& socket, size_t& RXsize)
    {
        for (size_t i = 0; i < BIG_MESSAGE_SIZE; i += BLOCK_SIZE)
        {
            char Buffer[BLOCK_SIZE];
            memset(Buffer, 0, BLOCK_SIZE);
            RXsize += boost::asio::read(socket, boost::asio::buffer(Buffer, BLOCK_SIZE));
        }
    }
}

int main(int argc, char * argv[])
{
    std::cout << "Running:" << std::endl;

    int port = 9876;

    boost::asio::io_service ios;
    boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::address::from_string("127.0.0.1"), port);
    boost::asio::ip::tcp::acceptor acceptor(ios, endpoint);
    boost::asio::ip::tcp::socket TXsocket(ios);
    boost::asio::ip::tcp::socket RXsocket(ios);

    TXsocket.connect(endpoint);
    acceptor.accept(RXsocket);

    size_t TXsize = 0;
    size_t RXsize = 0;

    doTX(TXsocket, TXsize);
    doRX(RXsocket, RXsize);

    std::cout << TXsize << " " << RXsize << std::endl;

    return 0;
}