Delphi：（Indy）发送头记录，后跟文件

Question

I am currently trying to use Indy to write a custom higher level protocol on top of TCP. Essentially, I want to send a record across (using a stream) but this record can indicate that x bytes to follow will be an image file.

As such, when the record is recieved on the server, if it's contents indicate it's followed by an image, it needs to separate the record and image data.

var
Segment: TDPPSegment;
Segment2: TDPPSegment;
Buffer: TIdBytes;
Buffer2: TIdBytes;
Mem: TMemoryStream;
begin
if (Client.Connected) then begin

Segment.NameStr := 'Adrian';
Segment2.NameStr := 'Jon';

Mem := TMemoryStream.Create;
Mem.Write(Segment, SizeOf(Segment));
Mem.Write(Segment2, SizeOf(Segment2));

//The Size of the stream is 8 bytes here!
Client.IOHandler.Write(Mem, 0, False);

end;

To simulate the 'image file' I simply want to send TWO records consecutively; thats the aim. Notice here I am sending the whole memory stream at once (!) and NOT record by record. But interestingly, the server runs the OnExecute event twice!

var
Buffer: TIdBytes;
Segment: TDPPSegment;
Mem: TMemoryStream;
begin
Mem := TMemoryStream.Create;
AContext.Connection.IOHandler.ReadStream(Mem, SizeOf(TDPPSegment), False);

//Incoming stream size is FOUR bytes but TWICE!
Mem.Position := 0;
Mem.Read(Segment, SizeOf(TDPPSegment));
Showmessage(Segment.NameStr);

I want it to execute once, so in the future I can first read the header record (known size) and THEN see what/if anything is to follow and act accordingly..

Help would be greatly appreciated!

Thanks for reading, Adrian

Answer 1

Your records contain non-ShortString strings in them, as evident by the fact that the number of bytes occupied by the character data is larger than the number of bytes being written into the stream - meaning that pointer values (2 x SizeOf(Pointer)) are being written to the stream instead of the actual characters. As such, you will have to serialize your strings manually, such as by sending the string length followed by the actual characters. And if you plan on supporting Delphi 2009+, you have to take Unicode into account, so you should encode the strings before transmitting them, and then decode them on the receiving end.

Records are useful for organizing your data in memory, but usually not very ueful for transmitting data over a network, unless the records contain only POD types (and a string does not qualify as that).

Try this:

procedure WriteStrToIO(IO: TIdIOHandler; const S: String);
var
  Buf: TIdBytes;
  Len: Integer;
begin
  Buf := ToBytes(S, IndyUTF8Encoding);
  Len := Length(Buf);
  IO.Write(Len); 
  if Len > 0 then IO.Write(Buf); 
end;

var 
  Len: Integer;
  Buf: TIdBytes; // or whatever you want to use...
begin 
  if Client.Connected then
  begin 
    WriteStrToIO(Client.IOHandler, 'Adrian');

    Buf := ...; // secondary data
    Len := Length(Buf);
    Client.IOHandler.Write(Len);
    if Len > 0 then
      Client.IOHandler.Write(Buf);

    ...
  end;
end;

.

var 
  NameStr: String; 
  Buf: TIdBytes;
begin   
  with AContext.Connection.IOHandler do
  begin
    NameStr := ReadString(ReadInteger, IndyUTF8Encoding); 

    // read secondary data ...
    ReadBytes(Buf, ReadInteger);
  end;

  // ShowMessage() is not thread-safe!
  Windows.MessageBox(0, PChar(NameStr), 'NameStr', MB_OK); 
end;

As for the OnExecute event being triggered multiple times, that is normal behavior. That event is not tied to data transmissions at all. It is called in a continuous loop for the lifetime of the connection. Once you exit the event handler, it is triggered again immediately if the client is still connected. This is useful for message-based protocols like yours, where the event gets triggered, reads a single message waiting for data to arrive, exits, gets triggered again to read the next message waiting for data to arrive, and so on.