🚀 go-pugleaf

"Vladimir Stefanovic" <antivari@ptt.yu> wrote in message
news:41245031$1@newsgroups.borland.com...

> The bytes has been sent but the destination copy
> is usually mixed and/or damaged in some parts.

That is because when your server is receiving new data, it is overwriting
the existing buffered data instead of appending the new data to the end of
the buffer.  You need to change this line:

    Socket->ReceiveBuf( InboxDataBuffer->Memory, IncomingSize );

To this instead:

    Socket->ReceiveBuf( &((LPBYTE)(InboxDataBuffer->Memory))[OldSize],
IncomingSize );


Gambit

Uh, I hope this will work. I'm not curerntly at PC with BCB, so I'll
try this tomorrow.

Thanks a lot Remy. My productivity has increased many times
when I discovered these NGs, and primarily with your
assistence and suggestions.


Best regards,
Vladimir Stefanovic



>  You need to change this line:
>
>     Socket->ReceiveBuf( InboxDataBuffer->Memory, IncomingSize );
>
> To this instead:
>
>     Socket->ReceiveBuf( &((LPBYTE)(I
nboxDataBuffer->Memory))[OldSize],
> IncomingSize );
>
>
> Gambit
>
>

>Uh, I hope this will work

Yes, It worked perfectly...

I have read one of your posts some time ago...

> the client-side code you currently have will not work
> as-is if you are using non-blocking mode, because you
> are not checking for when SendBuffer() fails to send
> any data due to blocking.  When that happens, you have
> to wait for the OnWrite event to trigger before you can
> send more data again.  Otherwise, you are going to corrupt
> your data stream because not all of the data will be sent
> correctly.

... and I have the same situation in NonBlocking mode. How
can I addopt the code I have, to work synchronized with
OnWrite(), or I have to take a completely different approach?

Should that change also affect the servers receiving mechanism?

   BYTE Buffer [ BUFFER_SIZE ];
   int CurrentPosition = 0;
   int Delta;
   while ( ( Delta = OutboxDataBuffer->Size - CurrentPosition ) > 0 )
   {
      int NumberOfBytesRead = ( Delta < BUFFER_SIZE ? Delta : BUFFER_SIZE );
      OutboxDataBuffer->Seek( CurrentPosition, soFromBeginning );
      OutboxDataBuffer->ReadBuffer( Buffer, NumberOfBytesRead );
      int NumberOfBytesSent = ClientSocket->Socket->SendBuf( Buffer, NumberOfBytesRead );
      if ( NumberOfBytesSent < 1 ) // <--- this happens in non-blocking mode after 8K
         return; // Error ...
      CurrentPosition += NumberOfBytesSent;
    }


Just one more thing:

I thought that within Open/Close...

   ClientSocket->Open()
      ClientSocket->Socket->SendBuf()
   ClientSocket->Close()   

... I am addressing the same unique ServerSocketClientRead
instance:
 
   void __fastcall TserverForm::ServerSocketClientRead(TObject *Sender,
         TCustomWinSocket *Socket)
   {
      // ...
      int NewSize;
      // ... NewSize increases ...
      this->Caption = IntToStr ( NewSize );
   }

... but when Closed() and again Opened(), 'NewSize' continues
counting like it is static! In fact 'NewSize' continues counting
for all clients' connections when sending. I realize that this
must have some sense and I'm trying to figure it out. Is that
in connection with servers' blocking modes?

All this I need to find out the way how to:

* Deploy and recognize connection of a speciffic client and
somehow make it's own TMemoryStream for receiving, decoding
and adding to the shared list (with critical section involved).

* Inform the server what stream size to expect (embed that
into stream, for example first 10 bytes ASCII, or a separate
call)




Best regards,
Vladimir Stefanovic

> Is that in connection with servers' blocking modes?

Hi Remy,

I think I finally discovered the right way to connect to server
and not to think of the common OnRead().

I just do not know yet the best way to inform the server of
the expecting data size. Can I somehow involve TMemoryStream
in this code and so the final TMemoryStream::Size is the size
I expected?

Ig I have to imnform the server of the stream size separately,
how the server knows to whome is the received size addressed?


In this code I explicitely said that I want 44800 bytes.

[code is based on your samples in these ng-s]

void __fastcall TsrvForm::ServerSocketGetThread(TObject *Sender,
      TServerClientWinSocket *ClientSocket,
      TServerClientThread *&SocketThread)
{
   SocketThread = new TLanServerThread( false, ClientSocket );
}

void __fastcall TLanServerThread::ClientExecute()
{
   char *SomeBuffer = new char[44800];
   int BufferSize = 44800;

   TWinSocketStream *Stream = new TWinSocketStream ( ClientSocket,
5000 );

   try
   {
      while( ( !Terminated ) && ( ClientSocket->Connected ) )
      {
         if ( Stream->WaitForData ( 5000 ) )
         {
            if( !ReadData ( Stream, SomeBuffer, BufferSize ) )
               break;

            // use your buffered data as needed...
            FILE *p;
            AnsiString File = ExtractFilePath( ParamStr(0) ) +
"Copy.txt";
            p = fopen( File.c_str(), "wb+" );
            fwrite ( SomeBuffer, 1, 44800, p );
            fclose (p);
         }
      }
   }
   __finally
   {
      delete Stream;
      delete SomeBuffer;
   }

}

bool __fastcall TLanServerThread::ReadData( TWinSocketStream *Stream,
void *Buffer, int BufferSize )
{

   LPBYTE Buf = (LPBYTE)Buffer;
   int NumRead, TotalRead = 0;

   try
   {
      while ( TotalRead < BufferSize )
      {
         NumRead = Stream->Read( &Buf[TotalRead],
BufferSize-TotalRead );
         if( NumRead > 0 )
            TotalRead += NumRead;
         else
            return false;

      }
   }
   catch ( const Exception& )
   {
      return false;
   }

   return true;

}



Best regards,
Vladimir Stefanovic

"Vladimir Stefanovic" <spam@not.needed> wrote in message
news:41260071@newsgroups.borland.com...

> I just do not know yet the best way to inform the
> server of the expecting data size.

Just write the data's size to the socket before writing the actual data, and
then read the size before reading the data, ie:

    int size = the data size;
    ...->SendBuf(&size, sizeof(int));
    ...->SendBuf(buffer, size);

    //...

    void __fastcall TLanServerThread::ClientExecute()
    {
        TWinSocketStream *Stream = new TWinSocketStream(ClientSocket, 5000);
        try
        {
            while( (!Terminated) && (ClientSocket->Connected) )
            {
                if( Stream->WaitForData (5000) )
                {
                    int size = 0;
                    if( !ReadData(Stream, &size, sizeof(int)) )
                        break;

                    char *buffer = new char[size];
                    try
                    {
                        if( ReadData(Stream, buffer, size) )
                            // use your buffered data as needed...
                    }
                    __finally {
                        delete[] buffer;
                    }
                }
            }
        }
        __finally
        {
            delete Stream;
        }
    }


Gambit

Hi,

Yes, thanks... That's it.

I'm too tired these days to see the obvious solutions.

>                 if( Stream->WaitForData (5000) )
>                 {
>                     int size = 0;
>                     if( !ReadData(Stream, &size, sizeof(int)) )
>                         break;
>
>                     char *buffer = new char[size];
>                     try
>                     {
>                         if( ReadData(Stream, buffer, size) )
>                             // use your buffered data as needed...
>                     }



Best regards,
Vladimir Stefanovic