🚀 go-pugleaf

"mike" <mfbrowne@earthlink.nnet> wrote in message
news:4200e6a4$1@newsgroups.borland.com...

> Could you have a look at this code sample and see if in
> your opinion I am approaching the problem correctly.

In my opinion, you are not.

>  while ( true )

Here is the major caveat - for a non-blocking socket, when the OnRead event
is triggered, you need to read all available data from the socket and then
wait for the next OnRead event to be triggered before you can read again.
That means that you should maintain a secondary buffer for all incoming
data, and then parse your packets from that buffer when they are actually
available.

>    NbrBytesRead = Socket->ReceiveBuf( &Size, sizeof(int) ) ;

You are not making sure that sizeof(int) number of bytes are actually
available before reading them.  If ReceiveBuf() returns a value <
sizeof(int) then your Size value will not be complete.  Using the secondary
buffer approach can fix that.

>        memset( buffer, 0x00, sizeof( buffer ) ) ;

The buffer variable is a pointer, so sizeof(buffer) will always return
sizeof(char*), which is currently 4.  It will not return the allocated size
like you are expecting.


With all of that said, try something like the following instead:


    #define OFFSET_MEM(mem, pos) \
        &((LPBYTE)(mem))[(pos)]

    class TMyMemoryStream : public TMemoryStream
    {
    public:
        __fastcall TMyMemoryStream() : TMemoryStream() {}

        void* __fastcall Expand(int Count)
        {
            int OldSize = Size;
            Size = (OldSize + Count);
            return OFFSET_MEM(Memory, OldSize);
        }

        char* __fastcall ReadPacket()
        {
            int iSize = Size;
            if( (iSize-Position) >= sizeof(int) )
            {
                int PacketSize = 0;
                Read(&PacketSize, sizeof(int));
                if( (iSize-Position) >= PacketSize )
                {
                    char *packet = new char[Size];
                    Read(packet, Size);
                    return packet;
                }
                Seek(-sizeof(int), soFromCurrent);
            }
            return NULL;
        }
    };


    TMyMemoryStream *IncomingBuffer;

    __fastcall TStdPopWin::TStdPopWin(TComponent *Owner)
        : TForm(Owner)
    {
        IncomingBuffer = new TMyMemoryStream;
    }

    __fastcall TStdPopWin::~TStdPopWin()
    {
        delete IncomingBuffer;
    }

    void __fastcall TStdPopWin::ClientSocket1Conect(TObject *Sender,
TCustomWinSocket *Socket)
    {
        IncomingBuffer->Clear();
    }

    void __fastcall TStdPopWin::ClientSocket1Disconect(TObject *Sender,
TCustomWinSocket *Socket)
    {
        IncomingBuffer->Clear();
    }

    void __fastcall TStdPopWin::ClientSocket1Read(TObject *Sender,
TCustomWinSocket *Socket)
    {
        int BytesToReceive = Socket->ReceiveLength();
        if( BytesToReceive <= 0 )
            return;

        void *NewMemory = IncomingBuffer->Expand(BytesToReceive);

        int BytesRead = Socket->ReceiveBuf(NewMemory, BytesToReceive);
        if( BytesRead <=0 )
            return;

        while( true )
        {
            char *packet = IncomingBuffer->ReadPacket();
            if( packet == NULL )
                break;

            // do Something with packet...
            delete[] packet;
        }
    }


Gambit