MailMan Delphi DLL Reference Documentation

MailMan

Current Version: 9.5.0.97

The Chilkat MailMan class is reponsible for sending email though SMTP and receiving/managing email on POP3 servers.

Create/Dispose

var
myObject: HCkMailMan;

begin
myObject := CkMailMan_Create();

// ...

CkMailMan_Dispose(myObject);
end;
function CkMailMan_Create: HCkMailMan; stdcall;

Creates an instance of the HCkMailMan object and returns a handle (i.e. a Pointer). The handle is passed in the 1st argument for the functions listed on this page.

procedure CkMailMan_Dispose(handle: HCkMailMan); stdcall;

Objects created by calling CkMailMan_Create must be freed by calling this method. A memory leak occurs if a handle is not disposed by calling this function.

Properties

AbortCurrent
function CkMailMan_getAbortCurrent(objHandle: HCkMailMan): wordbool; stdcall;
procedure CkMailMan_putAbortCurrent(objHandle: HCkMailMan; newPropVal: wordbool); stdcall;
Introduced in version 9.5.0.58

When set to True, causes the currently running method to abort. Methods that always finish quickly (i.e.have no length file operations or network communications) are not affected. If no method is running, then this property is automatically reset to False when the next method is called. When the abort occurs, this property is reset to False. Both synchronous and asynchronous method calls can be aborted. (A synchronous method call could be aborted by setting this property from a separate thread.)

top
AllOrNone
function CkMailMan_getAllOrNone(objHandle: HCkMailMan): wordbool; stdcall;
procedure CkMailMan_putAllOrNone(objHandle: HCkMailMan; newPropVal: wordbool); stdcall;

Prevents sending any email if any of the addresses in the recipient list are rejected by the SMTP server. The default value is False, which indicates that the mail sending should continue even if some email addresses are invalid. (Note: Not all SMTP servers check the validity of email addresses, and even for those that do, it is not 100% accurate.)

Note: An SMTP server only knows the validity of email addresses within the domain it controls.

Important: The AllOrNone property only works if SMTP pipelining is turned off. By default, the SmtpPipelining property is turned on and has the value of True. If all-or-none behavior is desired, make sure to set SmtpPipelining equal to False.

More Information and Examples
top
AutoFix
function CkMailMan_getAutoFix(objHandle: HCkMailMan): wordbool; stdcall;
procedure CkMailMan_putAutoFix(objHandle: HCkMailMan; newPropVal: wordbool); stdcall;

If True, then the following will occur when a connection is made to an SMTP or POP3 server:

1) If the SmtpPort property = 465, then sets StartTLS = False and SmtpSsl = True
2) If the SmtpPort property = 25, sets SmtpSsl = False
3) If the MailPort property = 995, sets PopSsl = True
4) If the MailPort property = 110, sets PopSsl = False

The default value of this property is True.

More Information and Examples
top
AutoGenMessageId
function CkMailMan_getAutoGenMessageId(objHandle: HCkMailMan): wordbool; stdcall;
procedure CkMailMan_putAutoGenMessageId(objHandle: HCkMailMan; newPropVal: wordbool); stdcall;

Controls whether a unique Message-ID header is auto-generated for each email sent.

The Message-ID header field should contain a unique message ID for each email that is sent. The default behavior is to auto-generate this header field at the time the message is sent. This makes it easier for the same email object to be re-used. If the message ID is not unique, the SMTP server may consider the message to be a duplicate of one that has already been sent, and may discard it without sending. This property controls whether message IDs are automatically generated. If auto-generation is turned on (True), the value returned by GetHeaderField("Message-ID") will not reflect the actual message ID that gets sent with the email.

To turn off automatic Message-ID generation, set this property to False.

top
AutoSmtpRset
function CkMailMan_getAutoSmtpRset(objHandle: HCkMailMan): wordbool; stdcall;
procedure CkMailMan_putAutoSmtpRset(objHandle: HCkMailMan; newPropVal: wordbool); stdcall;

If True, then the SMTP "RSET" command is automatically sent to ensure that the SMTP connection is in a valid state when a new email is about to be sent on an already established connection. The default value is False.

Important: This property only applies when an email is sent on an already-open SMTP connection.

top
AutoUnwrapSecurity
function CkMailMan_getAutoUnwrapSecurity(objHandle: HCkMailMan): wordbool; stdcall;
procedure CkMailMan_putAutoUnwrapSecurity(objHandle: HCkMailMan; newPropVal: wordbool); stdcall;
Introduced in version 9.5.0.49

If True, then digitally signed and/or encrypted email when downloaded from a mail server is automatically "unwrapped" and the results of the signature validation and decryption are available in various email object properties and methods. The default value of this property is True. Set this property to False to prevent unwrapping.

Note: A digitally signed or encrypted email can ONLY be verified and/or decrypted when initially loading the original MIME into the email object (i.e. when downloading from the server, or when loading from MIME). Once the MIME is parsed and stored in the internal email object format, the exactnes of the MIME has been lost and the signature can no longer be verified. This is why the signature is verified upon the intial loading of the MIME, and the results are made available through the various properties and methods. This property provides a means for downloading email where the .p7m (or .p7s) attachments are are to be treated as simple attachments and the desire is to access or save the original .p7m/.p7s files.

top
ClientIpAddress
procedure CkMailMan_getClientIpAddress(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putClientIpAddress(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__clientIpAddress(objHandle: HCkMailMan): PWideChar; stdcall;

The IP address to use for computers with multiple network interfaces or IP addresses. For computers with a single network interface (i.e. most computers), this property should not be set. For multihoming computers, the default IP address is automatically used if this property is not set.

The IP address is a string such as in dotted notation using numbers, not domain names, such as "165.164.55.124".

More Information and Examples
top
ConnectFailReason
function CkMailMan_getConnectFailReason(objHandle: HCkMailMan): Integer; stdcall;
Introduced in version 9.5.0.56

This property will be set to the status of the last connection made (or failed to be made) by any method.

Possible values are:

0 = success

Normal (non-TLS) sockets:
1 = empty hostname
2 = DNS lookup failed
3 = DNS timeout
4 = Aborted by application.
5 = Internal failure.
6 = Connect Timed Out
7 = Connect Rejected (or failed for some other reason)

SSL/TLS:
100 = TLS internal error.
101 = Failed to send client hello.
102 = Unexpected handshake message.
103 = Failed to read server hello.
104 = No server certificate.
105 = Unexpected TLS protocol version.
106 = Server certificate verify failed (the server certificate is expired or the cert's signature verification failed).
107 = Unacceptable TLS protocol version.
109 = Failed to read handshake messages.
110 = Failed to send client certificate handshake message.
111 = Failed to send client key exchange handshake message.
112 = Client certificate's private key not accessible.
113 = Failed to send client cert verify handshake message.
114 = Failed to send change cipher spec handshake message.
115 = Failed to send finished handshake message.
116 = Server's Finished message is invalid.

top
ConnectTimeout
function CkMailMan_getConnectTimeout(objHandle: HCkMailMan): Integer; stdcall;
procedure CkMailMan_putConnectTimeout(objHandle: HCkMailMan; newPropVal: Integer); stdcall;

The time (in seconds) to wait before while trying to connect to a mail server (POP3 or SMTP). The default value is 30.

top
DebugLogFilePath
procedure CkMailMan_getDebugLogFilePath(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putDebugLogFilePath(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__debugLogFilePath(objHandle: HCkMailMan): PWideChar; stdcall;

If set to a file path, causes each Chilkat method or property call to automatically append it's LastErrorText to the specified log file. The information is appended such that if a hang or crash occurs, it is possible to see the context in which the problem occurred, as well as a history of all Chilkat calls up to the point of the problem. The VerboseLogging property can be set to provide more detailed information.

This property is typically used for debugging the rare cases where a Chilkat method call hangs or generates an exception that halts program execution (i.e. crashes). A hang or crash should generally never happen. The typical causes of a hang are:

  1. a timeout related property was set to 0 to explicitly indicate that an infinite timeout is desired,
  2. the hang is actually a hang within an event callback (i.e. it is a hang within the application code), or
  3. there is an internal problem (bug) in the Chilkat code that causes the hang.

top
DsnEnvid
procedure CkMailMan_getDsnEnvid(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putDsnEnvid(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__dsnEnvid(objHandle: HCkMailMan): PWideChar; stdcall;

(An SMTP DSN service extension feature) An arbitrary string that will be used as the ENVID property when sending email. See RFC 3461 for more details.

top
DsnNotify
procedure CkMailMan_getDsnNotify(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putDsnNotify(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__dsnNotify(objHandle: HCkMailMan): PWideChar; stdcall;

(An SMTP DSN service extension feature) A string that will be used as the NOTIFY parameter when sending email. (See RFC 3461 for more details. ) This string can be left blank, or can be set to "NEVER", or any combination of a comma-separated list of "SUCCESS", "FAILURE", or "NOTIFY".

top
DsnRet
procedure CkMailMan_getDsnRet(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putDsnRet(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__dsnRet(objHandle: HCkMailMan): PWideChar; stdcall;

(An SMTP DSN service extension feature) A string that will be used as the RET parameter when sending email. (See RFC 3461 for more details. ) This string can be left blank, or can be set to "FULL" to receive entire-message DSN notifications, or "HDRS" to receive header-only DSN notifications.

top
EmbedCertChain
function CkMailMan_getEmbedCertChain(objHandle: HCkMailMan): wordbool; stdcall;
procedure CkMailMan_putEmbedCertChain(objHandle: HCkMailMan; newPropVal: wordbool); stdcall;

If True, causes the digital certificate chain to be embedded in signed emails. The certificates in the chain of authentication are embedded up to but not including the root certificate. If the IncludeRootCert property is also True, then the root CA certificate is also included in the S/MIME signature.

top
Filter
procedure CkMailMan_getFilter(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putFilter(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__filter(objHandle: HCkMailMan): PWideChar; stdcall;

An expression that is applied to any of the following method calls when present: LoadXmlFile, LoadXmlString, LoadMbx, CopyMail, and TransferMail. For these methods, only the emails that match the filter's expression are returned in the email bundle. In the case of TransferMail, only the matching emails are removed from the mail server. The filter allows any header field, or the body, to be checked.

Here are some examples of expressions:

Body like "mortgage rates*". 
Subject contains "update" and From contains "chilkat" 
To = "info@chilkatsoft.com" 

Here are the general rules for forming filter expressions:

Any MIME header field name can be used, case is insensitive. 
Literal strings are double-quoted, and case is insensitive. 
The "*" wildcard matches 0 or more occurrences of any character. 
Parentheses can be used to control precedence. 
The logical operators are: AND, OR, NOT (case insensitive) 
Comparison operators are: =, <, >, <=, >=, <> 
String comparison operators are: CONTAINS, LIKE (case insensitive)

Note: This property only works on text strings, not dates or numbers.

top
HeartbeatMs
function CkMailMan_getHeartbeatMs(objHandle: HCkMailMan): Integer; stdcall;
procedure CkMailMan_putHeartbeatMs(objHandle: HCkMailMan; newPropVal: Integer); stdcall;

The time interval, in milliseconds, between AbortCheck event callbacks. The heartbeat provides a means for an application to monitor a mail-sending and/or mail-reading method call, and to abort it while in progress.

top
HeloHostname
procedure CkMailMan_getHeloHostname(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putHeloHostname(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__heloHostname(objHandle: HCkMailMan): PWideChar; stdcall;

Specifies the hostname to be used for the EHLO/HELO command sent to an SMTP server. By default, this property is an empty string which causes the local hostname to be used.

top
HttpProxyAuthMethod
procedure CkMailMan_getHttpProxyAuthMethod(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putHttpProxyAuthMethod(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__httpProxyAuthMethod(objHandle: HCkMailMan): PWideChar; stdcall;

If an HTTP proxy requiring authentication is to be used, set this property to the HTTP proxy authentication method name. Valid choices are "Basic" or "NTLM".

top
HttpProxyDomain
procedure CkMailMan_getHttpProxyDomain(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putHttpProxyDomain(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__httpProxyDomain(objHandle: HCkMailMan): PWideChar; stdcall;

The NTLM authentication domain (optional) if NTLM authentication is used.

top
HttpProxyHostname
procedure CkMailMan_getHttpProxyHostname(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putHttpProxyHostname(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__httpProxyHostname(objHandle: HCkMailMan): PWideChar; stdcall;

If an HTTP proxy is to be used, set this property to the HTTP proxy hostname or IPv4 address (in dotted decimal notation).

top
HttpProxyPassword
procedure CkMailMan_getHttpProxyPassword(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putHttpProxyPassword(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__httpProxyPassword(objHandle: HCkMailMan): PWideChar; stdcall;

If an HTTP proxy requiring authentication is to be used, set this property to the HTTP proxy password.

top
HttpProxyPort
function CkMailMan_getHttpProxyPort(objHandle: HCkMailMan): Integer; stdcall;
procedure CkMailMan_putHttpProxyPort(objHandle: HCkMailMan; newPropVal: Integer); stdcall;

If an HTTP proxy is to be used, set this property to the HTTP proxy port number. (Two commonly used HTTP proxy ports are 8080 and 3128.)

top
HttpProxyUsername
procedure CkMailMan_getHttpProxyUsername(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putHttpProxyUsername(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__httpProxyUsername(objHandle: HCkMailMan): PWideChar; stdcall;

If an HTTP proxy requiring authentication is to be used, set this property to the HTTP proxy login name.

top
ImmediateDelete
function CkMailMan_getImmediateDelete(objHandle: HCkMailMan): wordbool; stdcall;
procedure CkMailMan_putImmediateDelete(objHandle: HCkMailMan; newPropVal: wordbool); stdcall;

If True (the default) then any method that deletes an email from the POP3 server will also issue a QUIT command to close the session to ensure the message is deleted immediately.

The POP3 protocol is such that the DELE command marks a message for deletion. It is not actually deleted until the QUIT command is sent and the session is closed. If ImmediateDelete is True, then any Chilkat MailMan method that marks a message (or messages) for deletion will also followup with a QUIT command and close the session. If your program sets ImmediateDelete to False, it must make sure to call Pop3EndSession to ensure that messages marked for deletion are actually deleted.

More Information and Examples
top
IncludeRootCert
function CkMailMan_getIncludeRootCert(objHandle: HCkMailMan): wordbool; stdcall;
procedure CkMailMan_putIncludeRootCert(objHandle: HCkMailMan; newPropVal: wordbool); stdcall;

Controls whether the root certificate in the chain of authentication (i.e. the CA root certificate) is included within the S/MIME signature of a signed email. Note: This property only applies if the EmbedCertChain property is also True.

top
IsPop3Connected
function CkMailMan_getIsPop3Connected(objHandle: HCkMailMan): wordbool; stdcall;
Introduced in version 9.5.0.48

Returns True if still connected to the POP3 server. Otherwise returns False.

Note: Accessing this property does not trigger any communication with the POP3 server. A connection to the POP3 server is established by explicitly calling Pop3BeginSession, or it is implicitly established as needed by any method that requires communication. A lost connection might only be detected when attempting to communicate with the server. To truly determine if a connection to the POP3 server is open and valid, it may be necessary to call the Pop3Noop method instead. This property might return True if the server has disconnected, but the client has not attempted to communicate with the server since the disconnect.

top
IsSmtpConnected
function CkMailMan_getIsSmtpConnected(objHandle: HCkMailMan): wordbool; stdcall;

Returns True if still connected to the SMTP server. Otherwise returns False (if there was never a connection in the first place, or if the connection was lost).

Note: Accessing this property does not trigger any communication with the SMTP server. A connection to the SMTP server is established by explicitly calling OpenSmtpConnection, or it is implicitly established as needed by any method that requires communication. A lost connection might only be detected when attempting to communicate with the server. To truly determine if a connection to the SMTP server is open and valid, it may be necessary to call the SmtpNoop method instead. This property might return True if the server has disconnected, but the client has not attempted to communicate with the server since the disconnect.

top
LastErrorHtml
procedure CkMailMan_getLastErrorHtml(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
function CkMailMan__lastErrorHtml(objHandle: HCkMailMan): PWideChar; stdcall;

Provides information in HTML format about the last method/property called. If a method call returns a value indicating failure, or behaves unexpectedly, examine this property to get more information.

top
LastErrorText
procedure CkMailMan_getLastErrorText(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
function CkMailMan__lastErrorText(objHandle: HCkMailMan): PWideChar; stdcall;

Provides information in plain-text format about the last method/property called. If a method call returns a value indicating failure, or behaves unexpectedly, examine this property to get more information.

top
LastErrorXml
procedure CkMailMan_getLastErrorXml(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
function CkMailMan__lastErrorXml(objHandle: HCkMailMan): PWideChar; stdcall;

Provides information in XML format about the last method/property called. If a method call returns a value indicating failure, or behaves unexpectedly, examine this property to get more information.

top
LastMethodSuccess
function CkMailMan_getLastMethodSuccess(objHandle: HCkMailMan): wordbool; stdcall;
procedure CkMailMan_putLastMethodSuccess(objHandle: HCkMailMan; newPropVal: wordbool); stdcall;

Indicate whether the last method call succeeded or failed. A value of True indicates success, a value of False indicates failure. This property is automatically set for method calls. It is not modified by property accesses. The property is automatically set to indicate success for the following types of method calls:

  • Any method that returns a string.
  • Any method returning a Chilkat object, binary bytes, or a date/time.
  • Any method returning a standard boolean status value where success = True and failure = False.
  • Any method returning an integer where failure is defined by a return value less than zero.

Note: Methods that do not fit the above requirements will always set this property equal to True. For example, a method that returns no value (such as a "void" in C++) will technically always succeed.

top
LastSmtpStatus
function CkMailMan_getLastSmtpStatus(objHandle: HCkMailMan): Integer; stdcall;

Returns the last SMTP diagnostic status code. This can be checked after sending an email. SMTP reply codes are defined by RFC 821 - Simple Mail Transfer Protocol.

top
LastSmtpStatusMsg
procedure CkMailMan_getLastSmtpStatusMsg(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
function CkMailMan__lastSmtpStatusMsg(objHandle: HCkMailMan): PWideChar; stdcall;
Introduced in version 9.5.0.85

Returns the last SMTP status message associated with the last SMTP status code received. This can be checked after sending an email.

top
LogMailReceivedFilename
procedure CkMailMan_getLogMailReceivedFilename(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putLogMailReceivedFilename(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__logMailReceivedFilename(objHandle: HCkMailMan): PWideChar; stdcall;

A log filename where the MailMan will log each message in the exact form it was received from a POP3 server. This property is provided for help in debugging.

top
LogMailSentFilename
procedure CkMailMan_getLogMailSentFilename(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putLogMailSentFilename(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__logMailSentFilename(objHandle: HCkMailMan): PWideChar; stdcall;

A log filename where the MailMan will log the exact message sent to the SMTP server. This property is helpful in debugging.

top
MailHost
procedure CkMailMan_getMailHost(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putMailHost(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__mailHost(objHandle: HCkMailMan): PWideChar; stdcall;

The domain name of the POP3 server. Do not include "http://" in the domain name. This property may also be set to an IP address string, such as "168.144.70.227". Both IPv4 and IPv6 address formats are supported.

top
MailPort
function CkMailMan_getMailPort(objHandle: HCkMailMan): Integer; stdcall;
procedure CkMailMan_putMailPort(objHandle: HCkMailMan; newPropVal: Integer); stdcall;

The port number of the POP3 server. Only needs to be set if the POP3 server is running on a non-standard port. The default value is 110. (If SSL/TLS is used by setting the PopSsl property = True, then this property should probably be set to 995, which is the standard SSL/TLS port for POP3.)

top
MaxCount
function CkMailMan_getMaxCount(objHandle: HCkMailMan): Integer; stdcall;
procedure CkMailMan_putMaxCount(objHandle: HCkMailMan; newPropVal: Integer); stdcall;

Limits the number of messages the MailMan will try to retrieve from the POP3 server in a single method call. If you are trying to read a large mailbox, you might set this to a value such as 100 to download 100 emails at a time.

top
OAuth2AccessToken
procedure CkMailMan_getOAuth2AccessToken(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putOAuth2AccessToken(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__oAuth2AccessToken(objHandle: HCkMailMan): PWideChar; stdcall;
Introduced in version 9.5.0.44

The OAUTH2 access token if OAUTH2 authentication is to be used for the authentication. For GMail, the Chilkat HTTP class/object's G_SvcOauthAccessToken method can be called to obtain an OAUTH2 access token for a GMail service account.

Starting in v9.5.0.83, this property can be set to also do XOAUTH2 authentication for POP3 sessions (pop.gmail.com).

top
OpaqueSigning
function CkMailMan_getOpaqueSigning(objHandle: HCkMailMan): wordbool; stdcall;
procedure CkMailMan_putOpaqueSigning(objHandle: HCkMailMan; newPropVal: wordbool); stdcall;

When False, a signed email is generated as multipart/signed. For example:

Content-Type: multipart/signed; charset=utf-8; boundary="------------010909020906040709090605";
 protocol="application/pkcs7-signature";
 micalg=sha256

When True, a signed email is generated as signed-data. For example:

Content-Type: application/pkcs7-mime; name="smime.p7m"; micalg=sha256;
 smime-type="signed-data"

A multipart/signed email is such that the signature is contained in a separate MIME body part and the original content of the email is not encapsulated within the signature. A signed-data email is such that it's non-multipart MIME (content type is "application/pkcs7-signature") and the original email is encapsulated within the signature. This is historically known as an opaque signature.

The default value is True.

top
P7mEncryptAttachFilename
procedure CkMailMan_getP7mEncryptAttachFilename(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putP7mEncryptAttachFilename(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__p7mEncryptAttachFilename(objHandle: HCkMailMan): PWideChar; stdcall;
Introduced in version 9.5.0.30

The filename attribute to be used in the Content-Disposition header field when sending a PCKS7 encrypted email. The default value is "smime.p7m".

top
P7mSigAttachFilename
procedure CkMailMan_getP7mSigAttachFilename(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putP7mSigAttachFilename(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__p7mSigAttachFilename(objHandle: HCkMailMan): PWideChar; stdcall;
Introduced in version 9.5.0.30

The filename attribute to be used in the Content-Disposition header field when sending a PCKS7 opaque signed email. The default value is "smime.p7m".

top
P7sSigAttachFilename
procedure CkMailMan_getP7sSigAttachFilename(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putP7sSigAttachFilename(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__p7sSigAttachFilename(objHandle: HCkMailMan): PWideChar; stdcall;
Introduced in version 9.5.0.30

The filename attribute to be used in the Content-Disposition header field when sending a signed email with a detached PKCS7 signature. The default value is "smime.p7s".

top
PercentDoneScale
function CkMailMan_getPercentDoneScale(objHandle: HCkMailMan): Integer; stdcall;
procedure CkMailMan_putPercentDoneScale(objHandle: HCkMailMan; newPropVal: Integer); stdcall;
Introduced in version 9.5.0.49

This property is only valid in programming environment and languages that allow for event callbacks.

Sets the value to be defined as 100% complete for the purpose of PercentDone event callbacks. The defaut value of 100 means that at most 100 event PercentDone callbacks will occur in a method that (1) is event enabled and (2) is such that it is possible to measure progress as a percentage completed. This property may be set to larger numbers to get more fine-grained PercentDone callbacks. For example, setting this property equal to 1000 will provide callbacks with .1 percent granularity. For example, a value of 453 would indicate 45.3% competed. This property is clamped to a minimum value of 10, and a maximum value of 100000.

top
Pop3SessionId
function CkMailMan_getPop3SessionId(objHandle: HCkMailMan): Integer; stdcall;

0 if no POP3 session is active. Otherwise a positive integer that is incremented with each new POP3 session. It may be used to determine if a new POP3 session has been established.

top
Pop3SessionLog
procedure CkMailMan_getPop3SessionLog(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
function CkMailMan__pop3SessionLog(objHandle: HCkMailMan): PWideChar; stdcall;

This string property accumulates the raw commands sent to the POP3 server, and the raw responses received from the POP3 server. This property is read-only, but it may be cleared by calling ClearPop3SessionLog.

More Information and Examples
top
Pop3SPA
function CkMailMan_getPop3SPA(objHandle: HCkMailMan): wordbool; stdcall;
procedure CkMailMan_putPop3SPA(objHandle: HCkMailMan; newPropVal: wordbool); stdcall;

Controls whether SPA authentication for POP3 is used or not. To use SPA authentication, set this property = True. No other programming changes are required. The default value is False.

Note: If SPA (i.e. NTLM) authentication does not succeed, set the Global.DefaultNtlmVersion property equal to 1 and then retry.

top
Pop3SslServerCertVerified
function CkMailMan_getPop3SslServerCertVerified(objHandle: HCkMailMan): wordbool; stdcall;

When connecting via SSL, this property is True if the POP3 server's SSL certificate was verified. Otherwise it is set to False.

top
Pop3Stls
function CkMailMan_getPop3Stls(objHandle: HCkMailMan): wordbool; stdcall;
procedure CkMailMan_putPop3Stls(objHandle: HCkMailMan; newPropVal: wordbool); stdcall;

If True, then an unencrypted connection (typically on port 110) is automatically converted to a secure TLS connection via the STLS command (see RFC 2595) when connecting. This should only be used with POP3 servers that are known to support the STLS capability. If this property is set to True, then the PopSsl property should be set to False. (The PopSsl property controls whether the connection is SSL/TLS from the beginning. Setting the Pop3Stls property = True indicates that the POP3 client will initially connect unencrypted and then convert to TLS.)

The default value of this property is False.

More Information and Examples
top
Pop3StlsIfPossible
function CkMailMan_getPop3StlsIfPossible(objHandle: HCkMailMan): wordbool; stdcall;
procedure CkMailMan_putPop3StlsIfPossible(objHandle: HCkMailMan; newPropVal: wordbool); stdcall;
Introduced in version 9.5.0.92

If True, then an unencrypted connection (typically on port 110) is automatically converted to a secure TLS connection via the STLS command if the mail server supports the STLS command. If the mail server does not support STLS, then the connection will remain unencrypted.

The default value of this property is False.

top
PopPassword
procedure CkMailMan_getPopPassword(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putPopPassword(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__popPassword(objHandle: HCkMailMan): PWideChar; stdcall;

The POP3 password.

If the Pop3SPA property is set, the PopUsername and PopPassword properties may be set to the string "default" to cause the component to use the current logged-on credentials (of the calling process) for authentication.

top
PopPasswordBase64
procedure CkMailMan_getPopPasswordBase64(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putPopPasswordBase64(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__popPasswordBase64(objHandle: HCkMailMan): PWideChar; stdcall;

Provides a way to specify the POP3 password from a Base64-encoded string.

top
PopSsl
function CkMailMan_getPopSsl(objHandle: HCkMailMan): wordbool; stdcall;
procedure CkMailMan_putPopSsl(objHandle: HCkMailMan; newPropVal: wordbool); stdcall;

Controls whether TLS/SSL is used when reading email from a POP3 server. Note: Check first to determine if your POP3 server can accept TLS/SSL connections. Also, be sure to set the MailPort property to the TLS/SSL POP3 port number, which is typically 995.

The default value of this property is False.

top
PopUsername
procedure CkMailMan_getPopUsername(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putPopUsername(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__popUsername(objHandle: HCkMailMan): PWideChar; stdcall;

The POP3 login name.

If the Pop3SPA property is set, the PopUsername and PopPassword properties may be set to the string "default" to cause the component to use the current logged-on credentials (of the calling process) for authentication.

top
PreferIpv6
function CkMailMan_getPreferIpv6(objHandle: HCkMailMan): wordbool; stdcall;
procedure CkMailMan_putPreferIpv6(objHandle: HCkMailMan; newPropVal: wordbool); stdcall;

If True, then use IPv6 over IPv4 when both are supported for a particular domain. The default value of this property is False, which will choose IPv4 over IPv6.

top
ReadTimeout
function CkMailMan_getReadTimeout(objHandle: HCkMailMan): Integer; stdcall;
procedure CkMailMan_putReadTimeout(objHandle: HCkMailMan; newPropVal: Integer); stdcall;

The maximum time to wait, in seconds, if the POP3 or SMTP server stops responding. The default value is 30 seconds.

More Information and Examples
top
RequireSslCertVerify
function CkMailMan_getRequireSslCertVerify(objHandle: HCkMailMan): wordbool; stdcall;
procedure CkMailMan_putRequireSslCertVerify(objHandle: HCkMailMan; newPropVal: wordbool); stdcall;

If True, then the mailman will verify the SMTP or POP3 server's SSL certificate when connecting. The certificate is expired, or if the cert's signature is invalid, the connection is not allowed. The default value of this property is False. (Obviously, this only applies to SSL/TLS connections.)

top
ResetDateOnLoad
function CkMailMan_getResetDateOnLoad(objHandle: HCkMailMan): wordbool; stdcall;
procedure CkMailMan_putResetDateOnLoad(objHandle: HCkMailMan; newPropVal: wordbool); stdcall;

Controls whether the Date header field is reset to the current date/time when an email is loaded from LoadMbx, LoadEml, LoadMime, LoadXml, or LoadXmlString. The default is False (to not reset the date). To automatically reset the date, set this property equal to True.

top
SendBufferSize
function CkMailMan_getSendBufferSize(objHandle: HCkMailMan): Integer; stdcall;
procedure CkMailMan_putSendBufferSize(objHandle: HCkMailMan; newPropVal: Integer); stdcall;

The buffer size to be used with the underlying TCP/IP socket for sending. The default value is 32767.

top
SendIndividual
function CkMailMan_getSendIndividual(objHandle: HCkMailMan): wordbool; stdcall;
procedure CkMailMan_putSendIndividual(objHandle: HCkMailMan; newPropVal: wordbool); stdcall;

Determines how emails are sent to distribution lists. If True, emails are sent to each recipient in the list one at a time, with the "To"header field containing the email address of the recipient. If False, emails will contain in the "To"header field, and are sent to 100 BCC recipients at a time. As an example, if your distribution list contained 350 email addresses, 4 emails would be sent, the first 3 having 100 BCC recipients, and the last email with 50 BCC recipients.The default value of this property is True.

top
SizeLimit
function CkMailMan_getSizeLimit(objHandle: HCkMailMan): Integer; stdcall;
procedure CkMailMan_putSizeLimit(objHandle: HCkMailMan; newPropVal: Integer); stdcall;

The MailMan will not try to retrieve mail messages from a POP3 server that are greater than this size limit. The default value is 0 indicating no size limit. The SizeLimit is specified in number of bytes.

top
SmtpAuthMethod
procedure CkMailMan_getSmtpAuthMethod(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putSmtpAuthMethod(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__smtpAuthMethod(objHandle: HCkMailMan): PWideChar; stdcall;

This property should usually be left empty. The MailMan will by default choose the most secure login method available to prevent unencrypted username and passwords from being transmitted if possible. However, some SMTP servers may not advertise the acceptable authorization methods, and therefore it is not possible to automatically determine the best authorization method. To force a particular auth method, or to prevent any authorization from being used, set this property to one of the following values: "NONE", "LOGIN", "PLAIN", "CRAM-MD5", or "NTLM".

Note: If NTLM authentication does not succeed, set the Global.DefaultNtlmVersion property equal to 1 and then retry.

top
SmtpFailReason
procedure CkMailMan_getSmtpFailReason(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
function CkMailMan__smtpFailReason(objHandle: HCkMailMan): PWideChar; stdcall;
Introduced in version 9.5.0.48

A keyword that indicates the cause of failure (or success) for the last SMTP related method called. Possible values are:

  1. Success The method call was successful.
  2. Failed A general failure not covered by any of the other possible keywords.
  3. NoValidRecipients The SMTP server rejected all receipients.
  4. NoRecipients The app failed to provide any recipients (TO, CC, or BCC).
  5. SomeBadRecipients The AllOrNone property is True, and some recipients were rejected by the SMTP server.
  6. Aborted The application aborted the method.
  7. NoFrom The failed to provide a FROM address.
  8. FromFailure The SMTP replied with an error in response to the "MAIL FROM" command.
  9. NoCredentials The application did not provide the required credentials, such as username or password.
  10. AuthFailure The login (authentication) failed.
  11. DataFailure The SMTP replied with an error in response to the "DATA" command.
  12. NoSmtpHostname The application failed to provide an SMTP hostname or IP address.
  13. StartTlsFailed Failed to convert the TCP connection to TLS via STARTTLS.
  14. ConnectFailed Unable to establish a TCP or TLS connection to the SMTP server.
  15. GreetingError The SMTP server immediately responded with an error status in the intial greeting.
  16. ConnectionLost The connection to the SMTP server was lost at some point during the method call.
  17. Timeout A timeout occurred when reading or writing the socket connection.
  18. RenderFailed A failure occurred when rendering the email. (Rendering the email for sending includes tasks such as signing or encrypting.)
  19. NotUnlocked The UnlockComponent method was not previously called on at least one instance of the mailman object.
  20. InternalFailure An internal failure that should be reported to Chilkat support.

top
SmtpHost
procedure CkMailMan_getSmtpHost(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putSmtpHost(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__smtpHost(objHandle: HCkMailMan): PWideChar; stdcall;

The domain name of the SMTP server. Do not include "http://" in the domain name. This property may also be set to an IP address string, such as "168.144.70.227". Both IPv4 and IPv6 address formats are supported.

More Information and Examples
top
SmtpLoginDomain
procedure CkMailMan_getSmtpLoginDomain(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putSmtpLoginDomain(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__smtpLoginDomain(objHandle: HCkMailMan): PWideChar; stdcall;

The Windows domain for logging into the SMTP server. Use this only if your SMTP server requires NTLM authentication, which means your SMTP server uses Integrated Windows Authentication. If there is no domain, this can be left empty.

top
SmtpPassword
procedure CkMailMan_getSmtpPassword(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putSmtpPassword(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__smtpPassword(objHandle: HCkMailMan): PWideChar; stdcall;

The password for logging into the SMTP server. Use this only if your SMTP server requires authentication. Chilkat Email.NET supports the LOGIN, PLAIN, CRAM-MD5, and NTLM login methods, and it will automatically choose the most secure method available. Additional login methods will be available in the future.

If NTLM (Windows-Integrated) authentication is used, the SmtpUsername and SmtpPassword properties may be set to the string "default" to cause the component to use the current logged-on credentials (of the calling process) for authentication.

top
SmtpPipelining
function CkMailMan_getSmtpPipelining(objHandle: HCkMailMan): wordbool; stdcall;
procedure CkMailMan_putSmtpPipelining(objHandle: HCkMailMan; newPropVal: wordbool); stdcall;
Introduced in version 9.5.0.49

Controls whether SMTP pipelining is automatically used when the SMTP server indicates support for it. The default is True. Setting this property equal to False will prevent the SMTP pipelining feature from being used.

top
SmtpPort
function CkMailMan_getSmtpPort(objHandle: HCkMailMan): Integer; stdcall;
procedure CkMailMan_putSmtpPort(objHandle: HCkMailMan; newPropVal: Integer); stdcall;

The port number of the SMTP server used to send email. Only needs to be set if the SMTP server is running on a non-standard port. The default value is 25. If SmtpSsl is set to True, this property should be set to 465. (TCP port 465 is reserved by common industry practice for secure SMTP communication using the SSL protocol.)

top
SmtpSessionLog
procedure CkMailMan_getSmtpSessionLog(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
function CkMailMan__smtpSessionLog(objHandle: HCkMailMan): PWideChar; stdcall;

This string property accumulates the raw commands sent to the SMTP server, and the raw responses received from the SMTP server. This property is read-only, but it may be cleared by calling ClearSmtpSessionLog.

top
SmtpSsl
function CkMailMan_getSmtpSsl(objHandle: HCkMailMan): wordbool; stdcall;
procedure CkMailMan_putSmtpSsl(objHandle: HCkMailMan; newPropVal: wordbool); stdcall;

When set to True, causes the mailman to connect to the SMTP server with implicit SSL/TLS.

top
SmtpSslServerCertVerified
function CkMailMan_getSmtpSslServerCertVerified(objHandle: HCkMailMan): wordbool; stdcall;

If using SSL, this property will be set to True if the SMTP server's SSL certificate was verified when establishing the connection. Otherwise it is set to False.

top
SmtpUsername
procedure CkMailMan_getSmtpUsername(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putSmtpUsername(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__smtpUsername(objHandle: HCkMailMan): PWideChar; stdcall;

The login for logging into the SMTP server. Use this only if your SMTP server requires authentication.

Note: In many cases, an SMTP server will not require authentication when sending to an email address local to it's domain. However, when sending email to an external domain, authentication is required (i.e. the SMTP server is being used as a relay).

If the SmtpAuthMethod property is set to "NTLM", the SmtpUsername and SmtpPassword properties may be set to the string "default" to use the current Windows logged-on user credentials.

smtp.office365.com: If SMTP authentication fails for your smtp.office365.com account, it may be that your account is configured to require MFA (multi-factor authentication). You may need to change settings to allow for legacy authentication (single-factor auth). See https://docs.microsoft.com/en-us/azure/active-directory/conditional-access/block-legacy-authentication Also, an app password may be required. See https://docs.microsoft.com/en-us/azure/active-directory/user-help/multi-factor-authentication-end-user-app-passwords

More Information and Examples
top
SocksHostname
procedure CkMailMan_getSocksHostname(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putSocksHostname(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__socksHostname(objHandle: HCkMailMan): PWideChar; stdcall;

The SOCKS4/SOCKS5 hostname or IPv4 address (in dotted decimal notation). This property is only used if the SocksVersion property is set to 4 or 5).

top
SocksPassword
procedure CkMailMan_getSocksPassword(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putSocksPassword(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__socksPassword(objHandle: HCkMailMan): PWideChar; stdcall;

The SOCKS5 password (if required). The SOCKS4 protocol does not include the use of a password, so this does not apply to SOCKS4.

top
SocksPort
function CkMailMan_getSocksPort(objHandle: HCkMailMan): Integer; stdcall;
procedure CkMailMan_putSocksPort(objHandle: HCkMailMan; newPropVal: Integer); stdcall;

The SOCKS4/SOCKS5 proxy port. The default value is 1080. This property only applies if a SOCKS proxy is used (if the SocksVersion property is set to 4 or 5).

top
SocksUsername
procedure CkMailMan_getSocksUsername(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putSocksUsername(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__socksUsername(objHandle: HCkMailMan): PWideChar; stdcall;

The SOCKS4/SOCKS5 proxy username. This property is only used if the SocksVersion property is set to 4 or 5).

top
SocksVersion
function CkMailMan_getSocksVersion(objHandle: HCkMailMan): Integer; stdcall;
procedure CkMailMan_putSocksVersion(objHandle: HCkMailMan; newPropVal: Integer); stdcall;

May be set to one of the following integer values:

0 - No SOCKS proxy is used. This is the default.
4 - Connect via a SOCKS4 proxy.
5 - Connect via a SOCKS5 proxy.

top
SoRcvBuf
function CkMailMan_getSoRcvBuf(objHandle: HCkMailMan): Integer; stdcall;
procedure CkMailMan_putSoRcvBuf(objHandle: HCkMailMan; newPropVal: Integer); stdcall;

Sets the receive buffer size socket option. Normally, this property should be left unchanged. The default value is 4194304.

This property can be increased if download performance seems slow. It is recommended to be a multiple of 4096.

top
SoSndBuf
function CkMailMan_getSoSndBuf(objHandle: HCkMailMan): Integer; stdcall;
procedure CkMailMan_putSoSndBuf(objHandle: HCkMailMan; newPropVal: Integer); stdcall;

Sets the send buffer size socket option. Normally, this property should be left unchanged. The default value is 262144.

This property can be increased if upload performance seems slow. It is recommended to be a multiple of 4096. Testing with sizes such as 512K and 1MB is reasonable.

top
SslAllowedCiphers
procedure CkMailMan_getSslAllowedCiphers(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putSslAllowedCiphers(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__sslAllowedCiphers(objHandle: HCkMailMan): PWideChar; stdcall;
Introduced in version 9.5.0.48

Provides a means for setting a list of ciphers that are allowed for SSL/TLS connections. The default (empty string) indicates that all implemented ciphers are possible. The TLS ciphers supported in Chilkat v9.5.0.55 and later are:

TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256
TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256
TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256
TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA
TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256
TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA
TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384
TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384
TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA
TLS_DHE_RSA_WITH_AES_256_CBC_SHA256
TLS_DHE_RSA_WITH_AES_256_GCM_SHA384
TLS_DHE_RSA_WITH_AES_256_CBC_SHA
TLS_RSA_WITH_AES_256_CBC_SHA256
TLS_RSA_WITH_AES_256_GCM_SHA384
TLS_RSA_WITH_AES_256_CBC_SHA
TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256
TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA
TLS_DHE_RSA_WITH_AES_128_CBC_SHA256
TLS_DHE_RSA_WITH_AES_128_GCM_SHA256
TLS_DHE_RSA_WITH_AES_128_CBC_SHA
TLS_RSA_WITH_AES_128_CBC_SHA256
TLS_RSA_WITH_AES_128_GCM_SHA256
TLS_RSA_WITH_AES_128_CBC_SHA
TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA
TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA
TLS_RSA_WITH_3DES_EDE_CBC_SHA
TLS_ECDHE_RSA_WITH_RC4_128_SHA
TLS_RSA_WITH_RC4_128_SHA
TLS_RSA_WITH_RC4_128_MD5
TLS_DHE_RSA_WITH_DES_CBC_SHA
TLS_RSA_WITH_DES_CBC_SHA
To restrict SSL/TLS connections to one or more specific ciphers, set this property to a comma-separated list of ciphers such as "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384, TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384". The order should be in terms of preference, with the preferred algorithms listed first. (Note that the client cannot specifically choose the algorithm is picked because it is the server that chooses. The client simply provides the server with a list from which to choose.)

The property can also disallow connections with servers having certificates with RSA keys less than a certain size. By default, server certificates having RSA keys of 512 bits or greater are allowed. Add the keyword "rsa1024" to disallow connections with servers having keys smaller than 1024 bits. Add the keyword "rsa2048" to disallow connections with servers having keys smaller than 2048 bits.

Note: Prior to Chilkat v9.5.0.55, it was not possible to explicitly list allowed cipher suites. The deprecated means for indicating allowed ciphers was both incomplete and unprecise. For example, the following keywords could be listed to allow matching ciphers: "aes256-cbc", "aes128-cbc", "3des-cbc", and "rc4". These keywords will still be recognized, but programs should be updated to explicitly list the allowed ciphers.

secure-renegotiation: Starting in Chilkat v9.5.0.55, the keyword "secure-renegotiation" may be added to require that all renegotions be done securely (as per RFC 5746).

best-practices: Starting in Chilkat v9.5.0.55, this property may be set to the single keyword "best-practices". This will allow ciphers based on the current best practices. As new versions of Chilkat are released, the best practices may change. Changes will be noted here. The current best practices are:

  • If the server uses an RSA key, it must be 1024 bits or greater.
  • All renegotations must be secure renegotiations.
  • All ciphers using RC4, DES, or 3DES are disallowed.

Example: The following string would restrict to 2 specific cipher suites, require RSA keys to be 1024 bits or greater, and require secure renegotiations: "TLS_DHE_RSA_WITH_AES_256_CBC_SHA256, TLS_RSA_WITH_AES_256_CBC_SHA, rsa1024, secure-renegotiation"

top
SslProtocol
procedure CkMailMan_getSslProtocol(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putSslProtocol(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__sslProtocol(objHandle: HCkMailMan): PWideChar; stdcall;
Introduced in version 9.5.0.46

Selects the secure protocol to be used for secure (SSL/TLS) connections (for both SMTP and POP3). Possible values are:

default
TLS 1.3
TLS 1.2
TLS 1.1
TLS 1.0
SSL 3.0
TLS 1.3 or higher
TLS 1.2 or higher
TLS 1.1 or higher
TLS 1.0 or higher
The default value is "default" which will choose the, which allows for the protocol to be selected dynamically at runtime based on the requirements of the server. Choosing an exact protocol will cause the connection to fail unless that exact protocol is negotiated. It is better to choose "X or higher" than an exact protocol. The "default" is effectively "SSL 3.0 or higher".

top
StartTLS
function CkMailMan_getStartTLS(objHandle: HCkMailMan): wordbool; stdcall;
procedure CkMailMan_putStartTLS(objHandle: HCkMailMan; newPropVal: wordbool); stdcall;

When set to True, causes the mailman to issue a STARTTLS command to switch over to a secure SSL/TLS connection prior to authenticating and sending email. The default value is False.

Note: This property applies to SMTP, not to POP3.

More Information and Examples
top
StartTLSifPossible
function CkMailMan_getStartTLSifPossible(objHandle: HCkMailMan): wordbool; stdcall;
procedure CkMailMan_putStartTLSifPossible(objHandle: HCkMailMan; newPropVal: wordbool); stdcall;
Introduced in version 9.5.0.67

When set to True, causes the mailman to do STARTTLS (if possible and supported by the server) to convert to a secure SMTP SSL/TLS connection prior to authenticating and sending email. The default value is True.

Note: Setting the StartTLS property = True causes STARTTLS to always be used, even if the SMTP server does not support it. This property allows for a non-encrypted connection, whereas the StartTLS property disallows non-encrypted connections.

Note: This property applies to SMTP, not to POP3.

top
TlsCipherSuite
procedure CkMailMan_getTlsCipherSuite(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
function CkMailMan__tlsCipherSuite(objHandle: HCkMailMan): PWideChar; stdcall;
Introduced in version 9.5.0.49

Contains the current or last negotiated TLS cipher suite. If no TLS connection has yet to be established, or if a connection as attempted and failed, then this will be empty. A sample cipher suite string looks like this: TLS_DHE_RSA_WITH_AES_256_CBC_SHA256.

top
TlsPinSet
procedure CkMailMan_getTlsPinSet(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putTlsPinSet(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__tlsPinSet(objHandle: HCkMailMan): PWideChar; stdcall;
Introduced in version 9.5.0.55

Specifies a set of pins for Public Key Pinning for TLS connections. This property lists the expected SPKI fingerprints for the server certificates. If the server's certificate (sent during the TLS handshake) does not match any of the SPKI fingerprints, then the TLS handshake is aborted and the connection fails. The format of this string property is as follows:

hash_algorithm, encoding, SPKI_fingerprint_1, SPKI_fingerprint_2, ...
For example, the following string specifies a single sha256 base64-encoded SPKI fingerprint:
"sha256, base64, lKg1SIqyhPSK19tlPbjl8s02yChsVTDklQpkMCHvsTE="
This example specifies two SPKI fingerprints:
"sha256, base64, 4t37LpnGmrMEAG8HEz9yIrnvJV2euVRwCLb9EH5WZyI=, 68b0G5iqMvWVWvUCjMuhLEyekM5729PadtnU5tdXZKs="
Any of the following hash algorithms are allowed:.sha1, sha256, sha384, sha512, md2, md5, haval, ripemd128, ripemd160,ripemd256, or ripemd320.

The following encodings are allowed: base64, hex, and any of the encodings indicated in the link below.

More Information and Examples
top
TlsVersion
procedure CkMailMan_getTlsVersion(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
function CkMailMan__tlsVersion(objHandle: HCkMailMan): PWideChar; stdcall;
Introduced in version 9.5.0.49

Contains the current or last negotiated TLS protocol version. If no TLS connection has yet to be established, or if a connection as attempted and failed, then this will be empty. Possible values are "SSL 3.0", "TLS 1.0", "TLS 1.1", "TLS 1.2", and "TLS 1.3".

top
UncommonOptions
procedure CkMailMan_getUncommonOptions(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
procedure CkMailMan_putUncommonOptions(objHandle: HCkMailMan; newPropVal: PWideChar); stdcall;
function CkMailMan__uncommonOptions(objHandle: HCkMailMan): PWideChar; stdcall;
Introduced in version 9.5.0.80

This is a catch-all property to be used for uncommon needs. This property defaults to the empty string and should typically remain empty. Can be set to a list of the following comma separated keywords:

  • "ProtectFromVpn" - Introduced in v9.5.0.80. On Android systems, will bypass any VPN that may be installed or active.

More Information and Examples
top
UseApop
function CkMailMan_getUseApop(objHandle: HCkMailMan): wordbool; stdcall;
procedure CkMailMan_putUseApop(objHandle: HCkMailMan; newPropVal: wordbool); stdcall;

If True, will automatically use APOP authentication if the POP3 server supports it. The default value of this property is False.

top
VerboseLogging
function CkMailMan_getVerboseLogging(objHandle: HCkMailMan): wordbool; stdcall;
procedure CkMailMan_putVerboseLogging(objHandle: HCkMailMan; newPropVal: wordbool); stdcall;

If set to True, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. The default value is False. Verbose logging should only be used for debugging. The potentially large quantity of logged information may adversely affect peformance.

top
Version
procedure CkMailMan_getVersion(objHandle: HCkMailMan; outPropVal: HCkString); stdcall;
function CkMailMan__version(objHandle: HCkMailMan): PWideChar; stdcall;

Version of the component/library, such as "9.5.0.94"

More Information and Examples
top

Methods

AddPfxSourceData
function CkMailMan_AddPfxSourceData(objHandle: HCkMailMan;
    pfxData: HCkByteData;
    password: PWideChar): wordbool; stdcall;

Adds a PFX to the object's internal list of sources to be searched for certificates and private keys when decrypting or when creating signed email for sending. Multiple PFX sources can be added by calling this method once for each. (On the Windows operating system, the registry-based certificate stores are also automatically searched, so it is commonly not required to explicitly add PFX sources.)

The pfxData contains the bytes of a PFX file (also known as PKCS12 or .p12).

Returns True for success, False for failure.

top
AddPfxSourceFile
function CkMailMan_AddPfxSourceFile(objHandle: HCkMailMan;
    pfxFilePath: PWideChar;
    password: PWideChar): wordbool; stdcall;

Adds a PFX file to the object's internal list of sources to be searched for certificates and private keys when decrypting or when sending signed email. Multiple PFX files can be added by calling this method once for each. (On the Windows operating system, the registry-based certificate stores are also automatically searched, so it is commonly not required to explicitly add PFX sources.)

The pfxFilePath contains the bytes of a PFX file (also known as PKCS12 or .p12).

Returns True for success, False for failure.

top
CheckMail
function CkMailMan_CheckMail(objHandle: HCkMailMan): Integer; stdcall;

Returns the number of emails available on the POP3 server. Returns -1 on error.

The VerifyPopConnection method can be called to verify basic TCP/IP connectivity with the POP3 server. The VerifyPopLogin method can be called to verify the POP3 login. The Verify* methods are intended to be called as a way of diagnosing the failure when a POP3 method returns an error status.

top
CheckMailAsync (1)
function CkMailMan_CheckMailAsync(objHandle: HCkMailMan): HCkTask; stdcall;

Creates an asynchronous task to call the CheckMail method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
ClearBadEmailAddresses
procedure CkMailMan_ClearBadEmailAddresses(objHandle: HCkMailMan) stdcall;

Clears the list of bad email addresses stored within the Mailman object. When an email-sending method is called, any email addresses rejected by the SMTP server will be cached within the Mailman object. These can be accessed by calling the GetBadEmailAddresses method. This method clears the Mailman's in-memory cache of bad addresses.

top
ClearPop3SessionLog
procedure CkMailMan_ClearPop3SessionLog(objHandle: HCkMailMan) stdcall;

Clears the contents of the Pop3SessionLog property.

top
ClearSmtpSessionLog
procedure CkMailMan_ClearSmtpSessionLog(objHandle: HCkMailMan) stdcall;

Clears the contents of the SmtpSessionLog property.

top
CloseSmtpConnection
function CkMailMan_CloseSmtpConnection(objHandle: HCkMailMan): wordbool; stdcall;

The mailman object automatically opens an SMTP connection (if necessary) whenever an email-sending method is called. The connection is kept open until explicitly closed by this method. Calling this method is entirely optional. The SMTP connection is also automatically closed when the mailman object is destructed. Thus, if an application calls SendEmail 10 times to send 10 emails, the 1st call will open the SMTP connection, while the subsequent 9 will send over the existing connection (unless a property such as username, login, hostname, etc. is changed, which would force the connection to become closed and re-established with the next mail-sending method call).

Note: This method sends a QUIT command to the SMTP server prior to closing the connection.

Returns True for success, False for failure.

More Information and Examples
top
CloseSmtpConnectionAsync (1)
function CkMailMan_CloseSmtpConnectionAsync(objHandle: HCkMailMan): HCkTask; stdcall;

Creates an asynchronous task to call the CloseSmtpConnection method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
CopyMail
function CkMailMan_CopyMail(objHandle: HCkMailMan): HCkEmailBundle; stdcall;

Copy the email from a POP3 server into a EmailBundle. This does not remove the email from the POP3 server.

Returns nil on failure

More Information and Examples
top
CopyMailAsync (1) (2)
function CkMailMan_CopyMailAsync(objHandle: HCkMailMan): HCkTask; stdcall;

Creates an asynchronous task to call the CopyMail method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
DeleteBundle
function CkMailMan_DeleteBundle(objHandle: HCkMailMan;
    emailBundle: HCkEmailBundle): wordbool; stdcall;

Marks multiple emails on the POP3 server for deletion. (Each email in emailBundle that is also present on the server is marked for deletion.) To complete the deletion of the emails, a "QUIT" message must be sent and the POP3 session ended. This will happen automatically when the ImmediateDelete property equals True, which is the default. If ImmediateDelete equals False, then the Pop3EndSession method can be called to send the "QUIT" and end the session (i.e. disconnect.)

Note: When making multiple calls to a Delete* method, it's best to turn off ImmediateDelete, and then manually call Pop3EndSession to finalize the deletions.

Also, any method call requiring communication with the POP3 server will automatically re-establish a session based on the current property settings.

Returns True for success, False for failure.

top
DeleteBundleAsync (1)
function CkMailMan_DeleteBundleAsync(objHandle: HCkMailMan;
    emailBundle: HCkEmailBundle): HCkTask; stdcall;

Creates an asynchronous task to call the DeleteBundle method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
DeleteByMsgnum
function CkMailMan_DeleteByMsgnum(objHandle: HCkMailMan;
    msgnum: Integer): wordbool; stdcall;

Marks an email for deletion by message number. WARNING: Be very careful if calling this method. Message numbers are specific to a POP3 session. If a maildrop has (for example) 10 messages, the message numbers will be 1, 2, 3, ... 10. If message number 1 is deleted and a new POP3 session is established, there will be 9 messages numbered 1, 2, 3, ... 9.

IMPORTANT: A POP3 must first be established by either calling Pop3BeginSession explicitly, or implicitly by calling some other method that automatically establishes the session. This method will not automatically establish a new POP3 session (because if it did, the message numbers would potentially be different than what the application expects).

This method only marks an email for deletion. It is not actually removed from the maildrop until the POP3 session is explicitly ended by calling Pop3EndSession.

Returns True for success, False for failure.

top
DeleteByMsgnumAsync (1)
function CkMailMan_DeleteByMsgnumAsync(objHandle: HCkMailMan;
    msgnum: Integer): HCkTask; stdcall;

Creates an asynchronous task to call the DeleteByMsgnum method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
DeleteByUidl
function CkMailMan_DeleteByUidl(objHandle: HCkMailMan;
    uidl: PWideChar): wordbool; stdcall;

Marks an email on the POP3 server for deletion. To complete the deletion of an email, a "QUIT" message must be sent and the POP3 session ended. This will happen automatically when the ImmediateDelete property equals True, which is the default. If ImmediateDelete equals False, then the Pop3EndSession method can be called to send the "QUIT" and end the session (i.e. disconnect.)

Note: When making multiple calls to a Delete* method, it's best to turn off ImmediateDelete, and then manually call Pop3EndSession to finalize the deletions.

Also, any method call requiring communication with the POP3 server will automatically re-establish a session based on the current property settings.

Returns True for success, False for failure.

top
DeleteByUidlAsync (1)
function CkMailMan_DeleteByUidlAsync(objHandle: HCkMailMan;
    uidl: PWideChar): HCkTask; stdcall;

Creates an asynchronous task to call the DeleteByUidl method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
DeleteEmail
function CkMailMan_DeleteEmail(objHandle: HCkMailMan;
    email: HCkEmail): wordbool; stdcall;

Marks an email on the POP3 server for deletion. To complete the deletion of an email, a "QUIT" message must be sent and the POP3 session ended. This will happen automatically when the ImmediateDelete property equals True, which is the default. If ImmediateDelete equals False, then the Pop3EndSession method can be called to send the "QUIT" and end the session (i.e. disconnect.)

Note: When making multiple calls to a Delete* method, it's best to turn off ImmediateDelete, and then manually call Pop3EndSession to finalize the deletions.

Also, any method call requiring communication with the POP3 server will automatically re-establish a session based on the current property settings.

Returns True for success, False for failure.

top
DeleteEmailAsync (1)
function CkMailMan_DeleteEmailAsync(objHandle: HCkMailMan;
    email: HCkEmail): HCkTask; stdcall;

Creates an asynchronous task to call the DeleteEmail method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
DeleteMultiple
function CkMailMan_DeleteMultiple(objHandle: HCkMailMan;
    uidlArray: HCkStringArray): wordbool; stdcall;

Marks multiple emails on the POP3 server for deletion. (Any email on the server having a UIDL equal to a UIDL found in uidlArray is marked for deletion.) To complete the deletion of the emails, a "QUIT" message must be sent and the POP3 session ended. This will happen automatically when the ImmediateDelete property equals True, which is the default. If ImmediateDelete equals False, then the Pop3EndSession method can be called to send the "QUIT" and end the session (i.e. disconnect.)

Note: When making multiple calls to a Delete* method, it's best to turn off ImmediateDelete, and then manually call Pop3EndSession to finalize the deletions.

Also, any method call requiring communication with the POP3 server will automatically re-establish a session based on the current property settings.

Returns True for success, False for failure.

top
DeleteMultipleAsync (1)
function CkMailMan_DeleteMultipleAsync(objHandle: HCkMailMan;
    uidlArray: HCkStringArray): HCkTask; stdcall;

Creates an asynchronous task to call the DeleteMultiple method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
FetchByMsgnum
function CkMailMan_FetchByMsgnum(objHandle: HCkMailMan;
    msgnum: Integer): HCkEmail; stdcall;

Fetches an email by message number. WARNING: Be very careful if calling this method. Message numbers are specific to a POP3 session. If a maildrop has (for example) 10 messages, the message numbers will be 1, 2, 3, ... 10. If message number 1 is deleted and a new POP3 session is established, there will be 9 messages numbered 1, 2, 3, ... 9.

IMPORTANT: A POP3 connection must first be established by either calling Pop3BeginSession explicitly, or implicitly by calling some other method that automatically establishes the session. This method will not automatically establish a new POP3 session (because if it did, the message numbers would potentially be different than what the application expects).

Returns nil on failure

top
FetchByMsgnumAsync (1) (2)
function CkMailMan_FetchByMsgnumAsync(objHandle: HCkMailMan;
    msgnum: Integer): HCkTask; stdcall;

Creates an asynchronous task to call the FetchByMsgnum method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
FetchEmail
function CkMailMan_FetchEmail(objHandle: HCkMailMan;
    uidl: PWideChar): HCkEmail; stdcall;

Fetches an email from the POP3 mail server given its UIDL. Calling this method does not remove the email from the server. A typical program might get the email headers from the POP3 server by calling GetAllHeaders or GetHeaders, and then fetch individual emails by UIDL.

Returns a null reference on failure.

Returns nil on failure

More Information and Examples
top
FetchEmailAsync (1) (2)
function CkMailMan_FetchEmailAsync(objHandle: HCkMailMan;
    uidl: PWideChar): HCkTask; stdcall;

Creates an asynchronous task to call the FetchEmail method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
FetchMime
function CkMailMan_FetchMime(objHandle: HCkMailMan;
    uidl: PWideChar;
    outData: HCkByteData): wordbool; stdcall;

Fetches an email by UIDL and returns the MIME source of the email in a byte array.

Returns True for success, False for failure.

top
FetchMimeAsync (1)
function CkMailMan_FetchMimeAsync(objHandle: HCkMailMan;
    uidl: PWideChar): HCkTask; stdcall;

Creates an asynchronous task to call the FetchMime method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
FetchMimeBd
function CkMailMan_FetchMimeBd(objHandle: HCkMailMan;
    uidl: PWideChar;
    mimeData: HCkBinData): wordbool; stdcall;
Introduced in version 9.5.0.73

Fetches an email by UIDL and returns the MIME source of the email in uidl.

Returns True for success, False for failure.

More Information and Examples
top
FetchMimeBdAsync (1)
function CkMailMan_FetchMimeBdAsync(objHandle: HCkMailMan;
    uidl: PWideChar;
    mimeData: HCkBinData): HCkTask; stdcall;
Introduced in version 9.5.0.73

Creates an asynchronous task to call the FetchMimeBd method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
FetchMimeByMsgnum
function CkMailMan_FetchMimeByMsgnum(objHandle: HCkMailMan;
    msgnum: Integer;
    outBytes: HCkByteData): wordbool; stdcall;

Fetches an email by message number and returns the MIME source of the email in a byte array. WARNING: Message sequend numbers are specific to a POP3 session. If a maildrop has (for example) 10 messages, the message numbers will be 1, 2, 3, ... 10. If message number 1 is deleted and a new POP3 session is established, there will be 9 messages numbered 1, 2, 3, ... 9.

IMPORTANT: A POP3 connection must first be established by either calling Pop3BeginSession explicitly, or implicitly by calling some other method that automatically establishes the session. This method will not automatically establish a new POP3 session (because if it did, the message numbers would potentially be different than what the application expects).

Returns True for success, False for failure.

top
FetchMimeByMsgnumAsync (1)
function CkMailMan_FetchMimeByMsgnumAsync(objHandle: HCkMailMan;
    msgnum: Integer): HCkTask; stdcall;

Creates an asynchronous task to call the FetchMimeByMsgnum method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
FetchMultiple
function CkMailMan_FetchMultiple(objHandle: HCkMailMan;
    uidlArray: HCkStringArray): HCkEmailBundle; stdcall;

Given an array of UIDL strings, fetchs all the emails from the POP3 server whose UIDL is present in the array, and returns the emails in a bundle.

Returns nil on failure

More Information and Examples
top
FetchMultipleAsync (1) (2)
function CkMailMan_FetchMultipleAsync(objHandle: HCkMailMan;
    uidlArray: HCkStringArray): HCkTask; stdcall;

Creates an asynchronous task to call the FetchMultiple method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
FetchMultipleHeaders
function CkMailMan_FetchMultipleHeaders(objHandle: HCkMailMan;
    uidlArray: HCkStringArray;
    numBodyLines: Integer): HCkEmailBundle; stdcall;

Given an array of UIDL strings, fetchs all the email headers from the POP3 server whose UIDL is present in the array.

Note: The email objects returned in the bundle contain only headers. The attachments will be missing, and the bodies will be mostly missing (only the 1st numBodyLines lines of either the plain-text or HTML body will be present).

Returns nil on failure

top
FetchMultipleHeadersAsync (1) (2)
function CkMailMan_FetchMultipleHeadersAsync(objHandle: HCkMailMan;
    uidlArray: HCkStringArray;
    numBodyLines: Integer): HCkTask; stdcall;

Creates an asynchronous task to call the FetchMultipleHeaders method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
FetchMultipleMime
function CkMailMan_FetchMultipleMime(objHandle: HCkMailMan;
    uidlArray: HCkStringArray): HCkStringArray; stdcall;

Given an array of UIDL strings, fetchs all the emails from the POP3 server whose UIDL is present in the array, and returns the MIME source of each email in an "stringarray" -- an object containing a collection of strings. Returns a null reference on failure.

Returns nil on failure

top
FetchMultipleMimeAsync (1) (2)
function CkMailMan_FetchMultipleMimeAsync(objHandle: HCkMailMan;
    uidlArray: HCkStringArray): HCkTask; stdcall;

Creates an asynchronous task to call the FetchMultipleMime method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
FetchSingleHeader
function CkMailMan_FetchSingleHeader(objHandle: HCkMailMan;
    numBodyLines: Integer;
    messageNumber: Integer): HCkEmail; stdcall;

Fetches a single header by message number. Returns an email object on success, or a null reference on failure.

Note: The email objects returned in the bundle contain only headers. The attachments will be missing, and the bodies will be mostly missing (only the 1st messageNumber lines of either the plain-text or HTML body will be present).

Also Important:Message numbers are specific to a POP3 session (whereas UIDLs are valid across sessions). Be very careful when using this method.

Returns nil on failure

top
FetchSingleHeaderAsync (1) (2)
function CkMailMan_FetchSingleHeaderAsync(objHandle: HCkMailMan;
    numBodyLines: Integer;
    messageNumber: Integer): HCkTask; stdcall;

Creates an asynchronous task to call the FetchSingleHeader method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
FetchSingleHeaderByUidl
function CkMailMan_FetchSingleHeaderByUidl(objHandle: HCkMailMan;
    numBodyLines: Integer;
    uidl: PWideChar): HCkEmail; stdcall;

Fetches a single header by UIDL. Returns an email object on success, or a null reference on failure.

Note: The email objects returned in the bundle contain only headers. The attachments will be missing, and the bodies will be mostly missing (only the 1st uidl lines of either the plain-text or HTML body will be present).

Returns nil on failure

top
FetchSingleHeaderByUidlAsync (1) (2)
function CkMailMan_FetchSingleHeaderByUidlAsync(objHandle: HCkMailMan;
    numBodyLines: Integer;
    uidl: PWideChar): HCkTask; stdcall;

Creates an asynchronous task to call the FetchSingleHeaderByUidl method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
GetAllHeaders
function CkMailMan_GetAllHeaders(objHandle: HCkMailMan;
    numBodyLines: Integer): HCkEmailBundle; stdcall;

Returns all the emails from the POP3 server, but only the first numBodyLines lines of the body. Attachments are not returned. The emails returned in the bundle are valid email objects, the only difference is that the body is truncated to include only the top numBodyLines lines, and the attachments will be missing.

Returns nil on failure

top
GetAllHeadersAsync (1) (2)
function CkMailMan_GetAllHeadersAsync(objHandle: HCkMailMan;
    numBodyLines: Integer): HCkTask; stdcall;

Creates an asynchronous task to call the GetAllHeaders method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
GetBadEmailAddrs
function CkMailMan_GetBadEmailAddrs(objHandle: HCkMailMan): HCkStringArray; stdcall;

Returns a string array object containing a list of failed and invalid email addresses that have accumulated during SMTP sends. The list will not contain duplicates. Also, this only works with some SMTP servers -- not all SMTP servers check the validity of each email address.

Note: An SMTP server can only validate the email addresses within it's own domain. External email address are not verifiable at the time of sending.

Returns nil on failure

More Information and Examples
top
GetFullEmail
function CkMailMan_GetFullEmail(objHandle: HCkMailMan;
    email: HCkEmail): HCkEmail; stdcall;

If a partial email was obtained using GetHeaders or GetAllHeaders, this method will take the partial email as an argument, and download the full email from the server. A new email object (separate from the partial email) is returned. A null reference is returned on failure.

Returns nil on failure

top
GetFullEmailAsync (1) (2)
function CkMailMan_GetFullEmailAsync(objHandle: HCkMailMan;
    email: HCkEmail): HCkTask; stdcall;

Creates an asynchronous task to call the GetFullEmail method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
GetHeaders
function CkMailMan_GetHeaders(objHandle: HCkMailMan;
    numBodyLines: Integer;
    fromIndex: Integer;
    toIndex: Integer): HCkEmailBundle; stdcall;

The same as the GetAllHeaders method, except only the emails from fromIndex to toIndex on the POP3 server are returned. The first email on the server is at index 0.

Returns nil on failure

top
GetHeadersAsync (1) (2)
function CkMailMan_GetHeadersAsync(objHandle: HCkMailMan;
    numBodyLines: Integer;
    fromIndex: Integer;
    toIndex: Integer): HCkTask; stdcall;

Creates an asynchronous task to call the GetHeaders method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
GetMailboxCount
function CkMailMan_GetMailboxCount(objHandle: HCkMailMan): Integer; stdcall;

Returns the number of emails on the POP3 server, or -1 for failure.

This method is identical to CheckEmail. It was added for clarity.

top
GetMailboxCountAsync (1)
function CkMailMan_GetMailboxCountAsync(objHandle: HCkMailMan): HCkTask; stdcall;

Creates an asynchronous task to call the GetMailboxCount method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
GetMailboxInfoXml
function CkMailMan_GetMailboxInfoXml(objHandle: HCkMailMan;
    outXml: HCkString): wordbool; stdcall;
function CkMailMan__getMailboxInfoXml(objHandle: HCkMailMan): PWideChar; stdcall;

Returns an XML document with information about the emails in a POP3 mailbox. The XML contains the UIDL and size (in bytes) of each email in the mailbox.

Returns True for success, False for failure.

More Information and Examples
top
GetMailboxInfoXmlAsync (1)
function CkMailMan_GetMailboxInfoXmlAsync(objHandle: HCkMailMan): HCkTask; stdcall;

Creates an asynchronous task to call the GetMailboxInfoXml method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
GetMailboxSize
function CkMailMan_GetMailboxSize(objHandle: HCkMailMan): LongWord; stdcall;

Returns the total combined size in bytes of all the emails in the POP3 mailbox. This is also known as the "mail drop" size. Returns -1 on failure.

top
GetMailboxSizeAsync (1)
function CkMailMan_GetMailboxSizeAsync(objHandle: HCkMailMan): HCkTask; stdcall;

Creates an asynchronous task to call the GetMailboxSize method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
GetPop3SslServerCert
function CkMailMan_GetPop3SslServerCert(objHandle: HCkMailMan): HCkCert; stdcall;

Returns the POP3 server's SSL certificate. This is available after connecting via SSL to a POP3 server. (To use POP3 SSL, set the PopSsl property = True.)

Returns a null reference if no POP3 SSL certificate is available.

Returns nil on failure

top
GetSentToEmailAddrs
function CkMailMan_GetSentToEmailAddrs(objHandle: HCkMailMan): HCkStringArray; stdcall;

Returns the list of successful email addresses in the last call to a mail sending method, such as SendEmail.

When an email is sent, the email addresses that were flagged invalid by the SMTP server are saved in a "bad email addresses" list within the mailman object, and the acceptable email addresses are saved in a "good email addresses" list (within the mailman object). These internal lists are automatically reset at the start of the next mail-sending method call. This allows for a program to know which email addresses were accepted and which were not.

Note: The AllOrNone property controls whether the mail-sending method, such as SendEmail, returns False (to indicate failure) if any single email address is rejected.

Note: An SMTP server can only be aware of invalid email addresses that are of the same domain. For example, the comcast.net mail servers would only be aware of what comcast.net email addresses are valid. All external email addresses are implicitly accepted because the server is simply forwarding the email towards the mail server controlling that domain.

Returns nil on failure

More Information and Examples
top
GetSizeByUidl
function CkMailMan_GetSizeByUidl(objHandle: HCkMailMan;
    uidl: PWideChar): Integer; stdcall;

Returns the size of an email (including attachments) given the UIDL of the email on the POP3 server. Returns -1 for failure.

top
GetSizeByUidlAsync (1)
function CkMailMan_GetSizeByUidlAsync(objHandle: HCkMailMan;
    uidl: PWideChar): HCkTask; stdcall;

Creates an asynchronous task to call the GetSizeByUidl method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
GetSmtpSslServerCert
function CkMailMan_GetSmtpSslServerCert(objHandle: HCkMailMan): HCkCert; stdcall;

If using SSL/TLS, this method returns the SMTP server's digital certificate used with the secure connection.

Returns nil on failure

top
GetUidls
function CkMailMan_GetUidls(objHandle: HCkMailMan): HCkStringArray; stdcall;

Returns the UIDLs of the emails currently stored on the POP3 server.

Returns nil on failure

More Information and Examples
top
GetUidlsAsync (1) (2)
function CkMailMan_GetUidlsAsync(objHandle: HCkMailMan): HCkTask; stdcall;

Creates an asynchronous task to call the GetUidls method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
IsSmtpDsnCapable
function CkMailMan_IsSmtpDsnCapable(objHandle: HCkMailMan): wordbool; stdcall;

Contacts the SMTP server and determines if it supports the DSN (Delivery Status Notification) features specified by RFC 3461 and supported by the DsnEnvid, DsnNotify, and DsnRet properties. Returns True if the SMTP server supports DSN, otherwise returns False.

top
IsSmtpDsnCapableAsync (1)
function CkMailMan_IsSmtpDsnCapableAsync(objHandle: HCkMailMan): HCkTask; stdcall;

Creates an asynchronous task to call the IsSmtpDsnCapable method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
LastJsonData
function CkMailMan_LastJsonData(objHandle: HCkMailMan): HCkJsonObject; stdcall;
Introduced in version 9.5.0.69

Provides information about what transpired in the last method called on this object instance. For many methods, there is no information. However, for some methods, details about what occurred can be obtained by getting the LastJsonData right after the method call returns.

Returns nil on failure

top
LoadEml
function CkMailMan_LoadEml(objHandle: HCkMailMan;
    emlFilename: PWideChar): HCkEmail; stdcall;

Loads an email from a .eml file. (EML files contain the MIME source of an email.) Returns a null reference on failure.

Note: MHT files can be loaded into an email object by calling this method.

Returns nil on failure

More Information and Examples
top
LoadMbx
function CkMailMan_LoadMbx(objHandle: HCkMailMan;
    mbxFileName: PWideChar): HCkEmailBundle; stdcall;

Loads a .mbx file containing emails and returns an email bundle. If a Filter is present, only emails matching the filter are returned.

Returns nil on failure

top
LoadMime
function CkMailMan_LoadMime(objHandle: HCkMailMan;
    mimeText: PWideChar): HCkEmail; stdcall;

Creates and loads an email from a MIME string. Returns a null reference on failure.

Returns nil on failure

top
LoadTaskCaller
function CkMailMan_LoadTaskCaller(objHandle: HCkMailMan;
    task: HCkTask): wordbool; stdcall;
Introduced in version 9.5.0.80

Loads the caller of the task's async method.

Returns True for success, False for failure.

top
LoadXmlEmail
function CkMailMan_LoadXmlEmail(objHandle: HCkMailMan;
    filename: PWideChar): HCkEmail; stdcall;

Loads an XML file containing a single email and returns an email object. Returns a null reference on failure.

Returns nil on failure

top
LoadXmlEmailString
function CkMailMan_LoadXmlEmailString(objHandle: HCkMailMan;
    xmlString: PWideChar): HCkEmail; stdcall;

Loads an XML string containing a single email and returns an email object. Returns a null reference on failure.

Returns nil on failure

top
LoadXmlFile
function CkMailMan_LoadXmlFile(objHandle: HCkMailMan;
    filename: PWideChar): HCkEmailBundle; stdcall;

Loads an XML file containing one or more emails and returns an email bundle. If a Filter is present, only emails matching the filter are returned. Returns a null reference on failure.

Returns nil on failure

top
LoadXmlString
function CkMailMan_LoadXmlString(objHandle: HCkMailMan;
    xmlString: PWideChar): HCkEmailBundle; stdcall;

Loads from an XML string containing emails and returns an email bundle. If a Filter is present, only emails matching the filter are returned.

Returns nil on failure

top
MxLookup
function CkMailMan_MxLookup(objHandle: HCkMailMan;
    emailAddress: PWideChar;
    outStrHostname: HCkString): wordbool; stdcall;
function CkMailMan__mxLookup(objHandle: HCkMailMan;
    emailAddress: PWideChar): PWideChar; stdcall;

Performs a DNS MX lookup to return the mail server hostname based on an email address.

Returns True for success, False for failure.

More Information and Examples
top
MxLookupAll
function CkMailMan_MxLookupAll(objHandle: HCkMailMan;
    emailAddress: PWideChar): HCkStringArray; stdcall;

Performs a DNS MX lookup to return the list of mail server hostnames based on an email address. The primary server is at index 0. In most cases, there is only one mail server for a given email address.

Returns nil on failure

top
OpenSmtpConnection
function CkMailMan_OpenSmtpConnection(objHandle: HCkMailMan): wordbool; stdcall;

Explicitly opens a connection to the SMTP server and authenticates (if a username/password was specified). Calling this method is optional because the SendEmail method and other mail-sending methods will automatically open the connection to the SMTP server if one is not already established.

Note: This method is the equivalent of calling SmtpConnect followed by SmtpAuthenticate.

Returns True for success, False for failure.

top
OpenSmtpConnectionAsync (1)
function CkMailMan_OpenSmtpConnectionAsync(objHandle: HCkMailMan): HCkTask; stdcall;

Creates an asynchronous task to call the OpenSmtpConnection method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
Pop3Authenticate
function CkMailMan_Pop3Authenticate(objHandle: HCkMailMan): wordbool; stdcall;
Introduced in version 9.5.0.56

Authenticates with the POP3 server using the property settings such as PopUsername, PopPassword, etc. This method should only be called after a successful call to Pop3Connect.

Note 1: The Pop3BeginSession method both connects and authenticates. It is the equivalent of calling Pop3Connect followed by Pop3Authenticate.

Note 2: All methods that communicate with the POP3 server, such as FetchEmail, will automatically connect and authenticate if not already connected and authenticated.

Returns True for success, False for failure.

top
Pop3AuthenticateAsync (1)
function CkMailMan_Pop3AuthenticateAsync(objHandle: HCkMailMan): HCkTask; stdcall;
Introduced in version 9.5.0.56

Creates an asynchronous task to call the Pop3Authenticate method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
Pop3BeginSession
function CkMailMan_Pop3BeginSession(objHandle: HCkMailMan): wordbool; stdcall;

Call to explicitly begin a POP3 session. It is not necessary to call this method because any method requiring an established POP3 session will automatically connect and login if a session is not already open.

Important: All TCP-based Internet communications, regardless of the protocol (such as HTTP, FTP, SSH, IMAP, POP3, SMTP, etc.), and regardless of SSL/TLS, begin with establishing a TCP connection to a remote host:port. External security-related infrastructure such as software firewalls (Windows Firewall), hardware firewalls, anti-virus, at either source or destination (or both) can block the connection. If the connection fails, make sure to check all potential external causes of blockage.

Returns True for success, False for failure.

More Information and Examples
top
Pop3BeginSessionAsync (1)
function CkMailMan_Pop3BeginSessionAsync(objHandle: HCkMailMan): HCkTask; stdcall;

Creates an asynchronous task to call the Pop3BeginSession method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
Pop3Connect
function CkMailMan_Pop3Connect(objHandle: HCkMailMan): wordbool; stdcall;
Introduced in version 9.5.0.56

Explicitly establishes a connection to the POP3 server, which includes establishing a secure TLS channel if required, and receives the initial greeting. This method stops short of authenticating. The Pop3Authenticate method should be called after a successful call to this method.

When finished transacting with a POP3 mail server you can disconnect by calling Pop3EndSession or Pop3EndSessionNoQuit.

Note 1: The Pop3BeginSession method both connects and authenticates. It is the equivalent of calling Pop3Connect followed by Pop3Authenticate.

Note 2: All methods that communicate with the POP3 server, such as FetchEmail, will automatically connect and authenticate if not already connected and authenticated.

Important: All TCP-based Internet communications, regardless of the protocol (such as HTTP, FTP, SSH, IMAP, POP3, SMTP, etc.), and regardless of SSL/TLS, begin with establishing a TCP connection to a remote host:port. External security-related infrastructure such as software firewalls (Windows Firewall), hardware firewalls, anti-virus, at either source or destination (or both) can block the connection. If the connection fails, make sure to check all potential external causes of blockage.

Returns True for success, False for failure.

top
Pop3ConnectAsync (1)
function CkMailMan_Pop3ConnectAsync(objHandle: HCkMailMan): HCkTask; stdcall;
Introduced in version 9.5.0.56

Creates an asynchronous task to call the Pop3Connect method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
Pop3EndSession
function CkMailMan_Pop3EndSession(objHandle: HCkMailMan): wordbool; stdcall;

Call to explicitly end a POP3 session (sends the QUIT command and then closes the connection with the POP3 server). If the ImmediateDelete property is set to False, and emails marked for deletion will be deleted at this time.

Returns True for success, False for failure.

top
Pop3EndSessionAsync (1)
function CkMailMan_Pop3EndSessionAsync(objHandle: HCkMailMan): HCkTask; stdcall;

Creates an asynchronous task to call the Pop3EndSession method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
Pop3EndSessionNoQuit
function CkMailMan_Pop3EndSessionNoQuit(objHandle: HCkMailMan): wordbool; stdcall;

This method is identical to Pop3EndSession, but no "QUIT" command is sent. The client simply disconnects from the POP3 server.

This method should always return True.

top
Pop3EndSessionNoQuitAsync (1)
function CkMailMan_Pop3EndSessionNoQuitAsync(objHandle: HCkMailMan): HCkTask; stdcall;

Creates an asynchronous task to call the Pop3EndSessionNoQuit method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
Pop3Noop
function CkMailMan_Pop3Noop(objHandle: HCkMailMan): wordbool; stdcall;

Sends a NOOP command to the POP3 server. This may be a useful method to call periodically to keep a connection open, or to verify that the POP3 connection (session) is open and functioning.

Returns True for success, False for failure.

top
Pop3NoopAsync (1)
function CkMailMan_Pop3NoopAsync(objHandle: HCkMailMan): HCkTask; stdcall;

Creates an asynchronous task to call the Pop3Noop method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
Pop3Reset
function CkMailMan_Pop3Reset(objHandle: HCkMailMan): wordbool; stdcall;

Sends a RSET command to the POP3 server. If any messages have been marked as deleted by the POP3 server, they are unmarked. Calling Pop3Reset resets the POP3 session to a valid, known starting point.

Returns True for success, False for failure.

top
Pop3ResetAsync (1)
function CkMailMan_Pop3ResetAsync(objHandle: HCkMailMan): HCkTask; stdcall;

Creates an asynchronous task to call the Pop3Reset method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
Pop3SendRawCommand
function CkMailMan_Pop3SendRawCommand(objHandle: HCkMailMan;
    command: PWideChar;
    charset: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkMailMan__pop3SendRawCommand(objHandle: HCkMailMan;
    command: PWideChar;
    charset: PWideChar): PWideChar; stdcall;

Sends a raw command to the POP3 server and returns the POP3 server's response. If non-us-ascii characters are included in command, then charset indicates the charset to be used in sending the command (such as "utf-8", "ansi", "iso-8859-1", "Shift_JIS", etc.)

Returns True for success, False for failure.

top
Pop3SendRawCommandAsync (1)
function CkMailMan_Pop3SendRawCommandAsync(objHandle: HCkMailMan;
    command: PWideChar;
    charset: PWideChar): HCkTask; stdcall;

Creates an asynchronous task to call the Pop3SendRawCommand method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
QuickSend
function CkMailMan_QuickSend(objHandle: HCkMailMan;
    fromAddr: PWideChar;
    toAddr: PWideChar;
    subject: PWideChar;
    body: PWideChar;
    smtpServer: PWideChar): wordbool; stdcall;

A quick way to send an email to a single recipient without having to explicitly create an email object.

Returns True for success, False for failure.

top
QuickSendAsync (1)
function CkMailMan_QuickSendAsync(objHandle: HCkMailMan;
    fromAddr: PWideChar;
    toAddr: PWideChar;
    subject: PWideChar;
    body: PWideChar;
    smtpServer: PWideChar): HCkTask; stdcall;

Creates an asynchronous task to call the QuickSend method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
RenderToMime
function CkMailMan_RenderToMime(objHandle: HCkMailMan;
    email: HCkEmail;
    outStr: HCkString): wordbool; stdcall;
function CkMailMan__renderToMime(objHandle: HCkMailMan;
    email: HCkEmail): PWideChar; stdcall;

When an email is sent by calling SendEmail, it is first "rendered" according to the values of the email properties and contents. It may be digitally signed, encrypted, values substituted for replacement patterns, and header fields "Q"or "B" encoded as needed based on the email. The RenderToMime method performs the rendering, but without the actual sending. The MIME text produced is exactly what would be sent to the SMTP server had SendEmail been called. (The SendEmail method is effectively the same as calling RenderToMime followed by a call to SendMime.)

The rendered MIME string is returned on success.

Returns True for success, False for failure.

More Information and Examples
top
RenderToMimeBd
function CkMailMan_RenderToMimeBd(objHandle: HCkMailMan;
    email: HCkEmail;
    renderedMime: HCkBinData): wordbool; stdcall;
Introduced in version 9.5.0.62

The same as RenderToMimeBytes, except the MIME is rendered into renderedMime. The rendered MIME is appended to renderedMime.

Returns True for success, False for failure.

More Information and Examples
top
RenderToMimeBytes
function CkMailMan_RenderToMimeBytes(objHandle: HCkMailMan;
    email: HCkEmail;
    outBytes: HCkByteData): wordbool; stdcall;

This method is the same as RenderToMime, but the MIME is returned in a byte array. If an email uses an 8bit or binary MIME encoding, then calling RenderToMime may introduce errors because it is not possible to return non-text binary data as a string. Therefore, calling RenderToMimeBytes is recommended over RenderToMime, unless it is assured that the email (MIME) does not use a binary encoding for non-text data.

Returns True for success, False for failure.

top
RenderToMimeSb
function CkMailMan_RenderToMimeSb(objHandle: HCkMailMan;
    email: HCkEmail;
    renderedMime: HCkStringBuilder): wordbool; stdcall;
Introduced in version 9.5.0.62

The same as RenderToMime, except the MIME is rendered into renderedMime. The rendered MIME is appended to renderedMime.

Returns True for success, False for failure.

top
SendBundle
function CkMailMan_SendBundle(objHandle: HCkMailMan;
    bundle: HCkEmailBundle): wordbool; stdcall;

Sends a bundle of emails. This is identical to calling SendEmail for each email in the bundle.

If an error occurs when sending one of the emails in the bundle, it will continue with each subsequent email until each email in the bundle has been attempted (unless a fatal error occurs, in which case the send is aborted).

Because it is difficult or impossible to programmatically identify which emails in the bundle failed and which succeeded, it is best to write a loop that sends each email separately (via the SendEmail method).

Returns True for success, False for failure.

top
SendBundleAsync (1)
function CkMailMan_SendBundleAsync(objHandle: HCkMailMan;
    bundle: HCkEmailBundle): HCkTask; stdcall;

Creates an asynchronous task to call the SendBundle method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
SendEmail
function CkMailMan_SendEmail(objHandle: HCkMailMan;
    email: HCkEmail): wordbool; stdcall;

Sends a single email. The connection to the SMTP server will remain open so that a subsequent call to SendEmail (or other email-sending methods) can re-use the same connection. If any properties relating to the SMTP server are changed, such as SmtpHost, SmtpUsername, etc., then the next call to an email-sending method will automatically close the connection and re-establish a connection using the updated property settings.

Important: Some SMTP servers do not actually send the email until the connection is closed. In these cases, it is necessary to call CloseSmtpConnection for the mail to be sent. Most SMTP servers send the email immediately, and it is not required to close the connection.

GMail: If sending via smtp.gmail.com, then send with OAuth2 authentication if possible. Otherwise you will need to change your GMail account settings to allow for sending by less secure apps. See the links below.

Note: After sending email, information about what transpired is available via the LastJsonData method.

Note: Returns True if the final SMTP status code in the SMTP session is in the 200's or 300's. See SMTP Server Return Codes

Returns True for success, False for failure.

top
SendEmailAsync (1)
function CkMailMan_SendEmailAsync(objHandle: HCkMailMan;
    email: HCkEmail): HCkTask; stdcall;

Creates an asynchronous task to call the SendEmail method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
SendMime
function CkMailMan_SendMime(objHandle: HCkMailMan;
    fromAddr: PWideChar;
    recipients: PWideChar;
    mimeSource: PWideChar): wordbool; stdcall;

Provides complete control over the email that is sent. The MIME text passed in mimeSource (the MIME source of an email) is passed exactly as-is to the SMTP server. The recipients is a comma separated list of recipient email addresses. The fromAddr is the reverse-path email address. This is where bounced email (non-delivery reports) will be delivered. It may be different than the "From" header field in the mimeSource.

To understand how the fromAddr and recipients relate to the email addresses found in the MIME headers (FROM, TO, CC), see the link below entitled "SMTP Protocol in a Nutshell". The fromAddr is what is passed to the SMTP server in the "MAIL FROM" command. The recipients are the email addresses passed in "RCPT TO" commands. These are usually the same email addresses found in the MIME headers, but need not be (unless the SMTP server enforces policies that require them to be the same).

Note: Returns True if the final SMTP status code in the SMTP session is in the 200's or 300's. See SMTP Server Return Codes

Returns True for success, False for failure.

top
SendMimeAsync (1)
function CkMailMan_SendMimeAsync(objHandle: HCkMailMan;
    fromAddr: PWideChar;
    recipients: PWideChar;
    mimeSource: PWideChar): HCkTask; stdcall;

Creates an asynchronous task to call the SendMime method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
SendMimeBd
function CkMailMan_SendMimeBd(objHandle: HCkMailMan;
    fromAddr: PWideChar;
    recipients: PWideChar;
    mimeData: HCkBinData): wordbool; stdcall;
Introduced in version 9.5.0.73

This method is the same as SendMimeBytes, except the MIME is passed in an object (mimeData) rather than explicitly passing the bytes.

Note: Returns True if the final SMTP status code in the SMTP session is in the 200's or 300's. See SMTP Server Return Codes

Returns True for success, False for failure.

top
SendMimeBdAsync (1)
function CkMailMan_SendMimeBdAsync(objHandle: HCkMailMan;
    fromAddr: PWideChar;
    recipients: PWideChar;
    mimeData: HCkBinData): HCkTask; stdcall;
Introduced in version 9.5.0.73

Creates an asynchronous task to call the SendMimeBd method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
SendMimeBytes
function CkMailMan_SendMimeBytes(objHandle: HCkMailMan;
    fromAddr: PWideChar;
    recipients: PWideChar;
    mimeSource: HCkByteData): wordbool; stdcall;

This method is the same as SendMime, except the MIME is passed in a byte array. This can be important if the MIME uses a binary encoding, or if a DKIM/DomainKey signature is included.

To understand how the fromAddr and recipients relate to the email addresses found in the MIME headers (FROM, TO, CC), see the link below entitled "SMTP Protocol in a Nutshell". The fromAddr is what is passed to the SMTP server in the "MAIL FROM" command. The recipients are the email addresses passed in "RCPT TO" commands. These are usually the same email addresses found in the MIME headers, but need not be (unless the SMTP server enforces policies that require them to be the same).

Note: Returns True if the final SMTP status code in the SMTP session is in the 200's or 300's. See SMTP Server Return Codes

Returns True for success, False for failure.

top
SendMimeBytesAsync (1)
function CkMailMan_SendMimeBytesAsync(objHandle: HCkMailMan;
    fromAddr: PWideChar;
    recipients: PWideChar;
    mimeSource: HCkByteData): HCkTask; stdcall;

Creates an asynchronous task to call the SendMimeBytes method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
SendMimeToList
function CkMailMan_SendMimeToList(objHandle: HCkMailMan;
    fromAddr: PWideChar;
    distListFilename: PWideChar;
    mimeSource: PWideChar): wordbool; stdcall;

Same as SendMime, but the recipient list is read from a text file (distListFilename) containing one email address per line.

Returns True for success, False for failure.

top
SendMimeToListAsync (1)
function CkMailMan_SendMimeToListAsync(objHandle: HCkMailMan;
    fromAddr: PWideChar;
    distListFilename: PWideChar;
    mimeSource: PWideChar): HCkTask; stdcall;

Creates an asynchronous task to call the SendMimeToList method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
SetDecryptCert
function CkMailMan_SetDecryptCert(objHandle: HCkMailMan;
    cert: HCkCert): wordbool; stdcall;
Introduced in version 9.5.0.40

Explicitly specifies the certificate to be used for decrypting encrypted email.

Returns True for success, False for failure.

top
SetDecryptCert2
function CkMailMan_SetDecryptCert2(objHandle: HCkMailMan;
    cert: HCkCert;
    privateKey: HCkPrivateKey): wordbool; stdcall;

Explicitly specifies the certificate and associated private key to be used for decrypting S/MIME encrypted email.

Note: In most cases, it is easier to call AddPfxSourceFile or AddPfxSourceData to provide the required cert and private key. On Windows systems where the certificate + private key has already been installed in the default certificate store, nothing needs to be done -- the mailman will automatically locate and use the required cert + private key.

Returns True for success, False for failure.

top
SetPassword
function CkMailMan_SetPassword(objHandle: HCkMailMan;
    protocol: PWideChar;
    password: HCkSecureString): wordbool; stdcall;
Introduced in version 9.5.0.71

Provides a more secure way of setting either the POP3 or SMTP password. The protocol can be "pop3" or "smtp". When the protocol is "pop3", this is equivalent to setting the PopPassword property. When protocol is "smtp", this is equivalent to setting the SmtpPassword property.

Returns True for success, False for failure.

More Information and Examples
top
SetSslClientCert
function CkMailMan_SetSslClientCert(objHandle: HCkMailMan;
    cert: HCkCert): wordbool; stdcall;

Sets the client-side certificate to be used with SSL connections. This is typically not required, as most SSL connections are such that only the server is authenticated while the client remains unauthenticated.

Returns True for success, False for failure.

top
SetSslClientCertPem
function CkMailMan_SetSslClientCertPem(objHandle: HCkMailMan;
    pemDataOrFilename: PWideChar;
    pemPassword: PWideChar): wordbool; stdcall;

Allows for a client-side certificate to be used for the SSL / TLS connection.

Returns True for success, False for failure.

top
SetSslClientCertPfx
function CkMailMan_SetSslClientCertPfx(objHandle: HCkMailMan;
    pfxFilename: PWideChar;
    pfxPassword: PWideChar): wordbool; stdcall;

Allows for a client-side certificate to be used for the SSL / TLS connection.

Returns True for success, False for failure.

top
SmtpAuthenticate
function CkMailMan_SmtpAuthenticate(objHandle: HCkMailMan): wordbool; stdcall;
Introduced in version 9.5.0.48

Authenticates with the SMTP server using the property settings such as SmtpUsername, SmtpPassword, etc. This method should only be called after a successful call to SmtpConnect.

Note 1: The OpenSmtpConnection method both connects and authenticates. It is the equivalent of calling SmtpConnect followed by SmtpAuthenticate.

Note 2: All methods that communicate with the SMTP server, such as SendEmail, will automatically connect and authenticate if not already connected and authenticated.

Returns True for success, False for failure.

More Information and Examples
top
SmtpAuthenticateAsync (1)
function CkMailMan_SmtpAuthenticateAsync(objHandle: HCkMailMan): HCkTask; stdcall;
Introduced in version 9.5.0.48

Creates an asynchronous task to call the SmtpAuthenticate method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
SmtpConnect
function CkMailMan_SmtpConnect(objHandle: HCkMailMan): wordbool; stdcall;
Introduced in version 9.5.0.48

Explicitly establishes a connection to the SMTP server, which includes establishing a secure TLS channel if required, and receives the initial greeting. This method stops short of authenticating. The SmtpAuthenticate method should be called after a successful call to this method.

Note 1: The OpenSmtpConnection method both connects and authenticates. It is the equivalent of calling SmtpConnect followed by SmtpAuthenticate.

Note 2: All methods that communicate with the SMTP server, such as SendEmail, will automatically connect and authenticate if not already connected and authenticated.

Important: All TCP-based Internet communications, regardless of the protocol (such as HTTP, FTP, SSH, IMAP, POP3, SMTP, etc.), and regardless of SSL/TLS, begin with establishing a TCP connection to a remote host:port. External security-related infrastructure such as software firewalls (Windows Firewall), hardware firewalls, anti-virus, at either source or destination (or both) can block the connection. If the connection fails, make sure to check all potential external causes of blockage.

Returns True for success, False for failure.

More Information and Examples
top
SmtpConnectAsync (1)
function CkMailMan_SmtpConnectAsync(objHandle: HCkMailMan): HCkTask; stdcall;
Introduced in version 9.5.0.48

Creates an asynchronous task to call the SmtpConnect method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
SmtpNoop
function CkMailMan_SmtpNoop(objHandle: HCkMailMan): wordbool; stdcall;

Sends a no-op to the SMTP server. Calling this method is good for testing to see if the connection to the SMTP server is working and valid. The SmtpNoop method will automatically establish the SMTP connection if it does not already exist.

Returns True for success, False for failure.

top
SmtpNoopAsync (1)
function CkMailMan_SmtpNoopAsync(objHandle: HCkMailMan): HCkTask; stdcall;

Creates an asynchronous task to call the SmtpNoop method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
SmtpReset
function CkMailMan_SmtpReset(objHandle: HCkMailMan): wordbool; stdcall;

Sends an RSET command to the SMTP server. This method is rarely needed. The RSET command resets the state of the connection to the SMTP server to the initial state (so that the component can proceed with sending a new email). The SmtpReset method would only be needed if a mail-sending method failed and left the connection with the SMTP server open and in a non-initial state. (A situation that is probably not even possible with the Chilkat mail component.)

Returns True for success, False for failure.

top
SmtpResetAsync (1)
function CkMailMan_SmtpResetAsync(objHandle: HCkMailMan): HCkTask; stdcall;

Creates an asynchronous task to call the SmtpReset method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
SmtpSendRawCommand
function CkMailMan_SmtpSendRawCommand(objHandle: HCkMailMan;
    command: PWideChar;
    charset: PWideChar;
    bEncodeBase64: wordbool;
    outStr: HCkString): wordbool; stdcall;
function CkMailMan__smtpSendRawCommand(objHandle: HCkMailMan;
    command: PWideChar;
    charset: PWideChar;
    bEncodeBase64: wordbool): PWideChar; stdcall;

Sends a raw command to the SMTP server and returns the SMTP server's response. If non-us-ascii characters are included in command, then charset indicates the charset to be used in sending the command (such as "utf-8", "ansi", "iso-8859-1", "Shift_JIS", etc.)

If bEncodeBase64 is True, then the response is returned in Base64-encoded format. Otherwise the raw response is returned.

Returns True for success, False for failure.

More Information and Examples
top
SmtpSendRawCommandAsync (1)
function CkMailMan_SmtpSendRawCommandAsync(objHandle: HCkMailMan;
    command: PWideChar;
    charset: PWideChar;
    bEncodeBase64: wordbool): HCkTask; stdcall;

Creates an asynchronous task to call the SmtpSendRawCommand method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
SshAuthenticatePk
function CkMailMan_SshAuthenticatePk(objHandle: HCkMailMan;
    sshLogin: PWideChar;
    sshUsername: HCkSshKey): wordbool; stdcall;

Authenticates with the SSH server using public-key authentication. The corresponding public key must have been installed on the SSH server for the sshLogin. Authentication will succeed if the matching sshUsername is provided.

Important: When reporting problems, please send the full contents of the LastErrorText property to support@chilkatsoft.com.

Returns True for success, False for failure.

top
SshAuthenticatePkAsync (1)
function CkMailMan_SshAuthenticatePkAsync(objHandle: HCkMailMan;
    sshLogin: PWideChar;
    sshUsername: HCkSshKey): HCkTask; stdcall;

Creates an asynchronous task to call the SshAuthenticatePk method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
SshAuthenticatePw
function CkMailMan_SshAuthenticatePw(objHandle: HCkMailMan;
    sshLogin: PWideChar;
    sshPassword: PWideChar): wordbool; stdcall;

Authenticates with the SSH server using a sshLogin and sshPassword.

An SSH tunneling (port forwarding) session always begins by first calling SshTunnel to connect to the SSH server, then calling either AuthenticatePw or AuthenticatePk to authenticate.

Note: Once the SSH tunnel is setup by calling SshTunnel and SshAuthenticatePw (or SshAuthenticatePk), all underlying communcations with the POP3 or SMTP server use the SSH tunnel. No changes in programming are required other than making two initial calls to setup the tunnel.

Important: When reporting problems, please send the full contents of the LastErrorText property to support@chilkatsoft.com.

Returns True for success, False for failure.

top
SshAuthenticatePwAsync (1)
function CkMailMan_SshAuthenticatePwAsync(objHandle: HCkMailMan;
    sshLogin: PWideChar;
    sshPassword: PWideChar): HCkTask; stdcall;

Creates an asynchronous task to call the SshAuthenticatePw method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
SshCloseTunnel
function CkMailMan_SshCloseTunnel(objHandle: HCkMailMan): wordbool; stdcall;

Closes the SSH tunnel for SMTP or POP3.

Returns True for success, False for failure.

top
SshCloseTunnelAsync (1)
function CkMailMan_SshCloseTunnelAsync(objHandle: HCkMailMan): HCkTask; stdcall;

Creates an asynchronous task to call the SshCloseTunnel method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
SshOpenTunnel
function CkMailMan_SshOpenTunnel(objHandle: HCkMailMan;
    sshHostname: PWideChar;
    sshPort: Integer): wordbool; stdcall;
Introduced in version 9.5.0.50

Connects to an SSH server and creates a tunnel for SMTP or POP3. The sshHostname is the hostname (or IP address) of the SSH server. The sshPort is typically 22, which is the standard SSH port number.

An SSH tunneling (port forwarding) session always begins by first calling SshTunnel to connect to the SSH server, followed by calling either SshAuthenticatePw or SshAuthenticatePk to authenticate.

Note: Once the SSH tunnel is setup by calling SshOpenTunnel and SshAuthenticatePw (or SshAuthenticatePk), all underlying communcations with the SMTP or POP3 server use the SSH tunnel. No changes in programming are required other than making two initial calls to setup the tunnel.

Important: All TCP-based Internet communications, regardless of the protocol (such as HTTP, FTP, SSH, IMAP, POP3, SMTP, etc.), and regardless of SSL/TLS, begin with establishing a TCP connection to a remote host:port. External security-related infrastructure such as software firewalls (Windows Firewall), hardware firewalls, anti-virus, at either source or destination (or both) can block the connection. If the connection fails, make sure to check all potential external causes of blockage.

Returns True for success, False for failure.

top
SshOpenTunnelAsync (1)
function CkMailMan_SshOpenTunnelAsync(objHandle: HCkMailMan;
    sshHostname: PWideChar;
    sshPort: Integer): HCkTask; stdcall;
Introduced in version 9.5.0.50

Creates an asynchronous task to call the SshOpenTunnel method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
TransferMail
function CkMailMan_TransferMail(objHandle: HCkMailMan): HCkEmailBundle; stdcall;

Downloads and removes all email from a POP3 server. A bundle containing the emails is returned. A null reference is returned on failure.

Returns nil on failure

top
TransferMailAsync (1) (2)
function CkMailMan_TransferMailAsync(objHandle: HCkMailMan): HCkTask; stdcall;

Creates an asynchronous task to call the TransferMail method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
TransferMultipleMime
function CkMailMan_TransferMultipleMime(objHandle: HCkMailMan;
    uidlArray: HCkStringArray): HCkStringArray; stdcall;

Same as FetchMultipleMime except that the downloaded emails are also deleted from the server. Returns a null reference on failure.

Returns nil on failure

top
TransferMultipleMimeAsync (1) (2)
function CkMailMan_TransferMultipleMimeAsync(objHandle: HCkMailMan;
    uidlArray: HCkStringArray): HCkTask; stdcall;

Creates an asynchronous task to call the TransferMultipleMime method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
UseCertVault
function CkMailMan_UseCertVault(objHandle: HCkMailMan;
    vault: HCkXmlCertVault): wordbool; stdcall;
Introduced in version 9.5.0.40

Adds an XML certificate vault to the object's internal list of sources to be searched for certificates and private keys when encrypting/decrypting or signing/verifying. Unlike the AddPfxSourceData and AddPfxSourceFile methods, only a single XML certificate vault can be used. If UseCertVault is called multiple times, only the last certificate vault will be used, as each call to UseCertVault will replace the certificate vault provided in previous calls.

Returns True for success, False for failure.

top
UseSsh
function CkMailMan_UseSsh(objHandle: HCkMailMan;
    ssh: HCkSsh): wordbool; stdcall;
Introduced in version 9.5.0.55

Uses an existing SSH tunnel for the connections to the POP3 andSMTP servers. This method is identical to the UseSshTunnel method, except the SSH connection is obtained from an SSH object instead of a Socket object.

Uses an existing SSH tunnel. This is useful for sharing an existing SSH tunnel connection wth other objects. (SSH is a protocol where the tunnel contains many logical channels. SMTP and POP3 connections can exist simultaneously within a single SSH tunnel as SSH channels.)

Returns True for success, False for failure.

top
UseSshTunnel
function CkMailMan_UseSshTunnel(objHandle: HCkMailMan;
    tunnel: HCkSocket): wordbool; stdcall;
Introduced in version 9.5.0.50

Uses an existing SSH tunnel. This is useful for sharing an existing SSH tunnel connection wth other objects. (SSH is a protocol where the tunnel contains many logical channels. SMTP and POP3 connections can exist simultaneously within a single SSH tunnel as SSH channels.)

Returns True for success, False for failure.

top
VerifyPopConnection
function CkMailMan_VerifyPopConnection(objHandle: HCkMailMan): wordbool; stdcall;

Return True if a TCP/IP connection can be established with the POP3 server, otherwise returns False.

top
VerifyPopConnectionAsync (1)
function CkMailMan_VerifyPopConnectionAsync(objHandle: HCkMailMan): HCkTask; stdcall;

Creates an asynchronous task to call the VerifyPopConnection method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
VerifyPopLogin
function CkMailMan_VerifyPopLogin(objHandle: HCkMailMan): wordbool; stdcall;

Return True if a TCP/IP connection and login is successful with the POP3 server. Otherwise return False.

top
VerifyPopLoginAsync (1)
function CkMailMan_VerifyPopLoginAsync(objHandle: HCkMailMan): HCkTask; stdcall;

Creates an asynchronous task to call the VerifyPopLogin method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
VerifyRecips
function CkMailMan_VerifyRecips(objHandle: HCkMailMan;
    email: HCkEmail;
    badAddrs: HCkStringArray): wordbool; stdcall;

Initiates sending an email, but aborts just after passing all recipients (TO, CC, BCC) to the SMTP server. This allows your program to collect email addresses flagged as invalid by the SMTP server.

Important: Please read this blog post before using this method: http://www.cknotes.com/?p=249

Returns True for success, False for failure.

More Information and Examples
top
VerifyRecipsAsync (1)
function CkMailMan_VerifyRecipsAsync(objHandle: HCkMailMan;
    email: HCkEmail;
    badAddrs: HCkStringArray): HCkTask; stdcall;

Creates an asynchronous task to call the VerifyRecips method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
VerifySmtpConnection
function CkMailMan_VerifySmtpConnection(objHandle: HCkMailMan): wordbool; stdcall;

Return True if a TCP/IP connection can be established with the SMTP server, otherwise returns False.

top
VerifySmtpConnectionAsync (1)
function CkMailMan_VerifySmtpConnectionAsync(objHandle: HCkMailMan): HCkTask; stdcall;

Creates an asynchronous task to call the VerifySmtpConnection method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top
VerifySmtpLogin
function CkMailMan_VerifySmtpLogin(objHandle: HCkMailMan): wordbool; stdcall;

Return True if a TCP/IP connection and login is successful with the SMTP server. Otherwise returns False.

top
VerifySmtpLoginAsync (1)
function CkMailMan_VerifySmtpLoginAsync(objHandle: HCkMailMan): HCkTask; stdcall;

Creates an asynchronous task to call the VerifySmtpLogin method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Returns nil on failure

top

Events

Chilkat supports event callbacks for the Delphi DLL starting in version 9.5.0.82.

AbortCheck
function MyAbortCheck(): Integer; cdecl;
Introduced in version 9.5.0.82

Provides the opportunity for a method call to be aborted. The AbortCheck event is fired periodically based on the value of the HeartbeatMs property. If HeartbeatMs is 0, then no AbortCheck events will fire. As an example, to fire 5 AbortCheck events per second, set the HeartbeatMs property equal to 200. Return True to abort; return False to continue (not abort)

More Information and Examples
top
PercentDone
function MyPercentDone(pctDone: Integer): Integer; cdecl;
Introduced in version 9.5.0.82

Provides the percentage completed for any method that involves network communications or time-consuming processing (assuming it is a method where a percentage completion can be measured). This event is only fired when it is possible to know a percentage completion, and when it makes sense to express the operation as a percentage completed. The pctDone argument will have a value from 1 to 100. For operations (Chilkat method calls) that complete very quickly, the number of PercentDone callbacks will vary, but the final callback should have a value of 100. For long running operations, no more than one callback per percentage point will occur (for example: 1, 2, 3, ... 98, 99, 100).

The PercentDone callback counts as an AbortCheck event. For method calls that complete quickly such that PercentDone events fire, it may be that AbortCheck events don't fire because the opportunity to abort is already provided in the PercentDone callback. For time consuming operations, where the amount of time between PercentDone callbacks are long, AbortCheck callbacks may be used to allow for the operation to be aborted in a more responsive manner.

Return True to abort; return False to continue (not abort)

More Information and Examples
top
ProgressInfo
procedure MyProgressInfo(name: PWideChar; value: PWideChar) cdecl;
Introduced in version 9.5.0.82

A general name/value event that provides information about what is happening during a method call. To find out what information is available, write code to handle this event and log the name/value pairs. Most are self-explanatory.

More Information and Examples
top
TaskCompleted
procedure MyTaskCompleted(task: HCkTask) cdecl;
Introduced in version 9.5.0.82

Called in the background thread when an asynchronous task completes.

top