Using Caché Internet Utilities Sending and Receiving Email [Home] [Back] [Next]

• Supported Email Protocols
• How Caché Represents MIME Email Messages
• Creating Single-part Email Messages
• Creating Multipart Email Messages
• Specifying Email Message Headers
• Adding Attachments to a Message
• Using an SMTP Server to Send Email
• Fetching Email from a POP3 Server
• Working with a Received Email Message
• Automatic Encoding and Character Translation

• Caché provides an object representation of MIME email messages. It supports text and non-text attachments, single-part or multipart message bodies, and headers in ASCII and non-ASCII character sets. (For more general support of MIME parts, see the chapter “Creating and Writing MIME Messages.”)
• You can send email via an SMTP server. SMTP (Simple Mail Transport Protocol) is the Internet standard for sending email.
• You can also retrieve email from an email server via POP3, the most common standard for retrieving email from remote servers.

• A set of message headers, each of which contains information such as the address to which the message is sent. This also includes the Mime-Type header and the Content-Type header for the entire message.
  For a multipart message, the Content-Type header must be multipart/mixed or some other subtype of multipart; the MIME standard has many variants.
• Multiple message parts, each of which consists of the pieces:
  • A set of content headers, which includes the Content-Type header and other headers specific to this part.
  • A body, which is either text or binary, and which can be in a different character set than the bodies of other parts.

• To represent an ordinary, one-part message, you use %Net.MailMessage
• To represent a multipart message, you use %Net.MailMessage as the parent message and you use multiple instances of %Net.MailMessagePart as its parts.

1. Create an instance of %Net.MailMessage.
   Tip:

   You can specify a character set as the argument to %New(); if you do so, that sets the Charset property for the message. For information on how this affects the message, see “Automatic Encoding and Character Translation.”
2. Set the To, From, and Subject properties of your instance.
   • To — The list of email addresses to which this message will be sent. This property is a standard Caché list class; to work with it, you use the standard list methods: Insert(), GetAt(), RemoveAt(), Count(), and Clear().
   • From — The email address this message is sent from.
   • Subject — The subject of the message, if this is required by the SMTP server you are using.
3. Optionally set Date, Cc, Bcc, and other properties. For details, see “Specifying Basic Email Headers.”
4. If the message is not plain text, set the following properties to indicate the kind of message you are creating:
   • If this is an HTML message, set the IsHTML property to 1.
   • If this is a binary message, set the IsBinary property to 1.
5. To specify the character set of the message and its headers, set the Charset property as needed. (For details on how this affects the message, see “Automatic Encoding and Character Translation.”)
   Important:

   It is important to specify the character set before you add the contents of the message.
6. Add the contents of the message:
   • For plain text or HTML, use the TextData property, which is an instance of %FileCharacterStream. You do not need to specify the TranslateTable property of this stream; that occurred automatically when you specified the character set of the mail message.
   • For binary data, use the BinaryData property, which is an instance of %FileBinaryStream.
   Tip:

   When you specify the Filename property of the stream, be sure to use a directory to which the users will have write access.
   To work with these properties, use the standard stream methods: Write(), WriteLine(), Read(), ReadLine(), Rewind(), MoveToEnd(), and Clear(). You can also use the Size property of the stream, which gives you the size of the message contents.

ClassMethod CreateTextMessage() As %Net.MailMessage
{
    Set msg = ##class(%Net.MailMessage).%New()
    set msg.From = "test@test.com"
    Do msg.To.Insert("xxx@xxx.com")
    Do msg.Cc.Insert("yyy@yyy.com")
    Do msg.Bcc.Insert("zzz@zzz.com")
    Set msg.Subject="subject line here"
    Set msg.IsBinary=0
    Set msg.IsHTML=0
    Do msg.TextData.Write("This is the message.")
    
    Quit msg
}

ClassMethod SimpleMessage() As %Net.MailMessage
{
  Set msg = ##class(%Net.MailMessage).%New()
  Set msg.Subject="Simple message "_$h
  Set msg.IsBinary=0
  Set msg.IsHTML=0
  Do msg.TextData.Write("This is the message.")
  Quit msg
}

1. Create an instance of %Net.MailMessage and set its To, From, and Subject properties. Optionally set other properties to specify other message headers.
2. Set the IsMultiPart property to 1.
3. Set the MultiPartType property to one of the following: "related", "alternative", or "mixed". This affects the Content-Type header of the entire message.
4. For each part that the message should contain, create an instance of %Net.MailMessagePart and specify its properties as described in “Creating Single-part Email Messages” — starting with step 4.
5. For the parent email message, set the Parts property, which is an array. Insert each child message part into this array.

• To — (Required) The list of email addresses to which this message will be sent. This property is a standard Caché list; to work with it, you use the standard list methods: Insert(), GetAt(), RemoveAt(), Count(), and Clear().
• From — (Required) The email address this message is sent from.
• Date — The date of this message.
• Subject — (Required) A string containing the subject for this message.
• Sender — The actual sender of the message.
• Cc — The list of carbon copy addresses to which this message will be sent.
• Bcc — The list of blind carbon copy addresses to which this message will be sent.

• If the message is plain text (IsHTML equals 0 and IsBinary equals 0), the Content-Type header is set to "text/plain".
• If the message is HTML (IsHTML equals 1 and IsBinary equals 0), the Content-Type header is set to "text/html".
• If the message is binary (IsBinary equals 1), the Content-Type header is set to "application/octet-stream".
• If the message is multipart, the Content-Type header is set as appropriate for the value of the MultiPartType property.

• For a binary message or message part: "base64"
• For a text message or message part: "quoted-printable"

 do msg.Headers.SetAt(1,"X-Priority")
 do msg.Headers.SetAt("High","X-MSMail-Priority")
 do msg.Headers.SetAt("High","Importance")

method AttachFile(Dir As %String, 
                  File As %String, 
                  isBinary As %Boolean = 1, 
                  charset As %String = "", 
                  ByRef count As %Integer) as %Status

method AttachStream(stream As %Stream.Object, 
                    Filename As %String, 
                    isBinary As %Boolean = 1, 
                    charset As %String = "", 
                    ByRef count As %Integer) as %Status

method AttachNewMessage() as %Net.MailMessagePart

method AttachEmail(mailmsg As %Net.MailMessage)

ClassMethod MessageWithAttachment() As %Net.MailMessage
{
  Set msg = ##class(%Net.MailMessage).%New()
  Set msg.Subject="Message with attachment "_$h
  Set msg.IsBinary=0
  Set msg.IsHTML=0
  Do msg.TextData.Write("This is the main message body.")

  //add an attachment
  Set status=msg.AttachFile("c:\", "GNET.pdf")
  If $$$ISERR(status) {
    Do $System.Status.DisplayError(status)
    Quit $$$NULLOREF
  }
  
  Quit msg
}

1. Create an instance of %Net.SMTP and set its properties as needed, especially the following:
   • smtpserver is the name of the SMTP server you are using.
   • port is the port you are using on the SMTP server; the default is 25.
   • timezone specifies the time zone of the server, as specified by RFC 822, for example "EST" or "-0400" or "LOCAL". If this is not set, the message uses universal time.
   This object describes the SMTP server you will use.
2. If the SMTP server requires authentication, specify the necessary credentials. To do so:
   1. Create an instance of %Net.Authenticator.
   2. Set the UserName and Password properties of this object.
   3. Set the authenticator property of your %Net.SMTP instance equal to this object.
   4. If the message itself has an authorized sender, set the AuthFrom property of your %Net.SMTP instance.
3. To use an SSL/TLS connection to the SMTP server:
   1. Set the SSLConfiguration property to the name of the activated SSL/TLS configuration to use.
      For information on creating and managing SSL/TLS configurations, see “Using SSL/TLS with Caché” in the Caché Security Administration Guide. The SSL/TLS configuration includes an option called Configuration Name, which is the string to use in this setting.
   2. Set the UseSTARTTLS property to either 0 or 1.
      In most cases, use the value 0. Use the value 1 for the case in which the server interaction begins on a normal TCP socket and then switches to TLS on the same port as the normal socket. For details, see RFC 3207.
   3. Optionally set the SSLCheckServerIdentity property to 1. Do this if you want to verify the host server name in the certificate.
4. Create the email message to send (as described in “Creating Single-part Email Messages” and “Creating Multipart Email Messages”).
5. Call the Send() method of your SMTP instance. This method returns a status, which you should check.
6. If the returned status indicates an error, check the Error property, which contains the error message itself.
7. Check the FailedSend property, which contains a list of email addresses for which the send action failed.

Set ^%SYS("StreamLocation","SAMPLES")="/tmp" 

ClassMethod HotPOPAsSMTP() As %Net.SMTP
{
  Set server=##class(%Net.SMTP).%New()
  Set server.smtpserver="smtp.hotpop.com"
  //HotPOP SMTP server uses the default port (25)
  Set server.port=25
  
  //Create object to carry authentication
  Set auth=##class(%Net.Authenticator).%New()
  Set auth.UserName="isctest@hotpop.com"
  Set auth.Password="123pass"
  
  Set server.authenticator=auth
  Set server.AuthFrom=auth.UserName
  Quit server
}

ClassMethod SendSimpleMessage(server As %Net.SMTP) As %List
{
  Set msg = ##class(%Net.MailMessage).%New()
  Set From=server.authenticator.UserName
  Set:From="" From="xxx@xxx.com"
  Set msg.From = From
  
  Do msg.To.Insert("xxx@xxx.com")
  //Do msg.Cc.Insert("yyy@yyy.com")
  //Do msg.Bcc.Insert("zzz@zzz.com")
  Set msg.Subject="Unique subject line here "_$H
  Set msg.IsBinary=0
  Set msg.IsHTML=0
  Do msg.TextData.Write("This is the message.")
  
  Set status=server.Send(msg)
  If $$$ISERR(status) {
    Do $System.Status.DisplayError(status)
    Write server.Error
    Quit ""
  }
  Quit server.FailedSend
}

ClassMethod YPOPsAsSMTP() As %Net.SMTP
{
  Set server=##class(%Net.SMTP).%New()
  //local host acts as the server
  Set server.smtpserver="127.0.0.1"
  //YPOPs uses default port, apparently
  Set server.port=25
  
  //Create object to carry authentication
  Set auth=##class(%Net.Authenticator).%New()
  //YPOPs works with a Yahoo email account
  Set auth.UserName="isc.test@yahoo.com"
  Set auth.Password="123pass"
  
  Set server.authenticator=auth
  Set server.AuthFrom=auth.UserName
  Quit server
}

ClassMethod SendMessage(server As %Net.SMTP, msg as %Net.MailMessage) as %Status
{
  Set From=server.authenticator.UserName
  //make sure From: user is same as used in authentication
  Set msg.From = From
  
  //finish addressing the message
  Do msg.To.Insert("xxx@xxx.com")
  //send the message to various test email addresses
  Do msg.To.Insert("isctest@hotpop.com")
  Do msg.To.Insert("isc_test@hotmail.com")
  Do msg.To.Insert("isctest001@gmail.com")
  Do msg.To.Insert("isc.test@yahoo.com")
  
  Set status=server.Send(msg)
  If $$$ISERR(status) {
    Do $System.Status.DisplayError(status)
    Write server.Error
    Quit $$$ERROR($$$GeneralError,"Failed to send message")
  }
  Quit $$$OK
}

• AllowHeaderEncoding specifies whether the Send() method encodes non-ASCII header text. The default is 1, which means that non-ASCII header text is encoded as specified by RFC 2047.
• ContinueAfterBadSend specifies whether to continue trying to send a message after detecting a failed email address. If ContinueAfterBadSend is 1, the system will add the failed email address to the list in the FailedSend property. The default is 0.
• ShowBcc specifies whether the Bcc headers are written to the email message. These will normally be filtered out by the SMTP server.

• Communicating with a POP3 Server
• Getting Information about the Mailbox
• Fetching Messages from the Mailbox
• Saving Attachments as Files
• Getting Attached Email Messages
• Other Message Retrieval Methods
• Deleting Messages

1. Create an instance of %Net.POP3. This object describes the POP3 server you will use.
2. Optionally specify the following properties of your instance of %Net.POP3:
   • port — Specifies the port you will use; the default is 110.
   • timeout — Specifies the read timeout in seconds; the default is 30 seconds.
   • StoreAttachToFile — Specifies whether to save each attachment to a file, when a message is read (when the message includes the content-disposition; attachment header). The default is false.
     Note that this setting does nothing unless AttachDir is also set.
   • StoreInlineToFile — Specifies whether to save each inline attachment to a file, when a message is read (when the message includes the content-disposition; inline header). The default is false.
     Note that this setting does nothing unless AttachDir is also set.
   • AttachDir — Specifies the directory into which the attachment are saved. There is no default. Make sure to terminate the name of the directory with a slash (/) or backslash (\), as appropriate for the operating system. Also make sure that this is directory already exists, and the users have write access to it.
   • IgnoreInvalidBase64Chars — Specifies whether to ignore invalid characters found during base–64 decoding. The default is false (and invalid characters result in an error). Note that RFC 2045 is ambiguous about whether unexpected characters should be ignored or should result in an error during base–64 decoding.
3. To use an SSL/TLS connection to the POP3 server:
   1. Set the SSLConfiguration property to the name of the activated SSL/TLS configuration to use.
      For information on creating and managing SSL/TLS configurations, see “Using SSL/TLS with Caché” in the Caché Security Administration Guide. The SSL/TLS configuration includes an option called Configuration Name, which is the string to use in this setting.
   2. Set the UseSTARTTLS property to either 0 or 1.
      In most cases, use the value 0. Use the value 1 for the case in which the server interaction begins on a normal TCP socket and then switches to TLS on the same port as the normal socket. For details, see RFC 2595.
   3. Optionally set the SSLCheckServerIdentity property to 1. Do this if you want to verify the host server name in the certificate.
4. Call the Connect() method of your instance. This method takes three arguments, in order:
   1. The name of the POP3 server
   2. A username
   3. A password
5. Use the methods of your instance to examine the mailbox, retrieve messages, and delete messages. The following sections provide details.
6. Optionally, to prevent the connection from timing out, call the Ping() method of your %Net.POP3 instance.
7. Optionally, if you have marked messages for deletion but now choose not to delete them, call the RollbackDeletes() method of your %Net.POP3 instance.
8. When you are done making changes to the mailbox, call one of the following methods:
   • QuitAndCommit() — Commits your changes and logs out of the mail server.
   • QuitAndRollback() — Rolls back your changes and logs out of the mail server.

ClassMethod HotPOPAsPOP3() As %Net.POP3
{
  Set server=##class(%Net.POP3).%New()
  
  //HotPOP POP3 server uses the default port
  //but let's set it anyway
  Set server.port=110

  //just in case we plan to fetch any messages
  //that have attachments
  Set server.StoreAttachToFile=1
  Set server.StoreInlineToFile=1
  Set server.AttachDir="c:\DOWNLOADS\"

  Set servername="pop.hotpop.com"
  Set user="isctest@hotpop.com"
  Set pass="123pass"
  
  Set status=server.Connect(servername,user,pass)
  If $$$ISERR(status) {
    Do $System.Status.DisplayError(status) 
    Quit $$$NULLOREF
  }
  Quit server
}

ClassMethod YPOPsAsPOP3() As %Net.POP3
{
  Set server=##class(%Net.POP3).%New()
  
  //YPOPs uses the default port 
  //but let's set it anyway
  Set server.port=110

  //just in case we plan to fetch any messages
  //that have attachments
  Set server.StoreAttachToFile=1
  Set server.StoreInlineToFile=1
  Set server.AttachDir="c:\DOWNLOADS\"
  
  //local host acts as the server
  Set servername="127.0.0.1"
  //YPOPs works with a Yahoo email account
  Set user="isc.test@yahoo.com"
  Set pass="123pass"
  
  Set status=server.Connect(servername,user,pass)
  If $$$ISERR(status) {
    Do $System.Status.DisplayError(status) 
    Quit $$$NULLOREF
  }
  Quit server
}

ClassMethod ShowMailbox(server as %Net.POP3) 
{
    Set status=server.GetMailBoxStatus(.count,.size)
    If $$$ISERR(status) {
       Do $System.Status.DisplayError(status) 
       Quit 
    }
    Write "Mailbox information *****",!
    Write "Number of messages in mailbox: ",count,!
    Write "Size of messages: ",size,!

    Set status=server.GetMessageUIDArray(,.uids)
    Set status=server.GetSizeOfMessages(,.sizes)
    
    //iterate through messages, get info, and write it
    For i=1:1:count {
        Set uid=uids.GetAt(i)
        Set size=sizes.GetAt(i)
        Write "Msg number:", i,"   UID:",uid, "   size:",size,!
    }

}

Mailbox information *****
Number of messages in mailbox: 4
Size of messages: 18634
Msg number:1   UID:6ef78df6fd660391   size:7245
Msg number:2   UID:7410041a6faf4a87   size:5409
Msg number:3   UID:5555af7fa489e406   size:5121
Msg number:4   UID:299ad2b54c01a6be   size:859

ClassMethod FetchMailbox(server As %Net.POP3)
{
  Set status=server.GetMailBoxStatus(.count,.size)
  If $$$ISERR(status) {
    Do $System.Status.DisplayError(status) 
    Quit $$$NULLOREF
  }
  Write "Mailbox information *****",!
  Write "Number of messages in mailbox: ",count,!
  Write "Size of messages: ",size,!

  Set status=server.GetMessageUIDArray(,.uids)
  Set status=server.GetSizeOfMessages(,.sizes)
  
  //iterate through messages, get info, and write it
  For i=1:1:count {
    Set uid=uids.GetAt(i)
    Set size=sizes.GetAt(i)
    Set status=server.Fetch(i,.msg)
    If $$$ISERR(status) {
      Set subj="***error***"
    } else{
      Set subj=msg.Subject
    }
    Write "Msg number:", i,"  UID:",uid, "  Size:",size
    Write "  Subject: ",subj,!
  }
}

Content-Disposition: attachment; filename=genome.jpeg;

1. Specify the following properties of your %Net.POP3 instance:
   • Specify StoreAttachToFile as 1.
   • Specify StoreInlineToFile as 1.
   • Specify a valid directory for AttachDir. Make sure to terminate the name of the directory with a slash (/) or backslash (\), as appropriate for the operating system. Also make sure that this is directory already exists, and the users have write access to it.
2. Call Fetch() or FetchMessage() of your %Net.POP3 instance.

1. If the Content-Disposition header specifies a filename, that filename is used.
2. Otherwise, if the Content-Type header specifies a filename, that filename is used.
3. Otherwise, the system creates a name of the form ATTxxxxxx.dat.

• If the file already exists, the attachment is not downloaded.
• There is no default for AttachDir.
• The size of the attachment is not limited by Caché but might be limited by the file system.
• The Dir and FileName properties are not used here. They are relevant only when you upload an attachment to a mail message, as described in “Adding Attachments to a Message”.

ClassMethod GetMsg(server as %Net.POP3,msgno as %Integer) as %Net.MailMessage 
{
    Set status=server.Fetch(msgno,.msg)
    If $$$ISERR(status) {
       Do $System.Status.DisplayError(status) 
       Quit $$$NULLOREF
    }
    Quit msg
}

method Fetch(MessageNumber As %Integer, 
             ByRef MailMsg As %Net.MailMessage,
             Delete As %Boolean = 0,
             messageStream As %BinaryStream) as %Status

method FetchFromStream(messageStream As %BinaryStream, ByRef Msg As %Net.MailMessage) as %Status

method FetchMessage(MessageNumber As %Integer, 
                    ByRef From As %String, 
                    ByRef To As %String, 
                    ByRef Date As %String, 
                    ByRef Subject As %String, 
                    ByRef MessageSize As %Integer, 
                    ByRef MsgHeaders As %ArrayOfDataTypes, 
                    ByRef MailMsg As %Net.MailMessage, 
                    Delete As %Boolean = 0) as %Status

method FetchMessageHeaders(MessageNumber As %Integer, 
                           ByRef MsgHeadersArray As %String) as %Status

method FetchMessageInfo(MessageNumber As %Integer, 
                        Lines As %Integer, 
                        ByRef From As %String, 
                        ByRef To As %String, 
                        ByRef Date As %String, 
                        ByRef Subject As %String, 
                        ByRef MessageSize As %Integer, 
                        ByRef MsgHeaders As %ArrayOfDataTypes, 
                        ByRef MessageText As %String) as %Status

method GetAttachedEmail(msgpart As %Net.MailMessagePart, 
       Output mailmsg As %Net.MailMessage) as %Status

method GetMessageUID(MessageNumber As %Integer, 
                     ByRef UniqueID As %String) as %Status

method GetMessageUIDArray(MessageNumber As %String = "", 
                          ByRef ListOfUniqueIDs As %ArrayOfDataTypes) as %Status

method GetSizeOfMessages(MessageNumber As %String = "", 
                         ByRef ListOfSizes As %ArrayOfDataTypes) as %Status

• You can use the DeleteMessage() method. This method takes one argument, the message number to delete.
• When you retrieve a message with the Fetch() or FetchMessage() method, you can specify an optional argument that tells the POP3 server to mark the message for deletion after you have retrieved it.

• These methods do not delete a message; they mark it for deletion. The message is not deleted until you complete the POP3 transaction with QuitAndCommit(). If you simply disconnect from the server, your changes are discarded.
• You can call the RollbackDeletes() method to change the messages so that they are no longer marked for deletion.
• Each of these methods returns a status, which you should check.

ClassMethod GetMsgAndDelete(ByRef server As %Net.POP3, msgno As %Integer) As %Net.MailMessage
{
  //third argument to Fetch says whether to 
  //mark for deletion
  Set status=server.Fetch(msgno,.msg,1)
  If $$$ISERR(status) {
    Do $System.Status.DisplayError(status) 
    Quit $$$NULLOREF
  }
  
  Quit msg
}

ClassMethod CommitChanges(server As %Net.POP3) As %Status
{
  //commit all changes and log out
  Set status=server.QuitAndCommit()
  If $$$ISERR(status) {
    Do $System.Status.DisplayError(status) 
    Quit $$$ERROR($$$GeneralError,"Failed to commit changes")
  }
  Quit $$$OK
}

• For a multipart message, use the Parts property, which is an array of the parts. Parts.Count() gives you the number of parts. The key for each part is an integer, starting with 1. Use the GetAt() method to retrieve a given part. A message part is an instance of %Net.MailMessagePart.
  For information on the relationship of %Net.MailMessage and %Net.MailMessagePart, see “How Caché Represents MIME Email Messages.”
• For a binary message (or message part), use the BinaryData property.
• For a text message (or message part), use the TextData property.
  • If IsHTML is 0, the TextData property is an ordinary text string.
  • If IsHTML is 1, the TextData property is an HTML text string.

ClassMethod ShowMsgInfo(msg as %Net.MailMessage)
{
    Write "Message details *****",!
    Write "To (count): ", msg.To.Count(),!
    Write "From: ", msg.From,!
    Write "Cc (count): ", msg.Cc.Count(),!
    Write "Bcc (count): ", msg.Bcc.Count(),!
    Write "Date: ", msg.Date,!
    Write "Subject: ", msg.Subject,!
    Write "Sender: ", msg.Sender,!
    Write "IsMultipart: ", msg.IsMultiPart,!
    Write "Number of parts: ", msg.Parts.Count(),!
    Write "Number of headers: ", msg.Headers.Count(),!
    Write "IsBinary: ", msg.IsBinary,!
    Write "IsHTML: ", msg.IsHTML,!
    Write "TextData: ", msg.TextData.Read(),!
    Write "BinaryData: ", msg.BinaryData.Read(),!
}

Message details *****
To (count): 1
From: "XXX XXX" <XXX@XXX.com>
Cc (count): 0
Bcc (count): 0
Date: Fri, 16 Nov 2007 11:57:46 -0500
Subject: test 5
Sender:
IsMultipart: 0
Number of parts: 0
Number of headers: 16
IsBinary: 0
IsHTML: 0
TextData: This is test number 5, which is plain text.
BinaryData:

ClassMethod ShowMsgPartInfo(msg as %Net.MailMessage, partno as %Integer)
{
    Set part=msg.Parts.GetAt(partno)
    Write "Message part details *****",!
    Write "Message part: ", partno,!
    Write "IsMultipart: ", part.IsMultiPart,!
    Write "Number of parts: ", part.Parts.Count(),!
    Write "Number of headers: ", part.Headers.Count(),!
    Write "IsBinary: ", part.IsBinary,!
    Write "IsHTML: ", part.IsHTML,!
    Write "TextData: ", part.TextData.Read(),!
    Write "BinaryData: ", part.BinaryData.Read(),!
}

Message part details *****
Message part: 1
IsMultipart: 0
Number of parts: 0
Number of headers: 2
IsBinary: 0
IsHTML: 0
TextData: 1 test string
 
 
BinaryData:

ClassMethod ShowMsgHeaders(msg as %Net.MailMessage)
{
    Set headers=msg.Headers
    Write "Number of headers: ", headers.Count(),!
    
    //iterate through the headers
    Set key=""
    For {
        Set value=headers.GetNext(.key) 
        Quit:key=""  
        Write "Header:",key,!
        Write "Value: ",value,!!
    }
}

Number of headers: 16
Header: content-class
Value: urn:content-classes:message
 
Header: content-type
Value: multipart/alternative; boundary="----_=_NextPart_001_01C8286D.D9A7F3B1"
 
Header: date
Value: Fri, 16 Nov 2007 11:29:24 -0500
 
Header: from
Value: "XXX XXX" <XXX@XXX.com>
 
Header: message-id
Value: <895A9EF10DBA1F46A2DDB3AAF061ECD501801E86@Exchange1_backup>
 
Header: mime-version
Value: 1.0
 
...

• On Unicode systems, the default is UTF-8.
• On 8–bit systems, the default is the system default character set.