Indy10, IdTCPClient's IOHandler send additional data

Question

Trying to send a data to another machine. I use C++Builder XE6 and Indy10.

TMemoryStream *sms = new TMemoryStream();

sms->Write(msgData, msgSize);

Form1->IdTCPClient1->IOHandler->WriteBufferOpen();
Form1->IdTCPClient1->IOHandler->Write(sms, 0, true);
Form1->IdTCPClient1->IOHandler->WriteBufferFlush();

delete sms;

When I checked send data with Wireshark, I sent data that additional data and msgData to the machine. The additional data is " 00 00 00 20 ", and it is at head of sending data.

Does IdTcpClient usually send additional data like this?

Remy Lebeau Remy Lebeau · Accepted Answer · 2014-08-22T01:59:15

It is sending extra data because you are setting the AWriteByteCount parameter of Write(TStream) to true. 00 00 00 20 is the stream size in network byte order. msgSize is 0x00000020, aka 32. If you do not want the stream size sent, you need to set the AWriteByteCount parameter to false instead:

Form1->IdTCPClient1->IOHandler->Write(sms, 0, false);

Also, you should be using WriteBufferClose() instead of WriteBufferFlush(), and do not forget to call WriteBufferCancel() if Write() raises an exception. WriteBufferClose() sends the buffered data to the socket and then closes the buffer so subsequent writes are not buffered. WriteBufferFlush() sends the buffered data to the socket, but does not close the buffer, thus subsequent writes will be buffered.

Also, you can simplify the overhead a little by replacing TMemoryStream with TIdMemoryBufferStream, so that you do not have to make a separate copy of your message data in memory:

TIdMemoryBufferStream *sms = new TIdMemoryBufferStream(msgData, msgSize);
try
{
    Form1->IdTCPClient1->IOHandler->WriteBufferOpen();
    try
    {
        Form1->IdTCPClient1->IOHandler->Write(sms, 0, true); // or false
        Form1->IdTCPClient1->IOHandler->WriteBufferClose();
    }
    catch (const Exception &)
    {
        Form1->IdTCPClient1->IOHandler->WriteBufferCancel();
        throw;
    }
}
__finally
{
    delete sms;
}

Alternatively, use a RAII approach:

class BufferIOWriting
{
private:
    TIdIOHandler *m_IO;
    bool m_Finished;

public:
    BufferIOWriting(TIdIOHandler *aIO) : m_IO(aIO), m_Finished(false)
    {
        IO->WriteBufferOpen();
    }

    ~BufferIOWriting()
    {
        if (m_Finished)
            m_IO->WriteBufferClose();
        else
            m_IO->WriteBufferCancel();
    }

    void Finished()
    {
        m_Finished = true;
    }
};

{
    std::auto_ptr<TIdMemoryBufferStream> sms(new TIdMemoryBufferStream(msgData, msgSize));
    BufferIOWriting buffer(Form1->IdTCPClient1->IOHandler);
    Form1->IdTCPClient1->IOHandler->Write(sms.get(), 0, true); // or false 
    buffer.Finished();
}

With that said, I would suggest just getting rid of write buffering altogether:

TIdMemoryBufferStream *sms = new TIdMemoryBufferStream(msgData, msgSize);
try
{
    Form1->IdTCPClient1->IOHandler->Write(sms, 0, true); // or false 
}
__finally
{
    delete sms;
}

Or:

{
    std::auto_ptr<TIdMemoryBufferStream> sms(new TIdMemoryBufferStream(msgData, msgSize));
    Form1->IdTCPClient1->IOHandler->Write(sms.get(), 0, true); // or false 
}

Write buffering is useful when you need to make multiple related Write() calls that should have their data transmitted together in as few TCP frames as possible (in other words, letting the Nagle algorithm do its job better). For instance, if you need to Write() individual fields of your message. Write buffering does not make much sense to use when making a single Write() call, especially of such a small size. Let Write(TStream) handle its own buffering internally for you.

Indy10, IdTCPClient's IOHandler send additional data

1 Answers