Pascal (Lazarus/Delphi)

MIME Content-Transfer-Encoding Header Field

See more MIME Examples

Explains the Content-Transfer-Encoding header field and how it affects how data is stored in the MIME.

Pascal (Lazarus/Delphi)

program ChilkatDemo;

// Demonstrates using the Chilkat Pascal wrapper via the C bridge DLL.
// Builds as a console application under Lazarus (FPC) or Delphi.

{$IFDEF FPC}
  {$MODE DELPHI}
{$ENDIF}
{$APPTYPE CONSOLE}

uses
  {$IFDEF UNIX}
  cthreads,
  {$ENDIF}
  SysUtils,
  CkDllLoader,
  Chilkat.Mime,
  Chilkat.StringBuilder;

// ---------------------------------------------------------------------------

procedure RunDemo;
var
  success: Boolean;
  sbJpgBase64: TStringBuilder;
  mime: TMime;
  mimeBytes: TBytes;
  jpgBytes: TBytes;
  jpgBase64: string;
  mimeStr: string;

begin
  success := False;

  //  The Content-Transfer-Encoding header field is typically set to one of these values:
  //  
  //    base64
  //    quoted-printable
  //    binary
  //    8bit
  //    7bit

  //  If the encoding is base64 or quoted-printable, then the bytes of the content are encoded as such.
  //  The values "8bit", "7bit", and "binary" all imply that NO encoding has been performed.

  //  Here are some guidelines and hints:
  //  
  //  1) "8bit", "7bit", and "binary" encodings (i.e. NO encoding) results in the smallest MIME.

  //  2) A "binary" encoding implies non-text data.  Binary MIME CANNOT be retrieved as a string.  It can only be retrieved as a byte array.

  //  3) "8bit" and "7bit" encodings imply text.  
  //     7bit implies that the text is us-ascii (all byte values less than or equal to 0x7F).
  //     8bit implies that the text contains non-us-ascii chars.

  //  4) Base64 is the best choice for encoding non-text data, such as PDF's, images, etc.

  //  5) quoted-printable is the best choice for encoding text data where most chars are going to be us-ascii. This would typically 
  //     include all Western European languages.  For Asian, Arabic, Hebrew, etc. where most chars in the text are non-us-ascii,
  //     the most efficient encoding would be base64.  

  //  Let's demonstrate with this small JPG image.

  sbJpgBase64 := TStringBuilder.Create;
  sbJpgBase64.Append('/9j/4AAQSkZJRgABAQEASABIAAD//gAmRmlsZSB3cml0dGVuIGJ5IEFkb2JlIFBob3Rvc2hvcD8g' + #13#10);
  sbJpgBase64.Append('NC4w/9sAQwAQCwwODAoQDg0OEhEQExgoGhgWFhgxIyUdKDozPTw5Mzg3QEhcTkBEV0U3OFBtUVdf' + #13#10);
  sbJpgBase64.Append('YmdoZz5NcXlwZHhcZWdj/9sAQwEREhIYFRgvGhovY0I4QmNjY2NjY2NjY2NjY2NjY2NjY2NjY2Nj' + #13#10);
  sbJpgBase64.Append('Y2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2Nj/8IAEQgAFAAUAwERAAIRAQMRAf/EABcAAAMBAAAA' + #13#10);
  sbJpgBase64.Append('AAAAAAAAAAAAAAIDBAX/xAAYAQADAQEAAAAAAAAAAAAAAAABAgMEAP/aAAwDAQACEAMQAAAB2kZY' + #13#10);
  sbJpgBase64.Append('NNEijWKddfTmLgALWH//xAAbEAACAgMBAAAAAAAAAAAAAAABAgMRAAQSE//aAAgBAQABBQL0XqN+' + #13#10);
  sbJpgBase64.Append('pM2aqJGMiqFFCyg7z//EABwRAAICAgMAAAAAAAAAAAAAAAERAAIQIQMSUf/aAAgBAwEBPwHqU5aq' + #13#10);
  sbJpgBase64.Append('Axx+y1tMQl4elj//xAAcEQEAAQUBAQAAAAAAAAAAAAABEQACEBIhA1H/2gAIAQIBAT8B3Bhqy7Zc' + #13#10);
  sbJpgBase64.Append('enyiwmGgDhiOzj//xAAdEAABAwUBAAAAAAAAAAAAAAABAAIREBIhIkFR/9oACAEBAAY/ArZyn+Cg' + #13#10);
  sbJpgBase64.Append('xtxWuJaoCnqDuin/xAAcEAABBAMBAAAAAAAAAAAAAAABABEhYRAxQVH/2gAIAQEAAT8hkEwPUUR9' + #13#10);
  sbJpgBase64.Append('DYfE4nxtRpIkBTsayuALIiuY/9oADAMBAAIAAwAAABDWPTsf/8QAGhEAAwADAQAAAAAAAAAAAAAA' + #13#10);
  sbJpgBase64.Append('AAEREDFBIf/aAAgBAwEBPxC0DVPcWm+Ce4OesrkE6bjH/8QAGBEBAQEBAQAAAAAAAAAAAAAAAREA' + #13#10);
  sbJpgBase64.Append('QRD/2gAIAQIBAT8QahMiOc8YgSrnTY3ELclHXn//xAAcEAEBAAIDAQEAAAAAAAAAAAABEQAhMUFx' + #13#10);
  sbJpgBase64.Append('EFH/2gAIAQEAAT8Qn3igmSZSj+c4N4zapMy9IjFV98wncN2iuLFsCEbDGxQkI6RO/n//2Q==' + #13#10);

  mime := TMime.Create;
  mime.ContentType := 'image/jpeg';
  mime.SetBodyFromEncoded('base64',sbJpgBase64.GetAsString());

  WriteLn(mime.GetMime());
  WriteLn('-');

  //  The result:
  //  
  //  	Content-Type: image/jpeg
  //  	Content-Transfer-Encoding: base64
  //  
  //  	/9j/4AAQSkZJRgABAQEASABIAAD//gAmRmlsZSB3cml0dGVuIGJ5IEFkb2JlIFBob3Rvc2hvcD8g
  //  	NC4w/9sAQwAQCwwODAoQDg0OEhEQExgoGhgWFhgxIyUdKDozPTw5Mzg3QEhcTkBEV0U3OFBtUVdf
  //  	YmdoZz5NcXlwZHhcZWdj/9sAQwEREhIYFRgvGhovY0I4QmNjY2NjY2NjY2NjY2NjY2NjY2NjY2Nj
  //  	Y2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2Nj/8IAEQgAFAAUAwERAAIRAQMRAf/EABcAAAMBAAAA
  //  	AAAAAAAAAAAAAAIDBAX/xAAYAQADAQEAAAAAAAAAAAAAAAABAgMEAP/aAAwDAQACEAMQAAAB2kZY
  //  	NNEijWKddfTmLgALWH//xAAbEAACAgMBAAAAAAAAAAAAAAABAgMRAAQSE//aAAgBAQABBQL0XqN+
  //  	pM2aqJGMiqFFCyg7z//EABwRAAICAgMAAAAAAAAAAAAAAAERAAIQIQMSUf/aAAgBAwEBPwHqU5aq
  //  	Axx+y1tMQl4elj//xAAcEQEAAQUBAQAAAAAAAAAAAAABEQACEBIhA1H/2gAIAQIBAT8B3Bhqy7Zc
  //  	enyiwmGgDhiOzj//xAAdEAABAwUBAAAAAAAAAAAAAAABAAIREBIhIkFR/9oACAEBAAY/ArZyn+Cg
  //  	xtxWuJaoCnqDuin/xAAcEAABBAMBAAAAAAAAAAAAAAABABEhYRAxQVH/2gAIAQEAAT8hkEwPUUR9
  //  	DYfE4nxtRpIkBTsayuALIiuY/9oADAMBAAIAAwAAABDWPTsf/8QAGhEAAwADAQAAAAAAAAAAAAAA
  //  	AAEREDFBIf/aAAgBAwEBPxC0DVPcWm+Ce4OesrkE6bjH/8QAGBEBAQEBAQAAAAAAAAAAAAAAAREA
  //  	QRD/2gAIAQIBAT8QahMiOc8YgSrnTY3ELclHXn//xAAcEAEBAAIDAQEAAAAAAAAAAAABEQAhMUFx
  //  	EFH/2gAIAQEAAT8Qn3igmSZSj+c4N4zapMy9IjFV98wncN2iuLFsCEbDGxQkI6RO/n//2Q==
  //  

  //  Set the Content-Transfer-Encoding to "binary" by setting the Encoding property.
  mime.Encoding := 'binary';

  //  Try to get the MIME string.  This CANNOT be done.  The bytes of the JPG image do not
  //  represent chars, and to return a string means that bytes must be interpreted according
  //  to some character encoding (such as utf-8).  Non-text binary bytes can only be 
  //  contained in a string IF encoded in some way. Encodings such as Base64, quoted-printable,
  //  URL, etc. exist to make it possible to represent binary data in string format.   
  WriteLn(mime.GetMime());
  WriteLn('-');

  //  We CAN get the binary MIME as bytes..

  mimeBytes := mime.GetMimeBytes();

  //  Regardless of the Content-Transfer-Encoding, the 
  //  body content can always be retrieved and the body bytes
  //  decoded from whatever encoding is used..

  jpgBytes := mime.GetBodyBinary();

  //  To get the body in base64 format, first make sure
  //  the Content-Transfer-Encoding is base64, then call GetBodyEncoded.
  mime.Encoding := 'base64';
  jpgBase64 := mime.GetBodyEncoded();
  WriteLn(jpgBase64);
  WriteLn('-');

  //  Let's go back to "binary" MIME..
  mime.Encoding := 'binary';

  //  Let's say we have MIME, and it was loaded directly from a file, or from
  //  a byte array.  (It was not loaded from the contents of a string variable.)
  //  We don't know whether the MIME contains binary or 8bit encodings, and thus
  //  we dont' know if the MIME is safe to get as a string.
  //  The Convert8Bit method can be called to recursively traverse the MIME and set
  //  all 8bit or binary encodings to "base64".  This makes the MIME safe for storing in
  //  a string.
  mime.Convert8Bit();
  mimeStr := mime.GetMime();
  WriteLn(mimeStr);
  WriteLn('-');


  sbJpgBase64.Free;
  mime.Free;

end;

// ---------------------------------------------------------------------------

begin

  try
    RunDemo;
  except
    on E: Exception do
      WriteLn('Unhandled exception: ', E.ClassName, ': ', E.Message);
  end;

  WriteLn;
  {$IFDEF MSWINDOWS}
  WriteLn('Press Enter to exit...');
  ReadLn;
  {$ENDIF}
end.