--- product: Chilkat product_version: 11.7.0 language: wcpp language_label: Unicode C++ class: MailMan class_name: CkMailManW license: bundle deprecated: false reference_html: https://www.chilkatsoft.com/refdoc/wcppCkMailManWRef.html --- # Chilkat MailMan — Unicode C++ — v11.7.0 > Chilkat 11.7.0 · language=wcpp · class=MailMan (CkMailManW) > Other versions: replace `11.7.0` in this URL. Other languages: `https://www.chilkatsoft.com/ai-docs/v/11.7.0//classes/MailMan.md`. > Language-wide rules (install, unlock, error model, strings/bytes): `https://www.chilkatsoft.com/ai-docs/v/11.7.0/wcpp/guide.md`. ## Purpose **Send, receive, secure, and troubleshoot email with SMTP and POP3.** `Chilkat.MailMan` is a full-featured email client class for applications that need SMTP sending and POP3 receiving. It supports secure authentication, MIME rendering, attachments, S/MIME signing and encryption, OAuth2, TLS/STARTTLS, proxy and SSH tunnel routing, POP3 download and delete workflows, delivery status notifications, and detailed diagnostics for troubleshooting mail server communication. **SMTP sending** Send email messages, MIME content, bundles of messages, and signed or encrypted S/MIME mail through SMTP servers. **POP3 receiving** Connect to POP3 mailboxes, list messages, download email, retrieve headers, and control when messages are deleted from the server. **Secure authentication** Use passwords, OAuth2 access tokens, TLS, STARTTLS, client certificates, and secret-backed credentials where appropriate. **MIME and attachments** Render, send, retrieve, and process MIME messages, including HTML bodies, alternative bodies, embedded images, and file attachments. **S/MIME support** Work with certificates and private keys to sign, verify, encrypt, and decrypt email messages. **Diagnostics and routing** Troubleshoot SMTP and POP3 sessions with detailed logs, status codes, server responses, proxy settings, and SSH tunnel support. **Common pattern:** Configure the SMTP or POP3 server settings, choose the security and authentication method, send or retrieve messages, then inspect server status, response text, and `LastErrorText` when troubleshooting provider- specific behavior. For an extended overview, see [MailMan Class Overview](https://www.chilkatsoft.com/mailman_class_overview.asp). ## Object creation, unlocking and error handling **Object Creation** ```cpp // Local variable on the stack CkMailManW obj; // Dynamically allocate/delete CkMailManW *pObj = new CkMailManW(); // ... delete pObj; ``` Call `Global.UnlockBundle` once at the start of the program, before using this or any other Chilkat class. Any string unlocks a fully functional 30-day trial; a purchased unlock code is used in production. See `guide.md` for the exact code in Unicode C++. How failure is reported depends on the method's return type and is stated in the note under each method below. In every case the diagnostic text is in the `LastErrorText` property of the object whose method was called. ## Members common to every Chilkat class Documented once per language in `common-members.md`; listed here so this page is self-contained. | Property | Signature | Access | Meaning | |---|---|---|---| | `DebugLogFilePath` | `void get_DebugLogFilePath(CkString &str); const wchar_t *debugLogFilePath(void); void put_DebugLogFilePath(const wchar_t *str);` | read/write | If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. | | `LastErrorHtml` | `void get_LastErrorHtml(CkString &str); const wchar_t *lastErrorHtml(void);` | read-only | Provides HTML-formatted information about the last called method or property. | | `LastErrorText` | `void get_LastErrorText(CkString &str); const wchar_t *lastErrorText(void);` | read-only | Provides plain text information about the last called method or property. | | `LastErrorXml` | `void get_LastErrorXml(CkString &str); const wchar_t *lastErrorXml(void);` | read-only | Provides XML-formatted information about the last called method or property. | | `LastMethodSuccess` | `bool get_LastMethodSuccess(void); void put_LastMethodSuccess(bool newVal);` | read/write | Indicates the success or failure of the most recent method call: `true` means success, `false` means failure. | | `VerboseLogging` | `bool get_VerboseLogging(void); void put_VerboseLogging(bool newVal);` | read/write | If set to `true`, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. | | `Version` | `void get_Version(CkString &str); const wchar_t *version(void);` | read-only | Version of the component/library, such as "10.1.0" | ## Member index | Member | Kind | Signature | |---|---|---| | `AbortCurrent` | property, read/write | `bool get_AbortCurrent(void); void put_AbortCurrent(bool newVal);` | | `AllOrNone` | property, read/write | `bool get_AllOrNone(void); void put_AllOrNone(bool newVal);` | | `AutoFix` | property, read/write | `bool get_AutoFix(void); void put_AutoFix(bool newVal);` | | `AutoGenMessageId` | property, read/write | `bool get_AutoGenMessageId(void); void put_AutoGenMessageId(bool newVal);` | | `AutoSmtpRset` | property, read/write | `bool get_AutoSmtpRset(void); void put_AutoSmtpRset(bool newVal);` | | `AutoUnwrapSecurity` | property, read/write | `bool get_AutoUnwrapSecurity(void); void put_AutoUnwrapSecurity(bool newVal);` | | `ClientIpAddress` | property, read/write | `void get_ClientIpAddress(CkString &str); const wchar_t *clientIpAddress(void); void put_ClientIpAddress(const wchar_t *str);` | | `ConnectFailReason` | property, read-only | `int get_ConnectFailReason(void);` | | `ConnectTimeout` | property, read/write | `int get_ConnectTimeout(void); void put_ConnectTimeout(int newVal);` | | `DsnEnvid` | property, read/write | `void get_DsnEnvid(CkString &str); const wchar_t *dsnEnvid(void); void put_DsnEnvid(const wchar_t *str);` | | `DsnNotify` | property, read/write | `void get_DsnNotify(CkString &str); const wchar_t *dsnNotify(void); void put_DsnNotify(const wchar_t *str);` | | `DsnRet` | property, read/write | `void get_DsnRet(CkString &str); const wchar_t *dsnRet(void); void put_DsnRet(const wchar_t *str);` | | `EmbedCertChain` | property, read/write | `bool get_EmbedCertChain(void); void put_EmbedCertChain(bool newVal);` | | `EnableSecrets` | property, read/write | `bool get_EnableSecrets(void); void put_EnableSecrets(bool newVal);` | | `Filter` | property, read/write | `void get_Filter(CkString &str); const wchar_t *filter(void); void put_Filter(const wchar_t *str);` | | `HeartbeatMs` | property, read/write | `int get_HeartbeatMs(void); void put_HeartbeatMs(int newVal);` | | `HeloHostname` | property, read/write | `void get_HeloHostname(CkString &str); const wchar_t *heloHostname(void); void put_HeloHostname(const wchar_t *str);` | | `HttpProxyAuthMethod` | property, read/write | `void get_HttpProxyAuthMethod(CkString &str); const wchar_t *httpProxyAuthMethod(void); void put_HttpProxyAuthMethod(const wchar_t *str);` | | `HttpProxyDomain` | property, read/write | `void get_HttpProxyDomain(CkString &str); const wchar_t *httpProxyDomain(void); void put_HttpProxyDomain(const wchar_t *str);` | | `HttpProxyHostname` | property, read/write | `void get_HttpProxyHostname(CkString &str); const wchar_t *httpProxyHostname(void); void put_HttpProxyHostname(const wchar_t *str);` | | `HttpProxyPassword` | property, read/write | `void get_HttpProxyPassword(CkString &str); const wchar_t *httpProxyPassword(void); void put_HttpProxyPassword(const wchar_t *str);` | | `HttpProxyPort` | property, read/write | `int get_HttpProxyPort(void); void put_HttpProxyPort(int newVal);` | | `HttpProxyUsername` | property, read/write | `void get_HttpProxyUsername(CkString &str); const wchar_t *httpProxyUsername(void); void put_HttpProxyUsername(const wchar_t *str);` | | `ImmediateDelete` | property, read/write | `bool get_ImmediateDelete(void); void put_ImmediateDelete(bool newVal);` | | `IncludeRootCert` | property, read/write | `bool get_IncludeRootCert(void); void put_IncludeRootCert(bool newVal);` | | `IsPop3Connected` | property, read-only | `bool get_IsPop3Connected(void);` | | `IsSmtpConnected` | property, read-only | `bool get_IsSmtpConnected(void);` | | `LastSmtpStatus` | property, read-only | `int get_LastSmtpStatus(void);` | | `LastSmtpStatusMsg` | property, read-only | `void get_LastSmtpStatusMsg(CkString &str); const wchar_t *lastSmtpStatusMsg(void);` | | `LogMailReceivedFilename` | property, read/write | `void get_LogMailReceivedFilename(CkString &str); const wchar_t *logMailReceivedFilename(void); void put_LogMailReceivedFilename(const wchar_t *str);` | | `LogMailSentFilename` | property, read/write | `void get_LogMailSentFilename(CkString &str); const wchar_t *logMailSentFilename(void); void put_LogMailSentFilename(const wchar_t *str);` | | `MailHost` | property, read/write | `void get_MailHost(CkString &str); const wchar_t *mailHost(void); void put_MailHost(const wchar_t *str);` | | `MailPort` | property, read/write | `int get_MailPort(void); void put_MailPort(int newVal);` | | `MaxCount` | property, read/write | `int get_MaxCount(void); void put_MaxCount(int newVal);` | | `OAuth2AccessToken` | property, read/write | `void get_OAuth2AccessToken(CkString &str); const wchar_t *oAuth2AccessToken(void); void put_OAuth2AccessToken(const wchar_t *str);` | | `OpaqueSigning` | property, read/write | `bool get_OpaqueSigning(void); void put_OpaqueSigning(bool newVal);` | | `P7mEncryptAttachFilename` | property, read/write | `void get_P7mEncryptAttachFilename(CkString &str); const wchar_t *p7mEncryptAttachFilename(void); void put_P7mEncryptAttachFilename(const wchar_t *str);` | | `P7mSigAttachFilename` | property, read/write | `void get_P7mSigAttachFilename(CkString &str); const wchar_t *p7mSigAttachFilename(void); void put_P7mSigAttachFilename(const wchar_t *str);` | | `P7sSigAttachFilename` | property, read/write | `void get_P7sSigAttachFilename(CkString &str); const wchar_t *p7sSigAttachFilename(void); void put_P7sSigAttachFilename(const wchar_t *str);` | | `PercentDoneScale` | property, read/write | `int get_PercentDoneScale(void); void put_PercentDoneScale(int newVal);` | | `Pop3SessionId` | property, read-only | `int get_Pop3SessionId(void);` | | `Pop3SessionLog` | property, read-only | `void get_Pop3SessionLog(CkString &str); const wchar_t *pop3SessionLog(void);` | | `Pop3SPA` | property, read/write | `bool get_Pop3SPA(void); void put_Pop3SPA(bool newVal);` | | `Pop3SslServerCertVerified` | property, read-only | `bool get_Pop3SslServerCertVerified(void);` | | `Pop3Stls` | property, read/write | `bool get_Pop3Stls(void); void put_Pop3Stls(bool newVal);` | | `Pop3StlsIfPossible` | property, read/write | `bool get_Pop3StlsIfPossible(void); void put_Pop3StlsIfPossible(bool newVal);` | | `PopPassword` | property, read/write | `void get_PopPassword(CkString &str); const wchar_t *popPassword(void); void put_PopPassword(const wchar_t *str);` | | `PopPasswordBase64` | property, read/write | `void get_PopPasswordBase64(CkString &str); const wchar_t *popPasswordBase64(void); void put_PopPasswordBase64(const wchar_t *str);` | | `PopSsl` | property, read/write | `bool get_PopSsl(void); void put_PopSsl(bool newVal);` | | `PopUsername` | property, read/write | `void get_PopUsername(CkString &str); const wchar_t *popUsername(void); void put_PopUsername(const wchar_t *str);` | | `PreferIpv6` | property, read/write | `bool get_PreferIpv6(void); void put_PreferIpv6(bool newVal);` | | `ReadTimeout` | property, read/write | `int get_ReadTimeout(void); void put_ReadTimeout(int newVal);` | | `RequireHostnameMatch` | property, read/write | `bool get_RequireHostnameMatch(void); void put_RequireHostnameMatch(bool newVal);` | | `RequireSslCertVerify` | property, read/write | `bool get_RequireSslCertVerify(void); void put_RequireSslCertVerify(bool newVal);` | | `ResetDateOnLoad` | property, read/write | `bool get_ResetDateOnLoad(void); void put_ResetDateOnLoad(bool newVal);` | | `SendBufferSize` | property, read/write | `int get_SendBufferSize(void); void put_SendBufferSize(int newVal);` | | `SizeLimit` | property, read/write | `int get_SizeLimit(void); void put_SizeLimit(int newVal);` | | `SmtpAuthMethod` | property, read/write | `void get_SmtpAuthMethod(CkString &str); const wchar_t *smtpAuthMethod(void); void put_SmtpAuthMethod(const wchar_t *str);` | | `SmtpFailReason` | property, read-only | `void get_SmtpFailReason(CkString &str); const wchar_t *smtpFailReason(void);` | | `SmtpHost` | property, read/write | `void get_SmtpHost(CkString &str); const wchar_t *smtpHost(void); void put_SmtpHost(const wchar_t *str);` | | `SmtpLoginDomain` | property, read/write | `void get_SmtpLoginDomain(CkString &str); const wchar_t *smtpLoginDomain(void); void put_SmtpLoginDomain(const wchar_t *str);` | | `SmtpMailFrom` | property, read/write | `void get_SmtpMailFrom(CkString &str); const wchar_t *smtpMailFrom(void); void put_SmtpMailFrom(const wchar_t *str);` | | `SmtpPassword` | property, read/write | `void get_SmtpPassword(CkString &str); const wchar_t *smtpPassword(void); void put_SmtpPassword(const wchar_t *str);` | | `SmtpPipelining` | property, read/write | `bool get_SmtpPipelining(void); void put_SmtpPipelining(bool newVal);` | | `SmtpPort` | property, read/write | `int get_SmtpPort(void); void put_SmtpPort(int newVal);` | | `SmtpSessionLog` | property, read-only | `void get_SmtpSessionLog(CkString &str); const wchar_t *smtpSessionLog(void);` | | `SmtpSsl` | property, read/write | `bool get_SmtpSsl(void); void put_SmtpSsl(bool newVal);` | | `SmtpSslServerCertVerified` | property, read-only | `bool get_SmtpSslServerCertVerified(void);` | | `SmtpUsername` | property, read/write | `void get_SmtpUsername(CkString &str); const wchar_t *smtpUsername(void); void put_SmtpUsername(const wchar_t *str);` | | `SniHostname` | property, read/write | `void get_SniHostname(CkString &str); const wchar_t *sniHostname(void); void put_SniHostname(const wchar_t *str);` | | `SocksHostname` | property, read/write | `void get_SocksHostname(CkString &str); const wchar_t *socksHostname(void); void put_SocksHostname(const wchar_t *str);` | | `SocksPassword` | property, read/write | `void get_SocksPassword(CkString &str); const wchar_t *socksPassword(void); void put_SocksPassword(const wchar_t *str);` | | `SocksPort` | property, read/write | `int get_SocksPort(void); void put_SocksPort(int newVal);` | | `SocksUsername` | property, read/write | `void get_SocksUsername(CkString &str); const wchar_t *socksUsername(void); void put_SocksUsername(const wchar_t *str);` | | `SocksVersion` | property, read/write | `int get_SocksVersion(void); void put_SocksVersion(int newVal);` | | `SoRcvBuf` | property, read/write | `int get_SoRcvBuf(void); void put_SoRcvBuf(int newVal);` | | `SoSndBuf` | property, read/write | `int get_SoSndBuf(void); void put_SoSndBuf(int newVal);` | | `SslAllowedCiphers` | property, read/write | `void get_SslAllowedCiphers(CkString &str); const wchar_t *sslAllowedCiphers(void); void put_SslAllowedCiphers(const wchar_t *str);` | | `SslProtocol` | property, read/write | `void get_SslProtocol(CkString &str); const wchar_t *sslProtocol(void); void put_SslProtocol(const wchar_t *str);` | | `StartTLS` | property, read/write | `bool get_StartTLS(void); void put_StartTLS(bool newVal);` | | `StartTLSifPossible` | property, read/write | `bool get_StartTLSifPossible(void); void put_StartTLSifPossible(bool newVal);` | | `TlsCipherSuite` | property, read-only | `void get_TlsCipherSuite(CkString &str); const wchar_t *tlsCipherSuite(void);` | | `TlsPinSet` | property, read/write | `void get_TlsPinSet(CkString &str); const wchar_t *tlsPinSet(void); void put_TlsPinSet(const wchar_t *str);` | | `TlsVersion` | property, read-only | `void get_TlsVersion(CkString &str); const wchar_t *tlsVersion(void);` | | `UncommonOptions` | property, read/write | `void get_UncommonOptions(CkString &str); const wchar_t *uncommonOptions(void); void put_UncommonOptions(const wchar_t *str);` | | `UseApop` | property, read/write | `bool get_UseApop(void); void put_UseApop(bool newVal);` | | `AddPfxSourceBd` | method | `bool AddPfxSourceBd(CkBinDataW &bd, const wchar_t *password);` | | `AddPfxSourceFile` | method | `bool AddPfxSourceFile(const wchar_t *pfxFilePath, const wchar_t *password);` | | `CheckMail` | method | `int CheckMail(void);` | | `ClearPop3SessionLog` | method | `void ClearPop3SessionLog(void);` | | `ClearSmtpSessionLog` | method | `void ClearSmtpSessionLog(void);` | | `CloseSmtpConnection` | method | `bool CloseSmtpConnection(void);` | | `DeleteBundle` | method | `bool DeleteBundle(CkEmailBundleW &emailBundle);` | | `DeleteByMsgnum` | method | `bool DeleteByMsgnum(int msgnum);` | | `DeleteByUidl` | method | `bool DeleteByUidl(const wchar_t *uidl);` | | `DeleteEmail` | method | `bool DeleteEmail(CkEmailW &email);` | | `DeleteUidlSet` | method | `bool DeleteUidlSet(CkStringTableW &stUidls);` | | `FetchAll` | method | `bool FetchAll(bool keepOnServer, bool headersOnly, int numBodyLines, CkEmailBundleW &bundle);` | | `FetchByUidl` | method | `bool FetchByUidl(const wchar_t *uidl, bool headerOnly, int numBodyLines, CkEmailW &email);` | | `FetchFull` | method | `bool FetchFull(CkEmailW &partialEmail, CkEmailW &fullEmail);` | | `FetchMimeBd` | method | `bool FetchMimeBd(const wchar_t *uidl, CkBinDataW &mimeData);` | | `FetchMimeByMsgnumBd` | method | `bool FetchMimeByMsgnumBd(int msgnum, CkBinDataW &bd);` | | `FetchOne` | method | `bool FetchOne(bool headerOnly, int numBodyLines, int msgNum, CkEmailW &email);` | | `FetchRange` | method | `bool FetchRange(bool keepOnServer, bool headersOnly, int numBodyLines, int startIndex, int endIndex, CkEmailBundleW &bundle);` | | `FetchUidls` | method | `bool FetchUidls(CkStringTableW &uidls);` | | `FetchUidlSet` | method | `bool FetchUidlSet(CkStringTableW &uidls, bool headersOnly, int numBodyLines, CkEmailBundleW &bundle);` | | `GetLastJsonData` | method | `void GetLastJsonData(CkJsonObjectW &json);` | | `GetMailboxCount` | method | `int GetMailboxCount(void);` | | `GetMailboxInfoXml` | method | `bool GetMailboxInfoXml(CkString &outXml); const wchar_t *getMailboxInfoXml(void);` | | `GetMailboxSize` | method | `unsigned long GetMailboxSize(void);` | | `GetServerCert` | method | `bool GetServerCert(bool useSmtp, CkCertW &cert);` | | `GetSizeByUidl` | method | `int GetSizeByUidl(const wchar_t *uidl);` | | `IsSmtpDsnCapable` | method | `bool IsSmtpDsnCapable(void);` | | `LoadMbxFile` | method | `bool LoadMbxFile(const wchar_t *mbxPath, CkEmailBundleW &bundle);` | | `LoadTaskCaller` | method | `bool LoadTaskCaller(CkTaskW &task);` | | `OpenSmtpConnection` | method | `bool OpenSmtpConnection(void);` | | `Pop3Authenticate` | method | `bool Pop3Authenticate(void);` | | `Pop3BeginSession` | method | `bool Pop3BeginSession(void);` | | `Pop3Connect` | method | `bool Pop3Connect(void);` | | `Pop3EndSession` | method | `bool Pop3EndSession(void);` | | `Pop3EndSessionNoQuit` | method | `bool Pop3EndSessionNoQuit(void);` | | `Pop3Noop` | method | `bool Pop3Noop(void);` | | `Pop3Reset` | method | `bool Pop3Reset(void);` | | `Pop3SendRawCommand` | method | `bool Pop3SendRawCommand(const wchar_t *command, const wchar_t *charset, CkString &outStr); const wchar_t *pop3SendRawCommand(const wchar_t *command, const wchar_t *charset);` | | `QuickSend` | method | `bool QuickSend(const wchar_t *fromAddr, const wchar_t *toAddr, const wchar_t *subject, const wchar_t *body, const wchar_t *smtpServer);` | | `RenderToMime` | method | `bool RenderToMime(CkEmailW &email, CkString &outStr); const wchar_t *renderToMime(CkEmailW &email);` | | `RenderToMimeBd` | method | `bool RenderToMimeBd(CkEmailW &email, CkBinDataW &renderedMime);` | | `RenderToMimeSb` | method | `bool RenderToMimeSb(CkEmailW &email, CkStringBuilderW &renderedMime);` | | `SendBundle` | method | `bool SendBundle(CkEmailBundleW &bundle);` | | `SendEmail` | method | `bool SendEmail(CkEmailW &email);` | | `SendMime` | method | `bool SendMime(const wchar_t *fromAddr, const wchar_t *recipients, const wchar_t *mimeSource);` | | `SendMimeBd` | method | `bool SendMimeBd(const wchar_t *fromAddr, const wchar_t *recipients, CkBinDataW &mimeData);` | | `SetDecryptCert` | method | `bool SetDecryptCert(CkCertW &cert);` | | `SetDecryptCert2` | method | `bool SetDecryptCert2(CkCertW &cert, CkPrivateKeyW &privateKey);` | | `SetPassword` | method | `bool SetPassword(const wchar_t *protocolName, CkSecureStringW &password);` | | `SetSslClientCert` | method | `bool SetSslClientCert(CkCertW &cert);` | | `SetSslClientCertPem` | method | `bool SetSslClientCertPem(const wchar_t *pemDataOrFilename, const wchar_t *pemPassword);` | | `SetSslClientCertPfx` | method | `bool SetSslClientCertPfx(const wchar_t *pfxPath, const wchar_t *pfxPassword);` | | `SmtpAuthenticate` | method | `bool SmtpAuthenticate(void);` | | `SmtpConnect` | method | `bool SmtpConnect(void);` | | `SmtpNoop` | method | `bool SmtpNoop(void);` | | `SmtpReset` | method | `bool SmtpReset(void);` | | `SmtpSendRawCommand` | method | `bool SmtpSendRawCommand(const wchar_t *command, const wchar_t *charset, bool bEncodeBase64, CkString &outStr); const wchar_t *smtpSendRawCommand(const wchar_t *command, const wchar_t *charset, bool bEncodeBase64);` | | `SshAuthenticatePk` | method | `bool SshAuthenticatePk(const wchar_t *sshLogin, CkSshKeyW &privKey);` | | `SshAuthenticatePw` | method | `bool SshAuthenticatePw(const wchar_t *sshLogin, const wchar_t *sshPassword);` | | `SshCloseTunnel` | method | `bool SshCloseTunnel(void);` | | `SshOpenTunnel` | method | `bool SshOpenTunnel(const wchar_t *sshHostname, int sshPort);` | | `UseCertVault` | method | `bool UseCertVault(CkXmlCertVaultW &vault);` | | `UseSsh` | method | `bool UseSsh(CkSshW &ssh);` | | `UseSshTunnel` | method | `bool UseSshTunnel(CkSocketW &tunnel);` | | `VerifyPopConnection` | method | `bool VerifyPopConnection(void);` | | `VerifyPopLogin` | method | `bool VerifyPopLogin(void);` | | `VerifyRecips` | method | `bool VerifyRecips(CkEmailW &email, CkStringArrayW &badAddrs);` | | `VerifySmtpConnection` | method | `bool VerifySmtpConnection(void);` | | `VerifySmtpLogin` | method | `bool VerifySmtpLogin(void);` | Deprecated members are listed at the end of this file with their replacements; do not use them in new code. ## Properties ### MailMan.AbortCurrent `Chilkat 11.7.0 · wcpp · MailMan · AbortCurrent · property · read/write · since 9.5.0.58` ```cpp bool get_AbortCurrent(void); void put_AbortCurrent(bool newVal); ``` Set this property to `true` to request that the currently running operation be aborted. This applies to methods that may take time to complete, such as methods that perform network communication or lengthy file operations. Methods that always complete quickly are generally not affected. If no method is currently running, the property is automatically reset to `false` when the next method call begins. When an abort actually occurs, Chilkat resets this property to `false`. Both synchronous and asynchronous method calls can be aborted. A synchronous method can be aborted by setting this property from another thread. ### MailMan.AllOrNone `Chilkat 11.7.0 · wcpp · MailMan · AllOrNone · property · read/write` ```cpp bool get_AllOrNone(void); void put_AllOrNone(bool newVal); ``` Determines whether an email should be sent when one or more recipients are rejected by the SMTP server. The default value is `false`, which means Chilkat continues sending even if some recipients are rejected. When set to `true`, the email is not sent to any recipients if the SMTP server rejects any recipient address. **Important:** This property only works when SMTP pipelining is disabled. Because `SmtpPipelining` is `true` by default, set `SmtpPipelining = false` when all-or-none behavior is required. **Note:** SMTP servers do not always verify recipient addresses. Even when they do, the server can usually verify only addresses within domains it controls. See also: - [AutoFix Explained in More Detail](https://cknotes.com/autofix-pop3-and-smtp-port-tls-settings/) ### MailMan.AutoFix `Chilkat 11.7.0 · wcpp · MailMan · AutoFix · property · read/write` ```cpp bool get_AutoFix(void); void put_AutoFix(bool newVal); ``` Controls whether Chilkat automatically selects the SMTP and POP3 TLS mode from a standard port number when a connection is prepared. - SMTP port `465`: implicit TLS (`SmtpSsl = true`). - SMTP port `587`: explicit TLS using `STARTTLS`. - SMTP port `25`: no TLS is implied. - POP3 port `995`: implicit TLS (`PopSsl = true`). - POP3 port `110`: no TLS is implied. The default value is `true`. For these standard ports, Chilkat sets the related TLS properties to a consistent combination before connecting, so conflicting implicit and explicit TLS settings do not remain in effect. If the configured port is nonstandard, AutoFix does not change the TLS properties. The application must set the desired implicit, required-explicit, opportunistic-explicit, or unencrypted mode explicitly. **Important:** AutoFix is applied when Chilkat prepares the connection. Assigning a port number does not immediately rewrite the visible property values. See also: - [AutoFix Explained in More Detail](https://cknotes.com/autofix-pop3-and-smtp-port-tls-settings/) ### MailMan.AutoGenMessageId `Chilkat 11.7.0 · wcpp · MailMan · AutoGenMessageId · property · read/write` ```cpp bool get_AutoGenMessageId(void); void put_AutoGenMessageId(bool newVal); ``` Determines whether Chilkat automatically generates a unique `Message-ID` header when an email is sent. The default behavior is to generate a new unique `Message-ID` at send time. This allows the same `Email` object to be reused without accidentally sending duplicate message IDs. If duplicate message IDs are used, some SMTP servers may treat the message as a duplicate and discard it. When automatic generation is enabled, calling `GetHeaderField("Message-ID")` before sending will not necessarily show the actual message ID that Chilkat sends. Set this property to `false` to prevent Chilkat from automatically generating the `Message-ID` header. ### MailMan.AutoSmtpRset `Chilkat 11.7.0 · wcpp · MailMan · AutoSmtpRset · property · read/write` ```cpp bool get_AutoSmtpRset(void); void put_AutoSmtpRset(bool newVal); ``` When `true`, Chilkat automatically sends the SMTP `RSET` command before sending a new email over an already-open SMTP connection. This helps ensure the SMTP session is in a clean state before the next email is sent. The default value is `false`. **Note:** This property only applies when reusing an existing SMTP connection. ### MailMan.AutoUnwrapSecurity `Chilkat 11.7.0 · wcpp · MailMan · AutoUnwrapSecurity · property · read/write · since 9.5.0.49` ```cpp bool get_AutoUnwrapSecurity(void); void put_AutoUnwrapSecurity(bool newVal); ``` Determines whether Chilkat automatically unwraps digitally signed or encrypted email when the message is downloaded or loaded from MIME. The default value is `true`. When enabled, Chilkat verifies signatures and decrypts encrypted content when possible. The results are made available through the email object's security-related properties and methods. Set this property to `false` if you want signed or encrypted attachments, such as `.p7m` or `.p7s` files, to remain as ordinary attachments. **Important:** Signature verification and decryption must occur when the original MIME is first loaded. After MIME is parsed into Chilkat's internal email object format, the exact original MIME bytes are no longer available, and the signature can no longer be verified. ### MailMan.ClientIpAddress `Chilkat 11.7.0 · wcpp · MailMan · ClientIpAddress · property · read/write` ```cpp void get_ClientIpAddress(CkString &str); const wchar_t *clientIpAddress(void); void put_ClientIpAddress(const wchar_t *str); ``` Sets the local IP address to use when connecting from a computer that has multiple network interfaces or multiple IP addresses. For most computers, this property should be left unset. Chilkat will automatically use the default local IP address. The value should be a numeric IP address, such as `165.164.55.124`, not a hostname. See also: - [Important Bind to Adapter Notes for Windows](http://www.cknotes.com/?p=376) ### MailMan.ConnectFailReason `Chilkat 11.7.0 · wcpp · MailMan · ConnectFailReason · property · read-only · since 9.5.0.56` ```cpp int get_ConnectFailReason(void); ``` Contains a numeric code describing the result of the last connection attempt. This applies to the last connection made, or attempted, by any method. | Code | Meaning | | --- | --- | | `0` | Success. | | `1` | Empty hostname. | | `2` | DNS lookup failed. | | `3` | DNS timeout. | | `4` | Aborted by the application. | | `5` | Internal failure. | | `6` | Connection timed out. | | `7` | Connection rejected, or failed for another reason. | | `100` | TLS internal error. | | `101` | Failed to send the TLS client hello. | | `102` | Unexpected TLS handshake message. | | `103` | Failed to read the TLS server hello. | | `104` | No server certificate was received. | | `105` | Unexpected TLS protocol version. | | `106` | Server certificate verification failed. | | `107` | Unacceptable TLS protocol version. | | `109` | Failed to read TLS handshake messages. | | `110` | Failed to send client certificate handshake message. | | `111` | Failed to send client key exchange handshake message. | | `112` | Client certificate private key is not accessible. | | `113` | Failed to send client certificate verify handshake message. | | `114` | Failed to send change cipher spec handshake message. | | `115` | Failed to send finished handshake message. | | `116` | The server's finished message is invalid. | ### MailMan.ConnectTimeout `Chilkat 11.7.0 · wcpp · MailMan · ConnectTimeout · property · read/write` ```cpp int get_ConnectTimeout(void); void put_ConnectTimeout(int newVal); ``` The maximum number of seconds to wait while attempting to connect to an SMTP or POP3 server. The default value is `30` seconds. ### MailMan.DsnEnvid `Chilkat 11.7.0 · wcpp · MailMan · DsnEnvid · property · read/write` ```cpp void get_DsnEnvid(CkString &str); const wchar_t *dsnEnvid(void); void put_DsnEnvid(const wchar_t *str); ``` The `DsnEnvid` property specifies the SMTP DSN `ENVID` value, which is an arbitrary identifier attached to the SMTP envelope. The same value is typically returned in DSN responses so the sending application can correlate delivery notifications with the original outbound email. Common choices for `DsnEnvid` include: - An internal message ID: > `MSG-10004521` - A GUID or UUID: > `550e8400-e29b-41d4-a716-446655440000` - An order or transaction number: > `ORDER-847291` - A timestamp-based identifier: > `MAIL-20260515-153045-001` - A composite identifier combining application, customer, and message IDs: > `billing|cust-9182|invoice-44381` The value should uniquely identify the outbound email within your application. It does not need to match the MIME `Message-ID` header, although some applications choose to use the same identifier for both. --- **About `SMTP DSN`** SMTP **DSN** means **Delivery Status Notification**. It is an optional SMTP service extension defined by RFC 3461 that allows the sender to request delivery-status reports from the SMTP server. DSN allows an application to request notifications such as: - Successful delivery - Delivery failure - Delayed delivery It also allows the sender to specify whether the returned notification should include the full original message or only the message headers. In `MailMan`, DSN behavior is controlled using: - `DsnEnvid` — sets the SMTP `ENVID` envelope identifier. - `DsnNotify` — controls when notifications are requested, such as `SUCCESS`, `FAILURE`, `DELAY`, or `NEVER`. - `DsnRet` — controls whether DSN responses include the full message or only headers. DSN is an optional SMTP extension and is not supported by all SMTP servers. A server supports DSN only if it advertises the `DSN` capability in response to the SMTP `EHLO` command. The `IsSmtpDsnCapable` method can be used to determine whether the SMTP server supports DSN. Even when DSN is supported, some SMTP servers or downstream mail systems may ignore or partially honor DSN requests. ### MailMan.DsnNotify `Chilkat 11.7.0 · wcpp · MailMan · DsnNotify · property · read/write` ```cpp void get_DsnNotify(CkString &str); const wchar_t *dsnNotify(void); void put_DsnNotify(const wchar_t *str); ``` Sets the SMTP DSN `NOTIFY` parameter used when sending email. The value may be left empty, set to `NEVER`, or set to a comma-separated combination of `SUCCESS`, `FAILURE`, and `DELAY`. ### MailMan.DsnRet `Chilkat 11.7.0 · wcpp · MailMan · DsnRet · property · read/write` ```cpp void get_DsnRet(CkString &str); const wchar_t *dsnRet(void); void put_DsnRet(const wchar_t *str); ``` Sets the SMTP DSN `RET` parameter used when sending email. The value may be left empty, set to `FULL` to request the full message in DSN notifications, or set to `HDRS` to request only the message headers. ### MailMan.EmbedCertChain `Chilkat 11.7.0 · wcpp · MailMan · EmbedCertChain · property · read/write` ```cpp bool get_EmbedCertChain(void); void put_EmbedCertChain(bool newVal); ``` When `true`, Chilkat embeds the signing certificate chain in signed email. Certificates are included up to, but not including, the root certificate. If `IncludeRootCert` is also `true`, the root CA certificate is included as well. The default value is `false` ### MailMan.EnableSecrets `Chilkat 11.7.0 · wcpp · MailMan · EnableSecrets · property · read/write · since 11.5.0` ```cpp bool get_EnableSecrets(void); void put_EnableSecrets(bool newVal); ``` **Full documentation for this property (same in every language):** [More Detailed Information About EnableSecrets](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/secret_specification_strings.md) Enables automatic resolution of passwords and credentials from secure local storage. When set to `true`, supported properties and methods can accept a Chilkat secret specification string instead of a literal password. Secret specification strings begin with `!!`. Chilkat resolves secrets from: - Windows Credential Manager on Windows. - Apple Keychain on macOS. The secret specification format is: `!![appName|]service[|domain]|username` This applies to `PopPassword`, `SmtpPassword`, `HttpProxyPassword`, `SocksPassword`, `PopPasswordBase64`, and `SshAuthenticatePw`. The default value is `false`. ### MailMan.Filter `Chilkat 11.7.0 · wcpp · MailMan · Filter · property · read/write` ```cpp void get_Filter(CkString &str); const wchar_t *filter(void); void put_Filter(const wchar_t *str); ``` Specifies a filter expression applied by methods such as `LoadXmlFile`, `LoadXmlString`, `LoadMbx`, `CopyMail`, and `TransferMail`. When a filter is present, only emails matching the expression are returned. For `TransferMail`, only matching emails are removed from the mail server. Example expressions: > `Body like "mortgage rates*"` > `Subject contains "update" and From contains "chilkat"` > `To = "info@chilkatsoft.com"` Rules for filter expressions: - Any MIME header field name may be used. Header names are case-insensitive. - Literal strings are enclosed in double quotes. - String matching is case-insensitive. - The `*` wildcard matches zero or more characters. - Parentheses may be used to control precedence. - Logical operators are `AND`, `OR`, and `NOT`. - String comparison operators include `CONTAINS` and `LIKE`. **Note:** Filtering works on text strings only, not dates or numbers. See also: - [More information about the Filter property (for POP3)](https://www.chilkatsoft.com/p/p_455.asp) ### MailMan.HeartbeatMs `Chilkat 11.7.0 · wcpp · MailMan · HeartbeatMs · property · read/write` ```cpp int get_HeartbeatMs(void); void put_HeartbeatMs(int newVal); ``` **Full documentation for this property (same in every language):** [Event Callback Examples](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/event_callback_examples.md) Sets the interval, in milliseconds, between `AbortCheck` event callbacks. This allows an application to periodically decide whether a long-running operation should be aborted. The default value is `0`, which means no `AbortCheck` callbacks are generated. ### MailMan.HeloHostname `Chilkat 11.7.0 · wcpp · MailMan · HeloHostname · property · read/write` ```cpp void get_HeloHostname(CkString &str); const wchar_t *heloHostname(void); void put_HeloHostname(const wchar_t *str); ``` Sets the hostname sent in the SMTP `EHLO` or `HELO` command. The default value is an empty string, which causes Chilkat to use the local computer's hostname. ### MailMan.HttpProxyAuthMethod `Chilkat 11.7.0 · wcpp · MailMan · HttpProxyAuthMethod · property · read/write` ```cpp void get_HttpProxyAuthMethod(CkString &str); const wchar_t *httpProxyAuthMethod(void); void put_HttpProxyAuthMethod(const wchar_t *str); ``` Sets the authentication method used when the configured HTTP proxy requires credentials. Valid values are `Basic` and `NTLM`. Leave this property empty when the proxy does not require authentication. ### MailMan.HttpProxyDomain `Chilkat 11.7.0 · wcpp · MailMan · HttpProxyDomain · property · read/write` ```cpp void get_HttpProxyDomain(CkString &str); const wchar_t *httpProxyDomain(void); void put_HttpProxyDomain(const wchar_t *str); ``` Sets the optional Windows domain used for NTLM authentication with an HTTP proxy. This property is ignored for Basic proxy authentication and may be left empty when no NTLM domain is required. ### MailMan.HttpProxyHostname `Chilkat 11.7.0 · wcpp · MailMan · HttpProxyHostname · property · read/write` ```cpp void get_HttpProxyHostname(CkString &str); const wchar_t *httpProxyHostname(void); void put_HttpProxyHostname(const wchar_t *str); ``` Sets the hostname or IP address of the HTTP proxy used for SMTP and POP3 connections. Leave this property empty to connect directly without an HTTP proxy. ### MailMan.HttpProxyPassword `Chilkat 11.7.0 · wcpp · MailMan · HttpProxyPassword · property · read/write` ```cpp void get_HttpProxyPassword(CkString &str); const wchar_t *httpProxyPassword(void); void put_HttpProxyPassword(const wchar_t *str); ``` Sets the password used to authenticate with the configured HTTP proxy. This property is used together with `HttpProxyUsername` and, for NTLM authentication, may also be used with `HttpProxyDomain`. ### MailMan.HttpProxyPort `Chilkat 11.7.0 · wcpp · MailMan · HttpProxyPort · property · read/write` ```cpp int get_HttpProxyPort(void); void put_HttpProxyPort(int newVal); ``` Sets the TCP port of the HTTP proxy. Common proxy ports include `8080` and `3128`. The value is used only when `HttpProxyHostname` is set. ### MailMan.HttpProxyUsername `Chilkat 11.7.0 · wcpp · MailMan · HttpProxyUsername · property · read/write` ```cpp void get_HttpProxyUsername(CkString &str); const wchar_t *httpProxyUsername(void); void put_HttpProxyUsername(const wchar_t *str); ``` Sets the username used to authenticate with the configured HTTP proxy. This property is used only when the proxy requires authentication. ### MailMan.ImmediateDelete `Chilkat 11.7.0 · wcpp · MailMan · ImmediateDelete · property · read/write` ```cpp bool get_ImmediateDelete(void); void put_ImmediateDelete(bool newVal); ``` Determines whether pending POP3 deletion marks are committed automatically after a successful delete operation or full-message retrieval performed with `keepOnServer = false`. The default value is `true`. Chilkat sends `DELE` as each message is processed. After the complete operation succeeds, Chilkat sends `QUIT`, commits the deletions, and closes the POP3 session. The next POP3 method automatically reconnects and establishes a new session. When set to `false`, Chilkat sends `DELE` but leaves the session open and the deletions uncommitted. Call `Pop3EndSession` to send `QUIT` and commit them. Calling `Pop3Reset`, calling `Pop3EndSessionNoQuit`, or losing the POP3 connection before `QUIT` causes the server to forget the pending deletion marks. Header-only or partial-message retrieval never marks a message for deletion, regardless of this property or the value of `keepOnServer`. See also: - [POP3 Session Management](https://www.chilkatsoft.com/p/p_250.asp) ### MailMan.IncludeRootCert `Chilkat 11.7.0 · wcpp · MailMan · IncludeRootCert · property · read/write` ```cpp bool get_IncludeRootCert(void); void put_IncludeRootCert(bool newVal); ``` Determines whether the root CA certificate is included in the S/MIME signature of a signed email. This property only applies when `EmbedCertChain` is `true`. ### MailMan.IsPop3Connected `Chilkat 11.7.0 · wcpp · MailMan · IsPop3Connected · property · read-only · since 9.5.0.48` ```cpp bool get_IsPop3Connected(void); ``` Returns `true` if Chilkat believes the POP3 connection is still open. Accessing this property does not send any command to the POP3 server. If the server has disconnected but Chilkat has not yet attempted further communication, this property may still return `true`. To verify that the POP3 connection is actually alive, call `Pop3Noop`. ### MailMan.IsSmtpConnected `Chilkat 11.7.0 · wcpp · MailMan · IsSmtpConnected · property · read-only` ```cpp bool get_IsSmtpConnected(void); ``` Returns `true` if Chilkat believes the SMTP connection is still open. Accessing this property does not communicate with the SMTP server. A lost connection may not be detected until the next SMTP command is sent. To verify that the SMTP connection is actually alive, call `SmtpNoop`. ### MailMan.LastSmtpStatus `Chilkat 11.7.0 · wcpp · MailMan · LastSmtpStatus · property · read-only` ```cpp int get_LastSmtpStatus(void); ``` Contains the SMTP failure status code returned by the server for the most recent SMTP operation. This property is nonzero only when Chilkat successfully connected, began an SMTP session, and then received a status code indicating failure. Such failures are generally reported by `4xx` or `5xx` replies. - **4xx** — Temporary failure. Retrying later may succeed. - **5xx** — Permanent failure. The request was rejected and usually requires a change before retrying. A value of `0` means that no SMTP failure status code was received. For example, the operation may have failed before an SMTP session was established. Use `SmtpFailReason` and `LastErrorText` for additional diagnostic information. ### MailMan.LastSmtpStatusMsg `Chilkat 11.7.0 · wcpp · MailMan · LastSmtpStatusMsg · property · read-only · since 9.5.0.85` ```cpp void get_LastSmtpStatusMsg(CkString &str); const wchar_t *lastSmtpStatusMsg(void); ``` Provides the text associated with the most recent SMTP reply received from the server. Use this property together with `LastSmtpStatus` when diagnosing an SMTP failure or interpreting a server-specific response. ### MailMan.LogMailReceivedFilename `Chilkat 11.7.0 · wcpp · MailMan · LogMailReceivedFilename · property · read/write` ```cpp void get_LogMailReceivedFilename(CkString &str); const wchar_t *logMailReceivedFilename(void); void put_LogMailReceivedFilename(const wchar_t *str); ``` Specifies a local file path where Chilkat writes each message exactly as it was received from the POP3 server. This is useful for debugging problems involving MIME structure, encodings, attachments, or server behavior. ### MailMan.LogMailSentFilename `Chilkat 11.7.0 · wcpp · MailMan · LogMailSentFilename · property · read/write` ```cpp void get_LogMailSentFilename(CkString &str); const wchar_t *logMailSentFilename(void); void put_LogMailSentFilename(const wchar_t *str); ``` Specifies a local file path where Chilkat writes the exact MIME message sent to the SMTP server. This is useful for inspecting the final MIME produced by Chilkat. ### MailMan.MailHost `Chilkat 11.7.0 · wcpp · MailMan · MailHost · property · read/write` ```cpp void get_MailHost(CkString &str); const wchar_t *mailHost(void); void put_MailHost(const wchar_t *str); ``` Sets the POP3 server hostname or IP address. Do not include `http://` or `https://`. The value should be a hostname such as `pop.example.com` or an IPv4/IPv6 address. ### MailMan.MailPort `Chilkat 11.7.0 · wcpp · MailMan · MailPort · property · read/write` ```cpp int get_MailPort(void); void put_MailPort(int newVal); ``` Sets the POP3 server port number. The default value is `110`. The standard POP3 ports and their associated `MailMan` property settings are described below. **Port 995 — POP3 over Implicit SSL/TLS** Uses implicit SSL/TLS, meaning the TLS connection is established immediately when the TCP connection is opened. ``` mailman.MailPort = 995; mailman.PopSsl = true; ``` **Port 110 — Standard Unencrypted POP3** Uses a normal unencrypted POP3 connection. ``` mailman.MailPort = 110; mailman.PopSsl = false; mailman.Pop3Stls = false; mailman.Pop3StlsIfPossible = false; ``` **Port 110 — POP3 with Explicit TLS via STLS** The connection begins unencrypted and is upgraded to TLS using the POP3 `STLS` command. ``` mailman.MailPort = 110; mailman.PopSsl = false; mailman.Pop3Stls = true; ``` **Port 110 — Opportunistic STLS** Attempts to upgrade the connection to TLS using `STLS` if the POP3 server supports it. Otherwise, the connection remains unencrypted. ``` mailman.MailPort = 110; mailman.PopSsl = false; mailman.Pop3StlsIfPossible = true; ``` **Important:** `PopSsl` and `Pop3Stls` represent two different approaches to TLS security: - `PopSsl = true` means the connection begins as SSL/TLS from the very start (implicit TLS). - `Pop3Stls = true` means the connection begins unencrypted and is later upgraded to TLS using the POP3 `STLS` command (explicit TLS). These two approaches are mutually exclusive and should not both be enabled at the same time. Modern POP3 servers most commonly use either: - `995` with `PopSsl = true`, or - `110` with `Pop3Stls = true`. ### MailMan.MaxCount `Chilkat 11.7.0 · wcpp · MailMan · MaxCount · property · read/write` ```cpp int get_MaxCount(void); void put_MaxCount(int newVal); ``` Limits the number of messages retrieved from the POP3 server. The following methods honor this property: - `GetAllHeaders` - `GetHeaders` - `FetchAll` - `FetchRange` The default value is `0`, which means no limit. For `FetchAll`, a positive value selects the newest messages in the mailbox. For example, when `MaxCount = 2`, the two newest messages are retrieved and returned in normal mailbox order, with the older of the two first. ### MailMan.OAuth2AccessToken `Chilkat 11.7.0 · wcpp · MailMan · OAuth2AccessToken · property · read/write · since 9.5.0.44` ```cpp void get_OAuth2AccessToken(CkString &str); const wchar_t *oAuth2AccessToken(void); void put_OAuth2AccessToken(const wchar_t *str); ``` Sets the OAuth2 access token used for POP3 or SMTP XOAUTH2 authentication. When this property is set, Chilkat uses the `AUTH XOAUTH2` authentication mechanism when it is supported by the server. **For POP3 XOAUTH2 authentication:** `PopPassword` should be left empty, or explicitly set to the empty string. **For SMTP XOAUTH2 authentication:** `SmtpPassword` should be left unset, or set to the empty string. The access token is sent as a bearer token during the `AUTH XOAUTH2` authentication exchange. ### MailMan.OpaqueSigning `Chilkat 11.7.0 · wcpp · MailMan · OpaqueSigning · property · read/write` ```cpp bool get_OpaqueSigning(void); void put_OpaqueSigning(bool newVal); ``` Controls the MIME format used for digitally signed email. When set to `false`, Chilkat creates a `multipart/signed` email. In this format, the original email content remains visible as a normal MIME body part, and the digital signature is included as a separate MIME part. The top-level MIME `Content-Type` header will look similar to: ``` Content-Type: multipart/signed; protocol="application/pkcs7-signature"; micalg=sha-256; boundary="------------040808030405050402070604" ``` This is commonly referred to as a detached signature because the signed content exists separately from the signature itself. When set to `true`, Chilkat creates an opaque signed email using PKCS#7 signed-data format. In this case, the original MIME content is encapsulated inside the PKCS#7 signature structure. The top-level MIME `Content-Type` header will look similar to: ``` Content-Type: application/pkcs7-mime; smime-type="signed-data"; name="smime.p7m"; micalg=sha-256 ``` This format is historically known as opaque signing because the original message content is wrapped inside the PKCS#7 signed object and is not directly visible as ordinary MIME body parts. The default value is `true`. ### MailMan.P7mEncryptAttachFilename `Chilkat 11.7.0 · wcpp · MailMan · P7mEncryptAttachFilename · property · read/write · since 9.5.0.30` ```cpp void get_P7mEncryptAttachFilename(CkString &str); const wchar_t *p7mEncryptAttachFilename(void); void put_P7mEncryptAttachFilename(const wchar_t *str); ``` Sets the filename used in the `Content-Disposition` header when sending a PKCS#7 encrypted email. The default value is `smime.p7m`. ### MailMan.P7mSigAttachFilename `Chilkat 11.7.0 · wcpp · MailMan · P7mSigAttachFilename · property · read/write · since 9.5.0.30` ```cpp void get_P7mSigAttachFilename(CkString &str); const wchar_t *p7mSigAttachFilename(void); void put_P7mSigAttachFilename(const wchar_t *str); ``` Sets the filename used in the `Content-Disposition` header when sending an opaque signed PKCS#7 email. The default value is `smime.p7m`. ### MailMan.P7sSigAttachFilename `Chilkat 11.7.0 · wcpp · MailMan · P7sSigAttachFilename · property · read/write · since 9.5.0.30` ```cpp void get_P7sSigAttachFilename(CkString &str); const wchar_t *p7sSigAttachFilename(void); void put_P7sSigAttachFilename(const wchar_t *str); ``` Sets the filename used in the `Content-Disposition` header when sending a signed email with a detached PKCS#7 signature. The default value is `smime.p7s`. ### MailMan.PercentDoneScale `Chilkat 11.7.0 · wcpp · MailMan · PercentDoneScale · property · read/write · since 9.5.0.49` ```cpp int get_PercentDoneScale(void); void put_PercentDoneScale(int newVal); ``` This property is only valid in programming environments and languages that allow for event callbacks. Sets the value that represents 100% completion for `PercentDone` event callbacks. The default value is `100`, meaning progress values range from `0` to `100`. Setting this property to a larger value provides finer granularity. For example, setting `PercentDoneScale = 1000` allows progress to be reported in tenths of a percent. For example, if `PercentDoneScale = 1000`, then a callback value of `453` represents 45.3% complete. The value is clamped to a minimum of `10` and a maximum of `100000`. ### MailMan.Pop3SessionId `Chilkat 11.7.0 · wcpp · MailMan · Pop3SessionId · property · read-only` ```cpp int get_Pop3SessionId(void); ``` Returns `0` when no POP3 session is active. Otherwise, returns a positive integer that increments each time a new POP3 session is established. This can be used to detect whether a new session has started. ### MailMan.Pop3SessionLog `Chilkat 11.7.0 · wcpp · MailMan · Pop3SessionLog · property · read-only` ```cpp void get_Pop3SessionLog(CkString &str); const wchar_t *pop3SessionLog(void); ``` Provides the accumulated raw POP3 commands sent to the server and the raw responses received from the server. This property is read-only. To clear it, call `ClearPop3SessionLog`. ### MailMan.Pop3SPA `Chilkat 11.7.0 · wcpp · MailMan · Pop3SPA · property · read/write` ```cpp bool get_Pop3SPA(void); void put_Pop3SPA(bool newVal); ``` Determines whether SPA, also known as NTLM authentication, is used for POP3. Set this property to `true` to use SPA authentication. No other programming changes are required. The default value is `false`. **Note:** If SPA/NTLM authentication fails, set `Global.DefaultNtlmVersion = 1` and retry. ### MailMan.Pop3SslServerCertVerified `Chilkat 11.7.0 · wcpp · MailMan · Pop3SslServerCertVerified · property · read-only` ```cpp bool get_Pop3SslServerCertVerified(void); ``` Indicates whether the POP3 server certificate chain was successfully verified during the most recent SSL/TLS POP3 connection. This property reports certificate-chain verification only. It does not report hostname matching or public key pinning. When either of those checks is required, a mismatch causes the connection itself to fail. This property is meaningful only after an SSL/TLS POP3 connection attempt. ### MailMan.Pop3Stls `Chilkat 11.7.0 · wcpp · MailMan · Pop3Stls · property · read/write` ```cpp bool get_Pop3Stls(void); void put_Pop3Stls(bool newVal); ``` Determines whether Chilkat requires the POP3 connection to be upgraded to TLS using the `STLS` command. When set to `true`, Chilkat initially connects without encryption and then sends `STLS` before authenticating. The connection fails if the server does not support the required upgrade. `PopSsl` takes precedence. If implicit TLS is enabled, this property does not cause an additional explicit TLS upgrade. The default value is `false`. Use `Pop3StlsIfPossible` when the upgrade should be attempted only when the server advertises support. ### MailMan.Pop3StlsIfPossible `Chilkat 11.7.0 · wcpp · MailMan · Pop3StlsIfPossible · property · read/write · since 9.5.0.92` ```cpp bool get_Pop3StlsIfPossible(void); void put_Pop3StlsIfPossible(bool newVal); ``` Determines whether Chilkat attempts POP3 `STLS` when the server advertises support for it. If the server supports `STLS`, the connection is upgraded to TLS. Otherwise, the connection remains unencrypted. `PopSsl` takes precedence. If implicit TLS is enabled, no separate `STLS` upgrade is attempted. Use `Pop3Stls = true` instead when encryption is required and the connection should fail if explicit TLS is unavailable. The default value is `false`. ### MailMan.PopPassword `Chilkat 11.7.0 · wcpp · MailMan · PopPassword · property · read/write` ```cpp void get_PopPassword(CkString &str); const wchar_t *popPassword(void); void put_PopPassword(const wchar_t *str); ``` Sets the POP3 password. On Windows, if `Pop3SPA` is enabled, both `PopUsername` and `PopPassword` may be set to `"default"` to use the credentials of the current logged-on Windows user. ### MailMan.PopPasswordBase64 `Chilkat 11.7.0 · wcpp · MailMan · PopPasswordBase64 · property · read/write` ```cpp void get_PopPasswordBase64(CkString &str); const wchar_t *popPasswordBase64(void); void put_PopPasswordBase64(const wchar_t *str); ``` Sets the POP3 password as Base64-encoded data instead of plain text. MailMan decodes the Base64 value and uses the resulting bytes as the POP3 password. This property is useful when an application already stores or receives the password in Base64 form; Base64 encoding by itself does not provide encryption. ### MailMan.PopSsl `Chilkat 11.7.0 · wcpp · MailMan · PopSsl · property · read/write` ```cpp bool get_PopSsl(void); void put_PopSsl(bool newVal); ``` Determines whether implicit SSL/TLS is used when connecting to the POP3 server. When set to `true`, the TLS connection is established immediately when the TCP connection is opened. Implicit POP3 TLS commonly uses port `995`. Implicit TLS takes precedence over explicit TLS. Therefore, when `PopSsl = true`, the settings in `Pop3Stls` and `Pop3StlsIfPossible` do not cause a separate `STLS` upgrade. The default value is `false`. When `AutoFix` is enabled, a standard POP3 port can cause Chilkat to select the appropriate TLS mode automatically before connecting. ### MailMan.PopUsername `Chilkat 11.7.0 · wcpp · MailMan · PopUsername · property · read/write` ```cpp void get_PopUsername(CkString &str); const wchar_t *popUsername(void); void put_PopUsername(const wchar_t *str); ``` Sets the POP3 login name. On Windows, if `Pop3SPA` is enabled, both `PopUsername` and `PopPassword` may be set to `"default"` to use the credentials of the current logged-on Windows user. ### MailMan.PreferIpv6 `Chilkat 11.7.0 · wcpp · MailMan · PreferIpv6 · property · read/write` ```cpp bool get_PreferIpv6(void); void put_PreferIpv6(bool newVal); ``` Determines whether IPv6 is preferred over IPv4 when both are available for a hostname. The default value is `false`, which means IPv4 is preferred. ### MailMan.ReadTimeout `Chilkat 11.7.0 · wcpp · MailMan · ReadTimeout · property · read/write` ```cpp int get_ReadTimeout(void); void put_ReadTimeout(int newVal); ``` Sets the maximum number of seconds to wait when the SMTP or POP3 server stops responding. The default value is `30` seconds. See also: - [SMTP Timeout Sending Large Emails](https://cknotes.com/smtp-timeout-sending-large-email/) ### MailMan.RequireHostnameMatch `Chilkat 11.7.0 · wcpp · MailMan · RequireHostnameMatch · property · read/write · since 11.6.0` ```cpp bool get_RequireHostnameMatch(void); void put_RequireHostnameMatch(bool newVal); ``` Determines whether the hostname used for the TLS connection must match a name in the server certificate's Subject Alternative Name (SAN) extension. The comparison is made against the SNI hostname sent in the TLS handshake. MailMan normally uses the configured server hostname. When connecting by IP address or through an alternate endpoint, set `SniHostname` to the expected DNS hostname. Hostname matching is enforced independently of `RequireSslCertVerify`. Therefore, it still occurs when certificate-chain verification is not required. Starting in v11.7.0, a wildcard SAN entry is matched as RFC 9525 (formerly RFC 6125) specifies. The wildcard must be the entire left-most label (`*.example.com`) and stands for exactly one label: `*.example.com` matches `www.example.com`, but not `a.b.example.com` and not the bare `example.com`. (Earlier versions matched the bare domain, and accepted a wildcard in any position.) A wildcard is not accepted directly under a top-level domain or a country-code second level such as `co.uk`, and never matches an IP address. The default value is `false`. ### MailMan.RequireSslCertVerify `Chilkat 11.7.0 · wcpp · MailMan · RequireSslCertVerify · property · read/write` ```cpp bool get_RequireSslCertVerify(void); void put_RequireSslCertVerify(bool newVal); ``` Determines whether Chilkat requires the SMTP or POP3 server certificate chain to be successfully verified for an SSL/TLS connection. When set to `true`, Chilkat rejects the connection if the certificate is expired, is not yet valid, or its chain/signature cannot be verified to a trusted root. Certificate-chain verification is separate from hostname matching and public key pinning. `RequireHostnameMatch` is enforced independently, even when this property is `false`. `TlsPinSet` supplements, rather than replaces, certificate verification. The default value is `false`. This property applies only to SSL/TLS connections. ### MailMan.ResetDateOnLoad `Chilkat 11.7.0 · wcpp · MailMan · ResetDateOnLoad · property · read/write` ```cpp bool get_ResetDateOnLoad(void); void put_ResetDateOnLoad(bool newVal); ``` Determines whether the email's `Date` header is reset to the current date and time when an email is loaded. This applies to methods such as `LoadMbx`, `LoadEml`, `LoadMime`, `LoadXml`, and `LoadXmlString`. The default value is `false`. ### MailMan.SendBufferSize `Chilkat 11.7.0 · wcpp · MailMan · SendBufferSize · property · read/write` ```cpp int get_SendBufferSize(void); void put_SendBufferSize(int newVal); ``` Sets the buffer size used by the underlying TCP/IP socket when sending data. The default value is `32767`. ### MailMan.SizeLimit `Chilkat 11.7.0 · wcpp · MailMan · SizeLimit · property · read/write` ```cpp int get_SizeLimit(void); void put_SizeLimit(int newVal); ``` Sets the maximum message size, in bytes, for POP3 operations that can download one or more complete emails. It applies to any method capable of downloading a full email and does not restrict header-only or partial-body retrieval. The default value is `0`, which means no size limit. For multi-message retrieval, a message larger than the limit is omitted from the result. No placeholder `Email` is added for the skipped message, and skipping an oversized message does not by itself cause the retrieval method to fail. ### MailMan.SmtpAuthMethod `Chilkat 11.7.0 · wcpp · MailMan · SmtpAuthMethod · property · read/write` ```cpp void get_SmtpAuthMethod(CkString &str); const wchar_t *smtpAuthMethod(void); void put_SmtpAuthMethod(const wchar_t *str); ``` Sets the SMTP authentication method to use. This property should usually be left empty so Chilkat can automatically choose the most secure method advertised by the SMTP server. If the server does not advertise authentication methods, or if a specific method must be forced, set this property to one of: `NONE`, `LOGIN`, `PLAIN`, `CRAM-MD5`, or `NTLM`. **Note:** If NTLM authentication fails, set `Global.DefaultNtlmVersion = 1` and retry. ### MailMan.SmtpFailReason `Chilkat 11.7.0 · wcpp · MailMan · SmtpFailReason · property · read-only · since 9.5.0.48` ```cpp void get_SmtpFailReason(CkString &str); const wchar_t *smtpFailReason(void); ``` Contains a keyword describing the result or failure reason for the last SMTP operation. `Success`: The method succeeded. `Failed`: A general failure occurred. `NoValidRecipients`: The SMTP server rejected all recipients. `NoRecipients`: No To, CC, or BCC recipients were provided. `SomeBadRecipients`: `AllOrNone` is `true` and some recipients were rejected. `Aborted`: The application aborted the operation. `NoFrom`: No FROM address was provided. `FromFailure`: The server rejected the `MAIL FROM` command. `NoCredentials`: Required credentials were not provided. `AuthFailure`: SMTP authentication failed. `DataFailure`: The server returned an error in response to `DATA`. `NoSmtpHostname`: No SMTP hostname or IP address was provided. `StartTlsFailed`: Failed to upgrade the connection using STARTTLS. `ConnectFailed`: Could not establish the TCP or TLS connection. `GreetingError`: The SMTP server returned an error in the initial greeting. `ConnectionLost`: The SMTP connection was lost during the operation. `Timeout`: A socket read or write timeout occurred. `RenderFailed`: The email could not be rendered for sending. `NotUnlocked`: `UnlockBundle` was not called on at least one MailMan instance. `InternalFailure`: An internal failure occurred and should be reported to Chilkat support. ### MailMan.SmtpHost `Chilkat 11.7.0 · wcpp · MailMan · SmtpHost · property · read/write` ```cpp void get_SmtpHost(CkString &str); const wchar_t *smtpHost(void); void put_SmtpHost(const wchar_t *str); ``` Sets the SMTP server hostname or IP address. Do not include `http://` or `https://`. The value may be a hostname, IPv4 address, or IPv6 address. See also: - [Sending Email without an SMTP Server](https://www.chilkatsoft.com/p/p_325.asp) ### MailMan.SmtpLoginDomain `Chilkat 11.7.0 · wcpp · MailMan · SmtpLoginDomain · property · read/write` ```cpp void get_SmtpLoginDomain(CkString &str); const wchar_t *smtpLoginDomain(void); void put_SmtpLoginDomain(const wchar_t *str); ``` Sets the Windows domain to use when logging in to an SMTP server with NTLM authentication. Leave this property empty if no domain is required. ### MailMan.SmtpMailFrom `Chilkat 11.7.0 · wcpp · MailMan · SmtpMailFrom · property · read/write · since 11.0.0` ```cpp void get_SmtpMailFrom(CkString &str); const wchar_t *smtpMailFrom(void); void put_SmtpMailFrom(const wchar_t *str); ``` Sets the SMTP envelope sender address used in the `MAIL FROM` command. This address receives bounce messages and identifies the originator of the SMTP transaction. It may differ from the `From` MIME header. If left empty, Chilkat uses the email address from the message's `From` header. SMTP servers may reject the envelope sender based on DNS, SPF, or other server policy checks. ### MailMan.SmtpPassword `Chilkat 11.7.0 · wcpp · MailMan · SmtpPassword · property · read/write` ```cpp void get_SmtpPassword(CkString &str); const wchar_t *smtpPassword(void); void put_SmtpPassword(const wchar_t *str); ``` Sets the password used for SMTP authentication. Chilkat supports SMTP authentication methods such as `LOGIN`, `PLAIN`, `CRAM-MD5`, and `NTLM`, and normally chooses the most secure available method automatically. If NTLM authentication is used, `SmtpUsername` and `SmtpPassword` may be set to the keyword `"default"` to use the current Windows logged-on credentials. ### MailMan.SmtpPipelining `Chilkat 11.7.0 · wcpp · MailMan · SmtpPipelining · property · read/write · since 9.5.0.49` ```cpp bool get_SmtpPipelining(void); void put_SmtpPipelining(bool newVal); ``` Determines whether SMTP pipelining is used when the server advertises support for it. The default value is `true`. Set this property to `false` to prevent SMTP pipelining. This is required when using `AllOrNone`. ### MailMan.SmtpPort `Chilkat 11.7.0 · wcpp · MailMan · SmtpPort · property · read/write` ```cpp int get_SmtpPort(void); void put_SmtpPort(int newVal); ``` Sets the SMTP server port. The default value is `25`. If using implicit SSL/TLS with `SmtpSsl = true`, the common port is `465`. ### MailMan.SmtpSessionLog `Chilkat 11.7.0 · wcpp · MailMan · SmtpSessionLog · property · read-only` ```cpp void get_SmtpSessionLog(CkString &str); const wchar_t *smtpSessionLog(void); ``` Provides the accumulated raw SMTP commands sent to the server and raw responses received from the server. This property is read-only. To clear it, call `ClearSmtpSessionLog`. ### MailMan.SmtpSsl `Chilkat 11.7.0 · wcpp · MailMan · SmtpSsl · property · read/write` ```cpp bool get_SmtpSsl(void); void put_SmtpSsl(bool newVal); ``` Determines whether Chilkat uses implicit SSL/TLS when connecting to the SMTP server. When set to `true`, the TLS connection is established immediately when the TCP connection is opened. Implicit SMTP TLS commonly uses port `465`. Implicit TLS takes precedence over explicit TLS. Therefore, when `SmtpSsl = true`, the settings in `StartTLS` and `StartTLSifPossible` do not cause a separate `STARTTLS` upgrade. The default value is `false`. When `AutoFix` is enabled, a standard SMTP port can cause Chilkat to select the appropriate TLS mode automatically before connecting. See also: - [AutoFix Explained in More Detail](https://cknotes.com/autofix-pop3-and-smtp-port-tls-settings/) ### MailMan.SmtpSslServerCertVerified `Chilkat 11.7.0 · wcpp · MailMan · SmtpSslServerCertVerified · property · read-only` ```cpp bool get_SmtpSslServerCertVerified(void); ``` Indicates whether the SMTP server certificate chain was successfully verified during the most recent SSL/TLS SMTP connection. This property reports certificate-chain verification only. It does not report hostname matching or public key pinning. When either of those checks is required, a mismatch causes the connection itself to fail. This property is meaningful only after an SSL/TLS SMTP connection attempt. ### MailMan.SmtpUsername `Chilkat 11.7.0 · wcpp · MailMan · SmtpUsername · property · read/write` ```cpp void get_SmtpUsername(CkString &str); const wchar_t *smtpUsername(void); void put_SmtpUsername(const wchar_t *str); ``` Sets the username used for SMTP authentication. If `SmtpAuthMethod` is `NTLM`, `SmtpUsername` and `SmtpPassword` may be set to the keyword `"default"` to use the current Windows logged-on credentials. See also: - [550 5.7.1 Unable to relay](https://www.chilkatsoft.com/p/p_372.asp) ### MailMan.SniHostname `Chilkat 11.7.0 · wcpp · MailMan · SniHostname · property · read/write · since 11.6.0` ```cpp void get_SniHostname(CkString &str); const wchar_t *sniHostname(void); void put_SniHostname(const wchar_t *str); ``` Specifies the DNS hostname sent in the Server Name Indication (SNI) extension of the TLS handshake for SMTP and POP3 connections. Normally this property is left empty. In that case, MailMan uses `SmtpHost` for SMTP connections and `MailHost` for POP3 connections. Set this property when connecting by IP address or through an alternate endpoint while the server's TLS certificate and virtual-host configuration use a DNS hostname. The value is also used for certificate hostname comparison when `RequireHostnameMatch` is `true`. The default value is the empty string. ### MailMan.SocksHostname `Chilkat 11.7.0 · wcpp · MailMan · SocksHostname · property · read/write` ```cpp void get_SocksHostname(CkString &str); const wchar_t *socksHostname(void); void put_SocksHostname(const wchar_t *str); ``` Sets the SOCKS4 or SOCKS5 proxy hostname or IPv4 address. This property is used only when `SocksVersion` is set to `4` or `5`. ### MailMan.SocksPassword `Chilkat 11.7.0 · wcpp · MailMan · SocksPassword · property · read/write` ```cpp void get_SocksPassword(CkString &str); const wchar_t *socksPassword(void); void put_SocksPassword(const wchar_t *str); ``` Sets the SOCKS5 proxy password, if authentication is required. SOCKS4 does not use passwords, so this property applies only to SOCKS5. ### MailMan.SocksPort `Chilkat 11.7.0 · wcpp · MailMan · SocksPort · property · read/write` ```cpp int get_SocksPort(void); void put_SocksPort(int newVal); ``` Sets the SOCKS proxy port. The default value is `1080`. This property applies only when `SocksVersion` is set to `4` or `5`. ### MailMan.SocksUsername `Chilkat 11.7.0 · wcpp · MailMan · SocksUsername · property · read/write` ```cpp void get_SocksUsername(CkString &str); const wchar_t *socksUsername(void); void put_SocksUsername(const wchar_t *str); ``` Sets the SOCKS4 or SOCKS5 proxy username. This property is used only when `SocksVersion` is set to `4` or `5`. ### MailMan.SocksVersion `Chilkat 11.7.0 · wcpp · MailMan · SocksVersion · property · read/write` ```cpp int get_SocksVersion(void); void put_SocksVersion(int newVal); ``` Specifies whether a SOCKS proxy is used. - `0` — no SOCKS proxy is used. This is the default. - `4` — connect through a SOCKS4 proxy. - `5` — connect through a SOCKS5 proxy. ### MailMan.SoRcvBuf `Chilkat 11.7.0 · wcpp · MailMan · SoRcvBuf · property · read/write` ```cpp int get_SoRcvBuf(void); void put_SoRcvBuf(int newVal); ``` Sets the socket receive buffer size. The default value is `4194304`. This property should normally be left unchanged. It may be increased if download performance is slow. Values should preferably be multiples of `4096`. See also: - [More Information about TCP performance and Buffer Sizes](http://www.cknotes.com/?p=446) ### MailMan.SoSndBuf `Chilkat 11.7.0 · wcpp · MailMan · SoSndBuf · property · read/write` ```cpp int get_SoSndBuf(void); void put_SoSndBuf(int newVal); ``` Sets the socket send buffer size. The default value is `262144`. This property should normally be left unchanged. It may be increased if upload performance is slow. Testing values such as `512K` or `1MB` is reasonable. Values should preferably be multiples of `4096`. See also: - [More Information about TCP performance and Buffer Sizes](http://www.cknotes.com/?p=446) ### MailMan.SslAllowedCiphers `Chilkat 11.7.0 · wcpp · MailMan · SslAllowedCiphers · property · read/write · since 9.5.0.48` ```cpp void get_SslAllowedCiphers(CkString &str); const wchar_t *sslAllowedCiphers(void); void put_SslAllowedCiphers(const wchar_t *str); ``` Sets the TLS cipher suites Chilkat is allowed to offer when establishing SSL/TLS connections. The default value is an empty string, meaning Chilkat may offer all implemented cipher suites. To restrict the allowed ciphers, set this property to a comma-separated list of cipher suite names, ordered by preference. The cipher suites supported by Chilkat are: **TLS 1.3 Cipher Suites** - `TLS_AES_128_GCM_SHA256` - `TLS_CHACHA20_POLY1305_SHA256` - `TLS_AES_256_GCM_SHA384` **ChaCha20-Poly1305 Cipher Suites** - `TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256` - `TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256` - `TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256` **AES-GCM Cipher Suites** - `TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256` - `TLS_DHE_RSA_WITH_AES_128_GCM_SHA256` - `TLS_RSA_WITH_AES_128_GCM_SHA256` - `TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256` - `TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384` - `TLS_DHE_RSA_WITH_AES_256_GCM_SHA384` - `TLS_RSA_WITH_AES_256_GCM_SHA384` - `TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384` **AES-128 CBC Cipher Suites** - `TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA` - `TLS_DHE_RSA_WITH_AES_128_CBC_SHA` - `TLS_RSA_WITH_AES_128_CBC_SHA` - `TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256` - `TLS_DHE_RSA_WITH_AES_128_CBC_SHA256` - `TLS_RSA_WITH_AES_128_CBC_SHA256` - `TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA` - `TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256` **AES-256 CBC Cipher Suites** - `TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA` - `TLS_DHE_RSA_WITH_AES_256_CBC_SHA` - `TLS_RSA_WITH_AES_256_CBC_SHA` - `TLS_DHE_RSA_WITH_AES_256_CBC_SHA256` - `TLS_RSA_WITH_AES_256_CBC_SHA256` - `TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384` - `TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA` - `TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384` **Important:** The client offers a list of allowed cipher suites, but the server chooses the final cipher suite from that list. This property can also include special keywords: - `rsa1024` — reject server certificates with RSA keys smaller than 1024 bits. - `rsa2048` — reject server certificates with RSA keys smaller than 2048 bits. - `secure-renegotiation` — require secure renegotiation as defined by RFC 5746. - `best-practices` — use Chilkat's current best-practice cipher policy. The `best-practices` setting currently requires RSA server keys of at least 1024 bits, requires secure renegotiation, and disallows RC4, DES, and 3DES ciphers. Example: > `TLS_DHE_RSA_WITH_AES_256_CBC_SHA256, TLS_RSA_WITH_AES_256_CBC_SHA, rsa1024, secure-renegotiation` ### MailMan.SslProtocol `Chilkat 11.7.0 · wcpp · MailMan · SslProtocol · property · read/write · since 9.5.0.46` ```cpp void get_SslProtocol(CkString &str); const wchar_t *sslProtocol(void); void put_SslProtocol(const wchar_t *str); ``` Selects the SSL/TLS protocol version used for secure SMTP and POP3 connections. Possible values include: - `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 allows Chilkat to choose the protocol dynamically based on the server's requirements. Choosing an exact protocol version can cause the connection to fail unless that exact version is negotiated. In most cases, using an `or higher` setting is preferable. ### MailMan.StartTLS `Chilkat 11.7.0 · wcpp · MailMan · StartTLS · property · read/write` ```cpp bool get_StartTLS(void); void put_StartTLS(bool newVal); ``` Determines whether Chilkat requires SMTP `STARTTLS`. When set to `true`, Chilkat connects to the SMTP server normally and then sends the `STARTTLS` command to upgrade the connection to TLS before authenticating and sending email. The connection fails if the server does not support the required upgrade. `SmtpSsl` takes precedence. If implicit TLS is enabled, this property does not cause an additional explicit TLS upgrade. The default value is `false`. Use `StartTLSifPossible` when the upgrade should be attempted only when the server advertises support. This property applies to SMTP only, not POP3. ### MailMan.StartTLSifPossible `Chilkat 11.7.0 · wcpp · MailMan · StartTLSifPossible · property · read/write · since 9.5.0.67` ```cpp bool get_StartTLSifPossible(void); void put_StartTLSifPossible(bool newVal); ``` Determines whether Chilkat attempts SMTP `STARTTLS` when the server advertises support for it. If the server supports `STARTTLS`, the connection is upgraded to TLS. Otherwise, the connection remains unencrypted. `SmtpSsl` takes precedence. If implicit TLS is enabled, no separate `STARTTLS` upgrade is attempted. Use `StartTLS = true` instead when encryption is required and the connection should fail if explicit TLS is unavailable. The default value is `true`. This property applies to SMTP only, not POP3. ### MailMan.TlsCipherSuite `Chilkat 11.7.0 · wcpp · MailMan · TlsCipherSuite · property · read-only · since 9.5.0.49` ```cpp void get_TlsCipherSuite(CkString &str); const wchar_t *tlsCipherSuite(void); ``` Contains the current or most recently negotiated TLS cipher suite. If no TLS connection has been established, or if the TLS connection attempt failed, this property is empty. Example value: > `TLS_DHE_RSA_WITH_AES_256_CBC_SHA256` ### MailMan.TlsPinSet `Chilkat 11.7.0 · wcpp · MailMan · TlsPinSet · property · read/write · since 9.5.0.55` ```cpp void get_TlsPinSet(CkString &str); const wchar_t *tlsPinSet(void); void put_TlsPinSet(const wchar_t *str); ``` **Full documentation for this property (same in every language):** [Encodings Supported by Chilkat](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md) Sets the expected Subject Public Key Info (SPKI) fingerprints for TLS public key pinning. During the TLS handshake, Chilkat compares the server certificate's public key fingerprint against this pin set. If none of the pins match, the connection fails. Pinning supplements normal certificate-chain verification; it does not replace it. A matching pin does not by itself make an expired or otherwise invalid certificate acceptable. The format is: > `hash_algorithm, encoding, SPKI_fingerprint_1, SPKI_fingerprint_2, ...` Example with one SHA-256 Base64 pin: > `sha256, base64, lKg1SIqyhPSK19tlPbjl8s02yChsVTDklQpkMCHvsTE=` Example with two SHA-256 Base64 pins: > `sha256, base64, 4t37LpnGmrMEAG8HEz9yIrnvJV2euVRwCLb9EH5WZyI=, 68b0G5iqMvWVWvUCjMuhLEyekM5729PadtnU5tdXZKs=` Supported hash algorithms include `sha1`, `sha256`, `sha384`, `sha512`, `md2`, `md5`, `haval`, `ripemd128`, `ripemd160`, `ripemd256`, and `ripemd320`. Supported encodings include `base64`, `hex`, and other Chilkat-supported encodings. ### MailMan.TlsVersion `Chilkat 11.7.0 · wcpp · MailMan · TlsVersion · property · read-only · since 9.5.0.49` ```cpp void get_TlsVersion(CkString &str); const wchar_t *tlsVersion(void); ``` Contains the current or most recently negotiated TLS protocol version. If no TLS connection has been established, or if the TLS connection attempt failed, this property is empty. Possible values include `SSL 3.0`, `TLS 1.0`, `TLS 1.1`, `TLS 1.2`, and `TLS 1.3`. ### MailMan.UncommonOptions `Chilkat 11.7.0 · wcpp · MailMan · UncommonOptions · property · read/write · since 9.5.0.80` ```cpp void get_UncommonOptions(CkString &str); const wchar_t *uncommonOptions(void); void put_UncommonOptions(const wchar_t *str); ``` Provides a comma-separated list of uncommon option keywords. This property defaults to an empty string and should normally remain empty. - `ProtectFromVpn` — introduced in v9.5.0.80. On Android, bypasses any installed or active VPN. - `SmtpLoginAnsi` — introduced in v9.5.0.97. Causes SMTP login and password strings containing non-ASCII characters to be sent using ANSI encoding instead of UTF-8. This restores the older Chilkat behavior for SMTP servers that expect ANSI credentials. ### MailMan.UseApop `Chilkat 11.7.0 · wcpp · MailMan · UseApop · property · read/write` ```cpp bool get_UseApop(void); void put_UseApop(bool newVal); ``` Determines whether Chilkat automatically uses APOP authentication when the POP3 server supports it. The default value is `false`. ## Methods ### MailMan.AddPfxSourceBd `Chilkat 11.7.0 · wcpp · MailMan · AddPfxSourceBd · method · since 11.0.0` ```cpp bool AddPfxSourceBd(CkBinDataW &bd, const wchar_t *password); ``` Adds a PFX/PKCS#12 certificate store to the MailMan object's internal list of sources used for locating certificates and private keys. `bd` is a `BinData` object containing the bytes of a `.pfx` or `.p12` file. The added PFX source is searched when Chilkat needs a certificate and private key for operations such as: - Decrypting S/MIME encrypted email - Creating digitally signed email Multiple PFX sources can be added by calling this method once for each PFX. On Windows, the registry-based Windows certificate stores are automatically searched when locating certificates and private keys. Therefore, if the required certificate and private key are already installed in the Windows certificate store, explicitly adding a PFX source is often unnecessary. On macOS, the Apple Keychain is also searched automatically. If the required certificate and private key are already available in the Apple Keychain, it is likewise unnecessary to explicitly add a PFX source. `password` specifies the password required to open the PFX. Returns true for success, false for failure. ### MailMan.AddPfxSourceFile `Chilkat 11.7.0 · wcpp · MailMan · AddPfxSourceFile · method` ```cpp bool AddPfxSourceFile(const wchar_t *pfxFilePath, const wchar_t *password); ``` Adds a PFX/PKCS#12 file to the MailMan object's internal list of sources used for locating certificates and private keys. The `pfxFilePath` argument is the path to a `.pfx` or `.p12` file. The added PFX source is searched when Chilkat needs a certificate and private key for operations such as: - Decrypting S/MIME encrypted email - Creating digitally signed email Multiple PFX sources can be added by calling this method once for each PFX. On Windows, the registry-based Windows certificate stores are automatically searched when locating certificates and private keys. Therefore, if the required certificate and private key are already installed in the Windows certificate store, explicitly adding a PFX source is often unnecessary. On macOS, the Apple Keychain is also searched automatically. If the required certificate and private key are already available in the Apple Keychain, it is likewise unnecessary to explicitly add a PFX source. The `password` argument specifies the password required to open the PFX. Returns true for success, false for failure. ### MailMan.CheckMail `Chilkat 11.7.0 · wcpp · MailMan · CheckMail · method` ```cpp int CheckMail(void); ``` Returns the number of messages currently available in the POP3 mailbox. Returns `-1` if an error occurs. If no POP3 session is active, Chilkat connects and authenticates automatically. After a successful call, the POP3 session remains open and can be reused by subsequent POP3 methods. Call `Pop3EndSession` or `Pop3EndSessionNoQuit` to end it. If this method fails, use `VerifyPopConnection` to test basic connectivity and `VerifyPopLogin` to test authentication. Async variant: `CheckMailAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.ClearPop3SessionLog `Chilkat 11.7.0 · wcpp · MailMan · ClearPop3SessionLog · method` ```cpp void ClearPop3SessionLog(void); ``` Clears the current contents of the `Pop3SessionLog` property. ### MailMan.ClearSmtpSessionLog `Chilkat 11.7.0 · wcpp · MailMan · ClearSmtpSessionLog · method` ```cpp void ClearSmtpSessionLog(void); ``` Clears the current contents of the `SmtpSessionLog` property. ### MailMan.CloseSmtpConnection `Chilkat 11.7.0 · wcpp · MailMan · CloseSmtpConnection · method` ```cpp bool CloseSmtpConnection(void); ``` Explicitly closes the current SMTP connection. Before closing the socket connection, Chilkat sends the SMTP `QUIT` command to the server. Calling this method is optional in most applications. The MailMan object automatically opens an SMTP connection when an email-sending method is called and no connection is already open. The connection is then kept open so subsequent sends can reuse it. For example, if an application calls `SendEmail` ten times, the first call opens the SMTP connection, and the following calls send over the same connection. If an SMTP-related property changes, such as the hostname, username, password, port, or SSL/TLS settings, the existing connection is closed and a new connection is established the next time an email-sending method is called. The SMTP connection is also closed automatically when the MailMan object is destroyed. Returns true for success, false for failure. Async variant: `CloseSmtpConnectionAsync` — same arguments, returns a `Task` (see Async variants below). See also: - [Minimizing SMTP Sessions](https://www.chilkatsoft.com/p/p_176.asp) ### MailMan.DeleteBundle `Chilkat 11.7.0 · wcpp · MailMan · DeleteBundle · method` ```cpp bool DeleteBundle(CkEmailBundleW &emailBundle); ``` Deletes POP3 messages by using the UIDLs stored in the `X-UIDL` headers of the `Email` objects in `emailBundle`. An email that does not contain an `X-UIDL` header is skipped. Chilkat processes the bundle and marks each located message with `DELE`. If a connection failure occurs before processing is complete, the POP3 session is lost and all uncommitted deletion marks are forgotten. If `ImmediateDelete` is `true`, which is the default, Chilkat sends a single `QUIT` after the entire bundle has been processed. This commits all deletion marks and closes the POP3 session. If it is `false`, the marks remain pending until the application calls `Pop3EndSession`. When making multiple deletion calls, it is usually more efficient to set `ImmediateDelete` to `false`, perform all deletion operations, and call `Pop3EndSession` once at the end. Returns true for success, false for failure. Async variant: `DeleteBundleAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.DeleteByMsgnum `Chilkat 11.7.0 · wcpp · MailMan · DeleteByMsgnum · method` ```cpp bool DeleteByMsgnum(int msgnum); ``` Marks an email for deletion by its POP3 message number. **Important:** Message numbers are specific to a single POP3 session and can change from one session to the next. For example, if a mailbox contains ten messages, they are numbered `1` through `10`. If message `1` is deleted and a new POP3 session is opened, the remaining messages are renumbered `1` through `9`. A POP3 session must already be established before this method is called, either explicitly by calling `Pop3BeginSession` or implicitly by calling another method that opens the session. This method does not automatically begin a new session because doing so could change the message numbers and cause the application to delete a different message than intended. This method only marks the message for deletion. The message is not removed from the POP3 mailbox until the session is ended by calling `Pop3EndSession`, which sends the `QUIT` command. Returns true for success, false for failure. Async variant: `DeleteByMsgnumAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.DeleteByUidl `Chilkat 11.7.0 · wcpp · MailMan · DeleteByUidl · method` ```cpp bool DeleteByUidl(const wchar_t *uidl); ``` Marks the POP3 message identified by the UIDL in `uidl` for deletion. UIDLs are preferred over message numbers because they remain stable across sessions while the message remains in the mailbox. If `ImmediateDelete` is `true`, which is the default, Chilkat sends `QUIT`, commits the deletion, and closes the session before returning. If it is `false`, the message is only marked with `DELE`; call `Pop3EndSession` to commit all pending deletions. `Pop3Reset` or `Pop3EndSessionNoQuit` cancels uncommitted deletion marks. If no POP3 session is active, Chilkat connects and authenticates automatically. Returns true for success, false for failure. Async variant: `DeleteByUidlAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.DeleteEmail `Chilkat 11.7.0 · wcpp · MailMan · DeleteEmail · method` ```cpp bool DeleteEmail(CkEmailW &email); ``` Deletes a POP3 message by using the UIDL stored in the `X-UIDL` header of the `Email` in `email`. If `email` does not contain an `X-UIDL` header, the method fails. If no POP3 session is active, Chilkat connects and authenticates automatically. The UIDL is used to locate the corresponding message in the current mailbox. If `ImmediateDelete` is `true`, which is the default, Chilkat marks the message for deletion, sends `QUIT` to commit the deletion, and closes the POP3 session before returning. If it is `false`, the message is marked with `DELE` and the deletion remains pending until `Pop3EndSession` sends `QUIT`. `Pop3Reset` or `Pop3EndSessionNoQuit` cancels uncommitted deletion marks. Uncommitted marks are also forgotten if the POP3 connection is lost before `QUIT` is sent. Returns true for success, false for failure. Async variant: `DeleteEmailAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.DeleteUidlSet `Chilkat 11.7.0 · wcpp · MailMan · DeleteUidlSet · method · since 11.1.0` ```cpp bool DeleteUidlSet(CkStringTableW &stUidls); ``` Marks the POP3 messages whose UIDLs are listed in `stUidls` for deletion. Chilkat processes the UIDL set and sends `DELE` for each located message. If a connection failure occurs before processing is complete, the POP3 session is lost and all uncommitted deletion marks are forgotten. If `ImmediateDelete` is `true`, which is the default, Chilkat sends a single `QUIT` after the entire set has been processed. This commits all deletion marks and closes the POP3 session. If it is `false`, the marks remain pending until the application calls `Pop3EndSession`. When making multiple deletion calls, it is usually more efficient to set `ImmediateDelete` to `false`, perform all deletion operations, and call `Pop3EndSession` once at the end. Returns true for success, false for failure. Async variant: `DeleteUidlSetAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.FetchAll `Chilkat 11.7.0 · wcpp · MailMan · FetchAll · method · since 11.0.0` ```cpp bool FetchAll(bool keepOnServer, bool headersOnly, int numBodyLines, CkEmailBundleW &bundle); ``` Retrieves messages from the POP3 mailbox and appends them to the `EmailBundle` in `bundle`. Existing emails in `bundle` are preserved. If `headersOnly` is `true`, Chilkat retrieves the message headers and a partial body. `numBodyLines` specifies the number of body lines; a value of `0` retrieves the first body line. Attachments are not downloaded. If `headersOnly` is `false`, Chilkat retrieves the complete messages, including attachments. If `keepOnServer` is `true`, every retrieved message remains on the POP3 server, regardless of `ImmediateDelete`. If `keepOnServer` is `false` and complete messages are retrieved, Chilkat sends `DELE` for each message after it is downloaded. If `ImmediateDelete = true`, Chilkat sends `QUIT` only after the entire requested set has been downloaded successfully; this commits the deletions and closes the POP3 session. If `ImmediateDelete = false`, the deletion marks remain pending in the open session until the application calls `Pop3EndSession`. If the POP3 connection is lost before `QUIT`, the session ends and the server forgets all uncommitted deletion marks. Chilkat automatically reconnects and establishes a new session when the next POP3 method is called. Header-only or partial retrieval never marks messages for deletion, regardless of `keepOnServer` or `ImmediateDelete`. `MaxCount` can limit the result to the newest messages. `SizeLimit` can omit oversized messages from full-message retrieval. If an error occurs while retrieving multiple messages, processing stops at the first failure. Messages that were successfully retrieved before the failure remain appended to the output `EmailBundle`; Chilkat does not remove those results or restore the bundle to its prior state. Returns true for success, false for failure. Async variant: `FetchAllAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.FetchByUidl `Chilkat 11.7.0 · wcpp · MailMan · FetchByUidl · method · since 11.0.0` ```cpp bool FetchByUidl(const wchar_t *uidl, bool headerOnly, int numBodyLines, CkEmailW &email); ``` Retrieves one message by UIDL and stores it in the `Email` in `email`. The message remains on the POP3 server. If `headerOnly` is `true`, Chilkat retrieves the headers and a partial body. `numBodyLines` specifies the number of body lines; a value of `0` retrieves the first body line. Attachments are not downloaded. If `headerOnly` is `false`, Chilkat retrieves the complete message, including attachments. If `uidl` is not found or the fetch otherwise fails, `email` is left unchanged. Returns true for success, false for failure. Async variant: `FetchByUidlAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.FetchFull `Chilkat 11.7.0 · wcpp · MailMan · FetchFull · method · since 11.0.0` ```cpp bool FetchFull(CkEmailW &partialEmail, CkEmailW &fullEmail); ``` Downloads the complete version of the header-only or partial `Email` in `partialEmail` and stores it in `fullEmail`. The full result includes the complete body and any attachments. `partialEmail` must retain the UIDL needed to locate the same message in the POP3 mailbox. The original POP3 session is not required; Chilkat connects and authenticates automatically when a session is not already active. If the UIDL no longer exists in the mailbox, or if the full message cannot be downloaded for another reason, the method fails and `fullEmail` remains unchanged. This method is useful when an application first retrieves headers or partial bodies and downloads the complete message only after the user selects it. Returns true for success, false for failure. Async variant: `FetchFullAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.FetchMimeBd `Chilkat 11.7.0 · wcpp · MailMan · FetchMimeBd · method · since 9.5.0.73` ```cpp bool FetchMimeBd(const wchar_t *uidl, CkBinDataW &mimeData); ``` Fetches an email from the POP3 server by UIDL and stores the raw MIME source bytes in `mimeData`. Chilkat clears the existing contents of `mimeData` before attempting the download. If the method succeeds, `mimeData` contains the downloaded MIME bytes. If it fails, `mimeData` remains empty. Returns true for success, false for failure. Async variant: `FetchMimeBdAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.FetchMimeByMsgnumBd `Chilkat 11.7.0 · wcpp · MailMan · FetchMimeByMsgnumBd · method · since 11.0.0` ```cpp bool FetchMimeByMsgnumBd(int msgnum, CkBinDataW &bd); ``` Retrieves an email by POP3 message number and stores the raw MIME source bytes in `bd`. Chilkat clears the existing contents of `bd` before attempting the download. If the method succeeds, `bd` contains the downloaded MIME bytes. If it fails, `bd` remains empty. **Important:** Message numbers are specific to a single POP3 session and can change from one session to the next. For example, if a mailbox contains ten messages, they are numbered `1` through `10`. If message `1` is deleted and a new POP3 session is opened, the remaining messages are renumbered `1` through `9`. A POP3 session must already be established before this method is called, either explicitly by calling `Pop3BeginSession` or implicitly by calling another method that opens the session. This method does not automatically begin a new POP3 session because doing so could change the message numbers. Returns true for success, false for failure. Async variant: `FetchMimeByMsgnumBdAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.FetchOne `Chilkat 11.7.0 · wcpp · MailMan · FetchOne · method · since 11.0.0` ```cpp bool FetchOne(bool headerOnly, int numBodyLines, int msgNum, CkEmailW &email); ``` Retrieves one message by POP3 message number and stores it in the `Email` in `email`. The first message has number `1`. The message remains on the server. If `headerOnly` is `true`, Chilkat retrieves the headers and a partial body. `numBodyLines` specifies the number of body lines; a value of `0` retrieves the first body line. Attachments are not downloaded. If `headerOnly` is `false`, Chilkat retrieves the complete message, including attachments. If the message number is invalid or the fetch otherwise fails, `email` is left unchanged. POP3 message numbers are specific to the current mailbox state and can change between sessions. Use UIDLs when a message must be identified reliably across sessions. Returns true for success, false for failure. Async variant: `FetchOneAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.FetchRange `Chilkat 11.7.0 · wcpp · MailMan · FetchRange · method · since 11.0.0` ```cpp bool FetchRange(bool keepOnServer, bool headersOnly, int numBodyLines, int startIndex, int endIndex, CkEmailBundleW &bundle); ``` Retrieves a range of messages from the POP3 mailbox and appends them to the `EmailBundle` in `bundle`. Existing emails in `bundle` are preserved. `startIndex` and `endIndex` are zero-based, inclusive indexes in the server's current mailbox order. The messages are appended in increasing index order. If `endIndex` extends past the end of the mailbox, Chilkat stops at the final message. If `startIndex` is greater than `endIndex`, the method succeeds without appending any messages. If `headersOnly` is `true`, Chilkat retrieves the message headers and a partial body. `numBodyLines` specifies the number of body lines; a value of `0` retrieves the first body line. Attachments are not downloaded. If `headersOnly` is `false`, Chilkat retrieves the complete messages, including attachments. If `keepOnServer` is `true`, every retrieved message remains on the POP3 server, regardless of `ImmediateDelete`. If `keepOnServer` is `false` and complete messages are retrieved, Chilkat sends `DELE` for each message after it is downloaded. If `ImmediateDelete = true`, Chilkat sends `QUIT` only after the entire requested set has been downloaded successfully; this commits the deletions and closes the POP3 session. If `ImmediateDelete = false`, the deletion marks remain pending in the open session until the application calls `Pop3EndSession`. If the POP3 connection is lost before `QUIT`, the session ends and the server forgets all uncommitted deletion marks. Chilkat automatically reconnects and establishes a new session when the next POP3 method is called. Header-only or partial retrieval never marks messages for deletion, regardless of `keepOnServer` or `ImmediateDelete`. If an error occurs while retrieving multiple messages, processing stops at the first failure. Messages that were successfully retrieved before the failure remain appended to the output `EmailBundle`; Chilkat does not remove those results or restore the bundle to its prior state. Returns true for success, false for failure. Async variant: `FetchRangeAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.FetchUidls `Chilkat 11.7.0 · wcpp · MailMan · FetchUidls · method · since 11.0.0` ```cpp bool FetchUidls(CkStringTableW &uidls); ``` Retrieves the UIDLs of the messages currently stored in the POP3 mailbox and stores them in `uidls`. The UIDLs are returned in the server's current mailbox order, with one entry for each message. A POP3 UIDL, or Unique ID Listing, is a persistent identifier assigned by the mail server. Unlike POP3 message numbers, which can change between sessions, a UIDL remains stable for as long as the message remains in the mailbox. If no POP3 session is active, Chilkat connects and authenticates automatically. After a successful call, the session remains open for reuse by subsequent POP3 methods. Returns true for success, false for failure. Async variant: `FetchUidlsAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.FetchUidlSet `Chilkat 11.7.0 · wcpp · MailMan · FetchUidlSet · method · since 11.0.0` ```cpp bool FetchUidlSet(CkStringTableW &uidls, bool headersOnly, int numBodyLines, CkEmailBundleW &bundle); ``` Retrieves the messages whose UIDLs are listed in `uidls` and appends them to the `EmailBundle` in `bundle`. Existing emails in `bundle` are preserved, and the retrieved messages remain on the POP3 server. UIDLs are processed in the order in which they occur in `uidls`. A duplicate UIDL causes the same message to be appended again. A UIDL that is not present in the mailbox is ignored and does not by itself cause the method to fail. If `headersOnly` is `true`, Chilkat retrieves the headers and a partial body. `numBodyLines` specifies the number of body lines; a value of `0` retrieves the first body line. Attachments are not downloaded. If `headersOnly` is `false`, Chilkat retrieves the complete messages, including attachments. If an error occurs while retrieving multiple messages, processing stops at the first failure. Messages that were successfully retrieved before the failure remain appended to the output `EmailBundle`; Chilkat does not remove those results or restore the bundle to its prior state. Returns true for success, false for failure. Async variant: `FetchUidlSetAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.GetLastJsonData `Chilkat 11.7.0 · wcpp · MailMan · GetLastJsonData · method · since 11.0.0` ```cpp void GetLastJsonData(CkJsonObjectW &json); ``` Copies into `json` any structured JSON details produced by the immediately preceding method call. Not every MailMan method produces JSON details. Call this method immediately after the operation of interest so the returned information corresponds to that operation. ### MailMan.GetMailboxCount `Chilkat 11.7.0 · wcpp · MailMan · GetMailboxCount · method` ```cpp int GetMailboxCount(void); ``` Returns the number of emails currently available in the POP3 mailbox. Returns `-1` if an error occurs. This method is functionally identical to `CheckMail`. Async variant: `GetMailboxCountAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.GetMailboxInfoXml `Chilkat 11.7.0 · wcpp · MailMan · GetMailboxInfoXml · method` ```cpp bool GetMailboxInfoXml(CkString &outXml); const wchar_t *getMailboxInfoXml(void); ``` Returns an XML document containing information about the messages currently stored in the POP3 mailbox. The XML includes the UIDL and size, in bytes, for each message in the mailbox. This is useful for scanning mailbox state without downloading the full messages. Returns true for success, false for failure. Async variant: `GetMailboxInfoXmlAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.GetMailboxSize `Chilkat 11.7.0 · wcpp · MailMan · GetMailboxSize · method` ```cpp unsigned long GetMailboxSize(void); ``` Returns the total combined size, in bytes, of all messages currently stored in the POP3 mailbox. This is also known as the POP3 maildrop size. If no POP3 session is active, Chilkat connects and authenticates automatically. After a successful call, the session remains open for reuse by subsequent POP3 methods. Returns `-1` on failure. Async variant: `GetMailboxSizeAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.GetServerCert `Chilkat 11.7.0 · wcpp · MailMan · GetServerCert · method · since 11.0.0` ```cpp bool GetServerCert(bool useSmtp, CkCertW &cert); ``` Gets the digital certificate presented by the SMTP or POP3 server for the current SSL/TLS connection and stores it in `cert`. If `useSmtp` is `true`, Chilkat returns the certificate for the SMTP connection. If `useSmtp` is `false`, Chilkat returns the certificate for the POP3 connection. This method applies only when the current connection uses SSL/TLS. Returns true for success, false for failure. ### MailMan.GetSizeByUidl `Chilkat 11.7.0 · wcpp · MailMan · GetSizeByUidl · method` ```cpp int GetSizeByUidl(const wchar_t *uidl); ``` Returns the size, in bytes, of the email on the POP3 server identified by `uidl`. The size includes the full message content, including attachments. Returns `-1` if an error occurs. Async variant: `GetSizeByUidlAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.IsSmtpDsnCapable `Chilkat 11.7.0 · wcpp · MailMan · IsSmtpDsnCapable · method` ```cpp bool IsSmtpDsnCapable(void); ``` Contacts the SMTP server and determines whether it supports the DSN, or Delivery Status Notification, extension defined by RFC 3461. DSN support is used with properties such as `DsnEnvid`, `DsnNotify`, and `DsnRet`. Returns `true` if the SMTP server advertises DSN support, otherwise returns `false`. Async variant: `IsSmtpDsnCapableAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.LoadMbxFile `Chilkat 11.7.0 · wcpp · MailMan · LoadMbxFile · method · since 11.0.0` ```cpp bool LoadMbxFile(const wchar_t *mbxPath, CkEmailBundleW &bundle); ``` Loads emails from a `.mbx` mailbox file and stores them in `bundle`. If a filter has been configured, only the emails matching the filter are returned. Returns true for success, false for failure. ### MailMan.LoadTaskCaller `Chilkat 11.7.0 · wcpp · MailMan · LoadTaskCaller · method · since 9.5.0.80` ```cpp bool LoadTaskCaller(CkTaskW &task); ``` Associates this MailMan object with the original MailMan caller of the asynchronous operation represented by `task`. Use this method when the application has a `Task` but no longer has a reference to the MailMan object that started the asynchronous operation. A common example is code running in a `TaskCompleted` event handler that needs access to the original MailMan object. `task` may be the task returned by any MailMan asynchronous method, and the task does not need to be complete. This method does not copy the original caller's configuration or state. After it succeeds, this MailMan object refers to the same MailMan state as the original caller. Any state previously associated with this MailMan object is replaced, and changes made through either reference affect the same MailMan instance. Returns true for success, false for failure. ### MailMan.OpenSmtpConnection `Chilkat 11.7.0 · wcpp · MailMan · OpenSmtpConnection · method` ```cpp bool OpenSmtpConnection(void); ``` Explicitly opens a connection to the SMTP server and authenticates if a username and password, OAuth2 token, or other applicable authentication settings have been provided. Calling this method is optional. Email-sending methods such as `SendEmail` automatically open and authenticate the SMTP connection when needed. This method is equivalent to calling `SmtpConnect` followed by `SmtpAuthenticate`. Returns true for success, false for failure. Async variant: `OpenSmtpConnectionAsync` — same arguments, returns a `Task` (see Async variants below). See also: - [Minimizing SMTP Connections](https://www.chilkatsoft.com/p/p_176.asp) ### MailMan.Pop3Authenticate `Chilkat 11.7.0 · wcpp · MailMan · Pop3Authenticate · method · since 9.5.0.56` ```cpp bool Pop3Authenticate(void); ``` Authenticates with the POP3 server using the current POP3 property settings, such as `PopUsername`, `PopPassword`, and any authentication-related options. This method should be called only after a successful call to `Pop3Connect`. The `Pop3BeginSession` method performs both steps and is equivalent to calling `Pop3Connect` followed by `Pop3Authenticate`. Calling this method is optional in most applications because POP3 methods that communicate with the server automatically connect and authenticate if no authenticated session is already open. Returns true for success, false for failure. Async variant: `Pop3AuthenticateAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.Pop3BeginSession `Chilkat 11.7.0 · wcpp · MailMan · Pop3BeginSession · method` ```cpp bool Pop3BeginSession(void); ``` Explicitly begins a POP3 session by connecting to the POP3 server and authenticating using the current POP3 property settings. Calling this method is optional. Any method that requires an established POP3 session automatically connects and logs in if a session is not already open. Returns true for success, false for failure. Async variant: `Pop3BeginSessionAsync` — same arguments, returns a `Task` (see Async variants below). See also: - [More about POP3 Session Management](https://www.chilkatsoft.com/p/p_250.asp) ### MailMan.Pop3Connect `Chilkat 11.7.0 · wcpp · MailMan · Pop3Connect · method · since 9.5.0.56` ```cpp bool Pop3Connect(void); ``` Explicitly connects to the POP3 server. If SSL/TLS is required by the current property settings, the secure TLS channel is established as part of this call. This method receives the server's initial greeting but does not authenticate. After `Pop3Connect` succeeds, call `Pop3Authenticate` to log in. The `Pop3BeginSession` method performs both steps and is equivalent to calling `Pop3Connect` followed by `Pop3Authenticate`. Calling this method is optional in most applications because POP3 methods that communicate with the server automatically connect and authenticate if no authenticated session is already open. When finished with the POP3 server, call `Pop3EndSession` or `Pop3EndSessionNoQuit` to disconnect. Returns true for success, false for failure. Async variant: `Pop3ConnectAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.Pop3EndSession `Chilkat 11.7.0 · wcpp · MailMan · Pop3EndSession · method` ```cpp bool Pop3EndSession(void); ``` Sends the POP3 `QUIT` command and closes the current POP3 connection. Any messages marked for deletion during the session are permanently deleted when the server accepts `QUIT`. After the session ends, `IsPop3Connected` is `false` and `Pop3SessionId` returns `0`. Returns true for success, false for failure. Async variant: `Pop3EndSessionAsync` — same arguments, returns a `Task` (see Async variants below). See also: - [More about POP3 Session Management](https://www.chilkatsoft.com/p/p_250.asp) ### MailMan.Pop3EndSessionNoQuit `Chilkat 11.7.0 · wcpp · MailMan · Pop3EndSessionNoQuit · method` ```cpp bool Pop3EndSessionNoQuit(void); ``` Closes the POP3 connection without sending the `QUIT` command. Pending deletion marks are not committed. Messages marked with `DELE` during the session remain in the mailbox after reconnecting. Use `Pop3EndSession` when pending deletions should be finalized. This method should always return `true`. Returns true for success, false for failure. Async variant: `Pop3EndSessionNoQuitAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.Pop3Noop `Chilkat 11.7.0 · wcpp · MailMan · Pop3Noop · method` ```cpp bool Pop3Noop(void); ``` Sends a POP3 `NOOP` command to the server. This can be useful for keeping a POP3 session alive or for verifying that the current POP3 connection is still open and functioning. Returns true for success, false for failure. Async variant: `Pop3NoopAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.Pop3Reset `Chilkat 11.7.0 · wcpp · MailMan · Pop3Reset · method` ```cpp bool Pop3Reset(void); ``` Sends the POP3 `RSET` command to the server. Any messages marked for deletion during the current session are unmarked and remain in the mailbox. The POP3 session remains open after a successful reset. Returns true for success, false for failure. Async variant: `Pop3ResetAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.Pop3SendRawCommand `Chilkat 11.7.0 · wcpp · MailMan · Pop3SendRawCommand · method` ```cpp bool Pop3SendRawCommand(const wchar_t *command, const wchar_t *charset, CkString &outStr); const wchar_t *pop3SendRawCommand(const wchar_t *command, const wchar_t *charset); ``` Sends a raw command to the POP3 server and returns the server's response. If `command` contains non-US-ASCII characters, `charset` specifies the character set used to encode the command before it is sent. Examples include `utf-8`, `ansi`, `iso-8859-1`, and `Shift_JIS`. This method is intended for advanced use, diagnostics, or issuing POP3 commands not directly exposed by higher-level MailMan methods. Returns true for success, false for failure. Async variant: `Pop3SendRawCommandAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.QuickSend `Chilkat 11.7.0 · wcpp · MailMan · QuickSend · method` ```cpp bool QuickSend(const wchar_t *fromAddr, const wchar_t *toAddr, const wchar_t *subject, const wchar_t *body, const wchar_t *smtpServer); ``` Sends a simple email to a single recipient without requiring the application to explicitly create an `Email` object. The `fromAddr` argument is the sender address, `toAddr` is the recipient address, `subject` is the message subject, `body` is the plain-text body, and `smtpServer` is the SMTP server hostname. This method is convenient for simple cases. For attachments, HTML email, CC/BCC recipients, alternate bodies, signing, encryption, or more control over headers and SMTP behavior, create an `Email` object and use `SendEmail` instead. Returns true for success, false for failure. Async variant: `QuickSendAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.RenderToMime `Chilkat 11.7.0 · wcpp · MailMan · RenderToMime · method` ```cpp bool RenderToMime(CkEmailW &email, CkString &outStr); const wchar_t *renderToMime(CkEmailW &email); ``` Renders the `Email` in `email` as the MIME text that would be sent to the SMTP server, without actually sending the email. Rendering uses the current MailMan and `Email` settings and may include MIME formatting, header encoding, replacement-pattern substitution, digital signing, encryption, and other transformations required before transmission. This method does not modify `email`. Values generated as part of rendering are produced for the returned MIME and are not written back to the supplied `Email`. Repeated calls are not guaranteed to produce byte-for-byte identical MIME. By default, a `Bcc` header present in `email` is included in the rendered MIME. Add `NoBccHeader` to the `Email` object's `UncommonOptions` property to omit the `Bcc` header from the MIME. Conceptually, `SendEmail` performs this rendering step and then sends the resulting MIME. **Note:** If the MIME may contain 8-bit or binary data, use `RenderToMimeBytes` or `RenderToMimeBd`. Returning binary MIME as a string can corrupt bytes that are not valid text. Returns true for success, false for failure. ### MailMan.RenderToMimeBd `Chilkat 11.7.0 · wcpp · MailMan · RenderToMimeBd · method · since 9.5.0.62` ```cpp bool RenderToMimeBd(CkEmailW &email, CkBinDataW &renderedMime); ``` Renders the `Email` in `email` as MIME bytes and appends the result to `renderedMime`. This method is the `BinData` version of `RenderToMimeBytes`. It is useful when the rendered MIME must be preserved as bytes, especially when it may contain 8-bit or binary MIME content. Rendering does not modify `email`. Values generated for the rendered MIME are not written back to the supplied `Email`. Returns true for success, false for failure. ### MailMan.RenderToMimeSb `Chilkat 11.7.0 · wcpp · MailMan · RenderToMimeSb · method · since 9.5.0.62` ```cpp bool RenderToMimeSb(CkEmailW &email, CkStringBuilderW &renderedMime); ``` Renders the `Email` in `email` as MIME text and appends the result to `renderedMime`. This method is the `StringBuilder` version of `RenderToMime`. Rendering does not modify `email`; values generated for the rendered MIME are not written back to the supplied `Email`. **Note:** If the MIME may contain 8-bit or binary content, use `RenderToMimeBytes` or `RenderToMimeBd` instead. Returning binary MIME as text can corrupt data that is not valid text. Returns true for success, false for failure. ### MailMan.SendBundle `Chilkat 11.7.0 · wcpp · MailMan · SendBundle · method` ```cpp bool SendBundle(CkEmailBundleW &bundle); ``` Sends each email in `bundle`. This is equivalent to calling `SendEmail` once for each email in the bundle. If an error occurs while sending one email, Chilkat continues attempting to send the remaining emails unless a fatal error occurs that requires the send operation to stop. Because it can be difficult or impossible to programmatically determine exactly which emails succeeded and which failed after a bundle send, applications that need detailed per-message status should loop through the bundle and call `SendEmail` for each message individually. Returns true for success, false for failure. Async variant: `SendBundleAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.SendEmail `Chilkat 11.7.0 · wcpp · MailMan · SendEmail · method` ```cpp bool SendEmail(CkEmailW &email); ``` Sends a single email through the configured SMTP server. Chilkat automatically opens the SMTP connection when needed. After the email is sent, the connection remains open so a subsequent call to `SendEmail` or another email-sending method can reuse the same SMTP connection. If an SMTP-related property changes, such as `SmtpHost`, `SmtpUsername`, password, port, or SSL/TLS settings, Chilkat automatically closes the existing connection and establishes a new one using the updated settings on the next send. **Important:** Some SMTP servers do not complete final delivery processing until the SMTP connection is closed. In these cases, call `CloseSmtpConnection` after sending. Most SMTP servers process the message immediately, so explicitly closing the connection is usually not required. By default, a `Bcc` header in `email` is included in the MIME sent to the SMTP server. To prevent Bcc addresses from appearing in the MIME header, add `NoBccHeader` to the `Email` object's `UncommonOptions` property. After sending, additional information about the SMTP transaction may be available by calling `GetLastJsonData`. If this method fails, examine `SmtpFailReason` and `LastSmtpStatus`. The latter is nonzero only when Chilkat established an SMTP session and received a failure status code from the server. Returns true for success, false for failure. Async variant: `SendEmailAsync` — same arguments, returns a `Task` (see Async variants below). See also: - [Configure GMail for less secure apps](http://www.ghacks.net/2014/07/21/gmail-starts-block-less-secure-apps-enable-access/) - [Diagnosing SMTP Failures](https://www.chilkatsoft.com/p/p_245.asp) - [SocketError: WSAECONNABORTED when Sending Email (SMTP)](https://www.chilkatsoft.com/p/p_389.asp) - [SMTP 553-Relaying Denied](https://www.chilkatsoft.com/p/p_425.asp) - [550 5.7.1 Unable to relay](https://www.chilkatsoft.com/p/p_372.asp) - [Using undisclosed recipients / Send Failed](https://www.chilkatsoft.com/p/p_369.asp) - [sockError: 10053, WSAECONNABORTED An established connection was aborted by the software in your host machine](https://www.chilkatsoft.com/p/p_361.asp) - [Sending Email without a Mail Server (sort of)](https://www.chilkatsoft.com/p/p_325.asp) - [Invalid Token error when trying to connect with SSL (SMTP, POP3, IMAP, FTP, HTTP)](https://www.chilkatsoft.com/p/p_321.asp) - [SMTP SSL Clarification](https://www.chilkatsoft.com/p/p_315.asp) - [Read Receipt vs. Delivery Receipt when Sending Email](https://www.chilkatsoft.com/p/p_313.asp) - [Validating an Email Address - Unfortunately, Nothing is Perfect](https://www.chilkatsoft.com/p/p_235.asp) - [POP-before-SMTP Authentication](https://www.chilkatsoft.com/p/p_148.asp) ### MailMan.SendMime `Chilkat 11.7.0 · wcpp · MailMan · SendMime · method` ```cpp bool SendMime(const wchar_t *fromAddr, const wchar_t *recipients, const wchar_t *mimeSource); ``` Sends an email from caller-supplied MIME text. The MIME source in `mimeSource` is passed to the SMTP server as the message content. This method provides complete control over the MIME that is sent. It is useful when the application already has a fully formed MIME message, or when the MIME was created externally and should not be rebuilt from an `Email` object. The `fromAddr` argument is the SMTP reverse-path address used in the `MAIL FROM` command. This is where bounced email and non-delivery reports are normally delivered. It can be different from the `From` header in the MIME. `recipients` is a comma-separated list of plain email addresses used in SMTP `RCPT TO` commands. Do not include display names or formatted mailbox syntax; supply only addresses such as `alice@example.com,bob@example.com`. If this method fails, examine `SmtpFailReason` and `LastSmtpStatus`. The latter is nonzero only when Chilkat established an SMTP session and received a failure status code from the server. Returns true for success, false for failure. Async variant: `SendMimeAsync` — same arguments, returns a `Task` (see Async variants below). See also: - [SMTP Protocol in a Nutshell](http://www.cknotes.com/?p=40) ### MailMan.SendMimeBd `Chilkat 11.7.0 · wcpp · MailMan · SendMimeBd · method · since 9.5.0.73` ```cpp bool SendMimeBd(const wchar_t *fromAddr, const wchar_t *recipients, CkBinDataW &mimeData); ``` Sends an email from caller-supplied MIME bytes contained in `mimeData`. This method is the `BinData` version of `SendMimeBytes`. It is useful when the MIME must be sent exactly as bytes, such as when it contains binary MIME content, 8bit encodings, or a DKIM/DomainKey signature where byte preservation matters. `fromAddr` is the SMTP reverse-path address used in the `MAIL FROM` command. `recipients` is a comma-separated list of plain email addresses used in SMTP `RCPT TO` commands. Do not include display names or formatted mailbox syntax in `recipients`. If this method fails, examine `SmtpFailReason` and `LastSmtpStatus`. The latter is nonzero only when Chilkat established an SMTP session and received a failure status code from the server. Returns true for success, false for failure. Async variant: `SendMimeBdAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.SetDecryptCert `Chilkat 11.7.0 · wcpp · MailMan · SetDecryptCert · method · since 9.5.0.40` ```cpp bool SetDecryptCert(CkCertW &cert); ``` Explicitly specifies the certificate to use when decrypting encrypted email. The certificate must correspond to the recipient certificate used to encrypt the message, and the associated private key must be available to Chilkat through the certificate itself, an added PFX source, an XML certificate vault, or the platform certificate store where applicable. Returns true for success, false for failure. ### MailMan.SetDecryptCert2 `Chilkat 11.7.0 · wcpp · MailMan · SetDecryptCert2 · method` ```cpp bool SetDecryptCert2(CkCertW &cert, CkPrivateKeyW &privateKey); ``` Explicitly specifies both the certificate and its associated private key to use when decrypting S/MIME encrypted email. In most cases, it is simpler to call `AddPfxSourceFile` or `AddPfxSourceData` to provide the certificate and private key together in a PFX/PKCS#12 source. On Windows, if the certificate and private key are already installed in the default certificate store, no explicit setup may be needed because MailMan automatically searches the Windows certificate stores. Returns true for success, false for failure. ### MailMan.SetPassword `Chilkat 11.7.0 · wcpp · MailMan · SetPassword · method · since 9.5.0.71` ```cpp bool SetPassword(const wchar_t *protocolName, CkSecureStringW &password); ``` Sets the POP3 or SMTP password from a `SecureString`. The `protocolName` argument specifies which password is being set. Use `pop3` to set the POP3 password, which is equivalent to setting the `PopPassword` property. Use `smtp` to set the SMTP password, which is equivalent to setting the `SmtpPassword` property. Returns true for success, false for failure. ### MailMan.SetSslClientCert `Chilkat 11.7.0 · wcpp · MailMan · SetSslClientCert · method` ```cpp bool SetSslClientCert(CkCertW &cert); ``` Sets the client-side certificate to use for SSL/TLS connections. This is typically not required. Most SSL/TLS connections authenticate the server only, while the client remains unauthenticated at the TLS layer. Use this method only when the SMTP or POP3 server requires TLS client certificate authentication. Returns true for success, false for failure. ### MailMan.SetSslClientCertPem `Chilkat 11.7.0 · wcpp · MailMan · SetSslClientCertPem · method` ```cpp bool SetSslClientCertPem(const wchar_t *pemDataOrFilename, const wchar_t *pemPassword); ``` Sets the client-side certificate to use for SSL/TLS connections, loading it from PEM data or from a PEM file. The `pemDataOrFilename` argument may contain PEM text or the path to a PEM file. The `pemPassword` argument supplies the password if the PEM private key is encrypted. TLS client certificates are typically required only when the server uses mutual TLS. Most SMTP and POP3 SSL/TLS connections do not require a client certificate. Returns true for success, false for failure. ### MailMan.SetSslClientCertPfx `Chilkat 11.7.0 · wcpp · MailMan · SetSslClientCertPfx · method` ```cpp bool SetSslClientCertPfx(const wchar_t *pfxPath, const wchar_t *pfxPassword); ``` Sets the client-side certificate to use for SSL/TLS connections, loading it from a PFX/PKCS#12 file. The `pfxPath` argument is the path to the PFX file, and `pfxPassword` is the password required to open it. TLS client certificates are typically required only when the server uses mutual TLS. Most SMTP and POP3 SSL/TLS connections do not require a client certificate. Returns true for success, false for failure. ### MailMan.SmtpAuthenticate `Chilkat 11.7.0 · wcpp · MailMan · SmtpAuthenticate · method · since 9.5.0.48` ```cpp bool SmtpAuthenticate(void); ``` Authenticates with the SMTP server using the current SMTP property settings, such as `SmtpUsername`, `SmtpPassword`, OAuth2 token settings, and other authentication-related options. This method should be called only after a successful call to `SmtpConnect`. The `OpenSmtpConnection` method performs both steps and is equivalent to calling `SmtpConnect` followed by `SmtpAuthenticate`. Calling this method is optional in most applications because SMTP methods that communicate with the server, such as `SendEmail`, automatically connect and authenticate if no authenticated SMTP connection is already open. Returns true for success, false for failure. Async variant: `SmtpAuthenticateAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.SmtpConnect `Chilkat 11.7.0 · wcpp · MailMan · SmtpConnect · method · since 9.5.0.48` ```cpp bool SmtpConnect(void); ``` Explicitly connects to the SMTP server. If SSL/TLS is required by the current property settings, the secure TLS channel is established as part of this call. This method receives the server's initial greeting but does not authenticate. After `SmtpConnect` succeeds, call `SmtpAuthenticate` to authenticate. The `OpenSmtpConnection` method performs both steps and is equivalent to calling `SmtpConnect` followed by `SmtpAuthenticate`. Calling this method is optional in most applications because SMTP methods that communicate with the server, such as `SendEmail`, automatically connect and authenticate if no authenticated SMTP connection is already open. Returns true for success, false for failure. Async variant: `SmtpConnectAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.SmtpNoop `Chilkat 11.7.0 · wcpp · MailMan · SmtpNoop · method` ```cpp bool SmtpNoop(void); ``` Sends an SMTP `NOOP` command to the server. This can be useful for testing whether the SMTP connection is working and still valid. If an SMTP connection is not already open, `SmtpNoop` automatically establishes the connection using the current SMTP property settings. Returns true for success, false for failure. Async variant: `SmtpNoopAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.SmtpReset `Chilkat 11.7.0 · wcpp · MailMan · SmtpReset · method` ```cpp bool SmtpReset(void); ``` Sends an SMTP `RSET` command to the server. The `RSET` command resets the server-side state of the current SMTP transaction so the connection can be used to begin a new mail transaction. This method is rarely needed. It would normally only be useful if a mail-sending method failed and left the SMTP connection open in a non-initial state, a situation that should generally not occur with the Chilkat MailMan object. Returns true for success, false for failure. Async variant: `SmtpResetAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.SmtpSendRawCommand `Chilkat 11.7.0 · wcpp · MailMan · SmtpSendRawCommand · method` ```cpp bool SmtpSendRawCommand(const wchar_t *command, const wchar_t *charset, bool bEncodeBase64, CkString &outStr); const wchar_t *smtpSendRawCommand(const wchar_t *command, const wchar_t *charset, bool bEncodeBase64); ``` Sends a raw command to the SMTP server and returns the server's response. If `command` contains non-US-ASCII characters, `charset` specifies the character set used to encode the command before it is sent. Examples include `utf-8`, `ansi`, `iso-8859-1`, and `Shift_JIS`. If `bEncodeBase64` is `true`, the response is returned in Base64-encoded form. If `bEncodeBase64` is `false`, the raw response text is returned. This method is intended for advanced use, diagnostics, or issuing SMTP commands not directly exposed by higher-level MailMan methods. Returns true for success, false for failure. Async variant: `SmtpSendRawCommandAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.SshAuthenticatePk `Chilkat 11.7.0 · wcpp · MailMan · SshAuthenticatePk · method` ```cpp bool SshAuthenticatePk(const wchar_t *sshLogin, CkSshKeyW &privKey); ``` Authenticates with the SSH server using public-key authentication after an SSH tunnel has been opened. The `sshLogin` argument is the SSH account name. The `privKey` argument is the `SshKey` containing the private key used for authentication. The matching public key must already be installed for the SSH account on the server. An SSH tunneling session begins by calling `SshOpenTunnel` to connect to the SSH server, followed by either `SshAuthenticatePk` or `SshAuthenticatePw` to authenticate. After the SSH tunnel is established and authenticated, MailMan's underlying SMTP or POP3 communication uses the SSH tunnel. No other programming changes are required beyond the initial tunnel setup calls. Returns true for success, false for failure. Async variant: `SshAuthenticatePkAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.SshAuthenticatePw `Chilkat 11.7.0 · wcpp · MailMan · SshAuthenticatePw · method` ```cpp bool SshAuthenticatePw(const wchar_t *sshLogin, const wchar_t *sshPassword); ``` Authenticates with the SSH server using an SSH username and password after an SSH tunnel has been opened. The `sshLogin` argument is the SSH account name, and `sshPassword` is the corresponding SSH password. An SSH tunneling session begins by calling `SshOpenTunnel` to connect to the SSH server, followed by either `SshAuthenticatePw` or `SshAuthenticatePk` to authenticate. After the SSH tunnel is established and authenticated, MailMan's underlying SMTP or POP3 communication uses the SSH tunnel. No other programming changes are required beyond the initial tunnel setup calls. Returns true for success, false for failure. Async variant: `SshAuthenticatePwAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.SshCloseTunnel `Chilkat 11.7.0 · wcpp · MailMan · SshCloseTunnel · method` ```cpp bool SshCloseTunnel(void); ``` Closes the SSH tunnel used for SMTP or POP3 communication. Returns true for success, false for failure. Async variant: `SshCloseTunnelAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.SshOpenTunnel `Chilkat 11.7.0 · wcpp · MailMan · SshOpenTunnel · method · since 9.5.0.50` ```cpp bool SshOpenTunnel(const wchar_t *sshHostname, int sshPort); ``` Connects to an SSH server and opens an SSH tunnel for MailMan's SMTP or POP3 connections. The `sshHostname` argument is the hostname or IP address of the SSH server. The `sshPort` argument is the SSH port, typically `22`. An SSH tunneling session begins by calling `SshOpenTunnel`, followed by either `SshAuthenticatePw` or `SshAuthenticatePk` to authenticate. After the SSH tunnel is established and authenticated, MailMan's underlying SMTP or POP3 communication uses the SSH tunnel. No other programming changes are required beyond the initial tunnel setup calls. Returns true for success, false for failure. Async variant: `SshOpenTunnelAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.UseCertVault `Chilkat 11.7.0 · wcpp · MailMan · UseCertVault · method · since 9.5.0.40` ```cpp bool UseCertVault(CkXmlCertVaultW &vault); ``` Provides an XML certificate vault to be searched for certificates and private keys when MailMan performs operations such as encryption, decryption, signing, or signature verification. Unlike PFX sources added with `AddPfxSourceData`, `AddPfxSourceBd`, or `AddPfxSourceFile`, only one XML certificate vault can be used at a time. If `UseCertVault` is called more than once, the most recent vault replaces the previously supplied vault. Returns true for success, false for failure. ### MailMan.UseSsh `Chilkat 11.7.0 · wcpp · MailMan · UseSsh · method · since 9.5.0.55` ```cpp bool UseSsh(CkSshW &ssh); ``` Configures MailMan to use an existing SSH tunnel provided by the `Ssh` object in `ssh` for SMTP and POP3 connections. This method is similar to `UseSshTunnel`, except the SSH tunnel is supplied in `ssh` rather than a `Socket` object. Sharing an existing SSH tunnel is useful when multiple objects need to communicate through the same SSH connection. SSH supports multiple logical channels within one tunnel, so SMTP and POP3 connections can exist simultaneously as separate SSH channels. Returns true for success, false for failure. ### MailMan.UseSshTunnel `Chilkat 11.7.0 · wcpp · MailMan · UseSshTunnel · method · since 9.5.0.50` ```cpp bool UseSshTunnel(CkSocketW &tunnel); ``` Configures MailMan to use an existing SSH tunnel provided by a `Socket` object for SMTP and POP3 connections. Sharing an existing SSH tunnel is useful when multiple objects need to communicate through the same SSH connection. SSH supports multiple logical channels within one tunnel, so SMTP and POP3 connections can exist simultaneously as separate SSH channels. Returns true for success, false for failure. ### MailMan.VerifyPopConnection `Chilkat 11.7.0 · wcpp · MailMan · VerifyPopConnection · method` ```cpp bool VerifyPopConnection(void); ``` Tests whether a TCP/IP connection can be established with the configured POP3 server. This method verifies connectivity only. It does not prove that POP3 authentication will succeed. Use `VerifyPopLogin` to test both connection and login. Returns `true` if the connection can be established, otherwise returns `false`. Async variant: `VerifyPopConnectionAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.VerifyPopLogin `Chilkat 11.7.0 · wcpp · MailMan · VerifyPopLogin · method` ```cpp bool VerifyPopLogin(void); ``` Tests whether Chilkat can connect to the configured POP3 server and successfully log in using the current POP3 authentication settings. Use this method to diagnose whether POP3 credentials and authentication settings are correct. If only the TCP/IP connection needs to be tested, use `VerifyPopConnection`. Returns `true` if the connection and login succeed, otherwise returns `false`. Async variant: `VerifyPopLoginAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.VerifyRecips `Chilkat 11.7.0 · wcpp · MailMan · VerifyRecips · method` ```cpp bool VerifyRecips(CkEmailW &email, CkStringArrayW &badAddrs); ``` **Full documentation for this method (same in every language):** [Validating Email Addresses](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/validating_email_addresses.md) Begins the SMTP send process for `email`, sends the recipient addresses to the SMTP server, and then aborts before sending the message content. Recipient addresses rejected by the SMTP server are returned in `badAddrs`. This method can help identify addresses the SMTP server rejects during the SMTP `RCPT TO` stage. However, it cannot guarantee that all accepted addresses are valid. SMTP servers often accept addresses outside their own domains and only later discover delivery failures when relaying or delivering to the final destination. Returns true for success, false for failure. Async variant: `VerifyRecipsAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.VerifySmtpConnection `Chilkat 11.7.0 · wcpp · MailMan · VerifySmtpConnection · method` ```cpp bool VerifySmtpConnection(void); ``` Tests whether a TCP/IP connection can be established with the configured SMTP server. This method verifies connectivity only. It does not prove that SMTP authentication will succeed. Use `VerifySmtpLogin` to test both connection and login. Returns `true` if the connection can be established, otherwise returns `false`. Async variant: `VerifySmtpConnectionAsync` — same arguments, returns a `Task` (see Async variants below). ### MailMan.VerifySmtpLogin `Chilkat 11.7.0 · wcpp · MailMan · VerifySmtpLogin · method` ```cpp bool VerifySmtpLogin(void); ``` Tests whether Chilkat can connect to the configured SMTP server and successfully authenticate using the current SMTP authentication settings. Use this method to diagnose whether SMTP credentials and authentication settings are correct. If only the TCP/IP connection needs to be tested, use `VerifySmtpConnection`. Returns `true` if the connection and login succeed, otherwise returns `false`. Async variant: `VerifySmtpLoginAsync` — same arguments, returns a `Task` (see Async variants below). ## Events and callbacks To receive events, define your own class that inherits from CkMailManProgressW and override just the methods you want to handle. The base class provides an empty implementation of every method, so anything you don't override is simply ignored. Then create an instance of your class and pass its address to the object's put_EventCallbackObject method. From that point on, the object calls your methods as the work proceeds. Be sure the callback object stays in scope for as long as it is in use. **For example:** ```cpp CkMailManW mailman; MyMailManProgressW callbackObj; mailman.put_EventCallbackObject(&callbackObj); ``` **MyMailManProgressW example:** ```cpp #include "CkMailManProgressW.h" class MyMailManProgressW : public CkMailManProgressW { public: MyMailManProgressW(); virtual ~MyMailManProgressW(); void AbortCheck(bool *abort); void EmailReceived(const wchar_t *subject, const wchar_t *fromAddr, const wchar_t *fromName, const wchar_t *returnPath, const wchar_t *dateStr, const wchar_t *uidl, int sizeInBytes); void PercentDone(int pctDone, bool *abort); void ProgressInfo(const wchar_t *name, const wchar_t *value); void TaskCompleted(CkTaskW &task); }; ``` ### MailMan.AbortCheck (event) `Chilkat 11.7.0 · wcpp · MailMan · AbortCheck · event` ```cpp void AbortCheck(bool *abort); ``` Enables a method call to be aborted by triggering the AbortCheck event at intervals defined by the `HeartbeatMs` property. If HeartbeatMs is set to its default value of 0, no events will occur. For instance, set HeartbeatMs to 200 to trigger 5 AbortCheck events per second. ### MailMan.PercentDone (event) `Chilkat 11.7.0 · wcpp · MailMan · PercentDone · event` ```cpp void PercentDone(int pctDone, bool *abort); ``` This provides the percentage completion for any method involving network communications or time-consuming processing, assuming the progress can be measured as a percentage. This event is triggered only when it's possible and logical to express the operation's progress as a percentage. The `pctDone` argument will range from 1 to 100. For methods that finish quickly, the number of PercentDone callbacks may vary, but the final callback will have `pctDone` equal to 100. For longer operations, callbacks will not exceed one per percentage point (e.g., 1, 2, 3, ..., 98, 99, 100). The PercentDone callback also acts as an `AbortCheck` event. For fast methods where PercentDone fires, an AbortCheck event may not trigger since the PercentDone callback already provides an opportunity to abort. For longer operations, where time between PercentDone callbacks is extended, AbortCheck callbacks enable more responsive operation termination. To abort the operation, set the `abort` output argument to `true`. This will cause the method to terminate and return a failure status or corresponding failure value. ### MailMan.ProgressInfo (event) `Chilkat 11.7.0 · wcpp · MailMan · ProgressInfo · event` ```cpp void ProgressInfo(const wchar_t *name, const wchar_t *value); ``` This event callback provides `tag name`/value pairs that detail what occurs during a method call. To discover existing tag names, create code to handle the event, emit the pairs, and review them. Most tag names are self-explanatory. Note: Some Chilkat methods don't fire any ProgressInfo events. ### MailMan.TaskCompleted (event) `Chilkat 11.7.0 · wcpp · MailMan · TaskCompleted · event` ```cpp void TaskCompleted(CkTaskW &task); ``` Called from the background thread when an asynchronous task completes. ## Async variants Each returns a `Task` instead of the result and takes the same arguments as the synchronous method; run the task, wait for `Finished`, then read the result from the task. No new Async methods are added from 11.7.0 on. ```cpp CkTaskW *CheckMailAsync(void); CkTaskW *CloseSmtpConnectionAsync(void); CkTaskW *DeleteBundleAsync(CkEmailBundleW &emailBundle); CkTaskW *DeleteByMsgnumAsync(int msgnum); CkTaskW *DeleteByUidlAsync(const wchar_t *uidl); CkTaskW *DeleteEmailAsync(CkEmailW &email); CkTaskW *DeleteUidlSetAsync(CkStringTableW &stUidls); CkTaskW *FetchAllAsync(bool keepOnServer, bool headersOnly, int numBodyLines, CkEmailBundleW &bundle); CkTaskW *FetchByUidlAsync(const wchar_t *uidl, bool headerOnly, int numBodyLines, CkEmailW &email); CkTaskW *FetchFullAsync(CkEmailW &partialEmail, CkEmailW &fullEmail); CkTaskW *FetchMimeBdAsync(const wchar_t *uidl, CkBinDataW &mimeData); CkTaskW *FetchMimeByMsgnumBdAsync(int msgnum, CkBinDataW &bd); CkTaskW *FetchOneAsync(bool headerOnly, int numBodyLines, int msgNum, CkEmailW &email); CkTaskW *FetchRangeAsync(bool keepOnServer, bool headersOnly, int numBodyLines, int startIndex, int endIndex, CkEmailBundleW &bundle); CkTaskW *FetchUidlsAsync(CkStringTableW &uidls); CkTaskW *FetchUidlSetAsync(CkStringTableW &uidls, bool headersOnly, int numBodyLines, CkEmailBundleW &bundle); CkTaskW *GetMailboxCountAsync(void); CkTaskW *GetMailboxInfoXmlAsync(void); CkTaskW *GetMailboxSizeAsync(void); CkTaskW *GetSizeByUidlAsync(const wchar_t *uidl); CkTaskW *IsSmtpDsnCapableAsync(void); CkTaskW *OpenSmtpConnectionAsync(void); CkTaskW *Pop3AuthenticateAsync(void); CkTaskW *Pop3BeginSessionAsync(void); CkTaskW *Pop3ConnectAsync(void); CkTaskW *Pop3EndSessionAsync(void); CkTaskW *Pop3EndSessionNoQuitAsync(void); CkTaskW *Pop3NoopAsync(void); CkTaskW *Pop3ResetAsync(void); CkTaskW *Pop3SendRawCommandAsync(const wchar_t *command, const wchar_t *charset); CkTaskW *QuickSendAsync(const wchar_t *fromAddr, const wchar_t *toAddr, const wchar_t *subject, const wchar_t *body, const wchar_t *smtpServer); CkTaskW *SendBundleAsync(CkEmailBundleW &bundle); CkTaskW *SendEmailAsync(CkEmailW &email); CkTaskW *SendMimeAsync(const wchar_t *fromAddr, const wchar_t *recipients, const wchar_t *mimeSource); CkTaskW *SendMimeBdAsync(const wchar_t *fromAddr, const wchar_t *recipients, CkBinDataW &mimeData); CkTaskW *SmtpAuthenticateAsync(void); CkTaskW *SmtpConnectAsync(void); CkTaskW *SmtpNoopAsync(void); CkTaskW *SmtpResetAsync(void); CkTaskW *SmtpSendRawCommandAsync(const wchar_t *command, const wchar_t *charset, bool bEncodeBase64); CkTaskW *SshAuthenticatePkAsync(const wchar_t *sshLogin, CkSshKeyW &privKey); CkTaskW *SshAuthenticatePwAsync(const wchar_t *sshLogin, const wchar_t *sshPassword); CkTaskW *SshCloseTunnelAsync(void); CkTaskW *SshOpenTunnelAsync(const wchar_t *sshHostname, int sshPort); CkTaskW *VerifyPopConnectionAsync(void); CkTaskW *VerifyPopLoginAsync(void); CkTaskW *VerifyRecipsAsync(CkEmailW &email, CkStringArrayW &badAddrs); CkTaskW *VerifySmtpConnectionAsync(void); CkTaskW *VerifySmtpLoginAsync(void); ``` ## Deprecated members — do not use in new code | Member | Kind | Deprecated in | Use instead | |---|---|---|---| | `SendIndividual` | property | before 11.6.1 | — | | `AddPfxSourceData` | method | before 11.6.1 | — | | `ClearBadEmailAddresses` | method | before 11.6.1 | — | | `CopyMail` | method | before 11.6.1 | `FetchAll` | | `DeleteMultiple` | method | before 11.6.1 | `DeleteUidlSet` | | `FetchByMsgnum` | method | before 11.6.1 | `FetchOne` | | `FetchEmail` | method | before 11.6.1 | `FetchByUidl` | | `FetchMime` | method | before 11.6.1 | — | | `FetchMimeByMsgnum` | method | before 11.6.1 | — | | `FetchMultiple` | method | before 11.6.1 | `FetchUidlSet` | | `FetchMultipleHeaders` | method | before 11.6.1 | `FetchUidlSet` | | `FetchMultipleMime` | method | before 11.6.1 | `FetchMimeBd` | | `FetchSingleHeader` | method | before 11.6.1 | `FetchOne` | | `FetchSingleHeaderByUidl` | method | before 11.6.1 | `FetchByUidl` | | `GetAllHeaders` | method | before 11.6.1 | `FetchAll` | | `GetBadEmailAddrs` | method | before 11.6.1 | — | | `GetFullEmail` | method | before 11.6.1 | `FetchFull` | | `GetHeaders` | method | before 11.6.1 | `FetchRange` | | `GetPop3SslServerCert` | method | before 11.6.1 | `GetServerCert` | | `GetSentToEmailAddrs` | method | before 11.6.1 | — | | `GetSmtpSslServerCert` | method | before 11.6.1 | `GetServerCert` | | `GetUidls` | method | before 11.6.1 | `FetchUidls` | | `LastJsonData` | method | before 11.6.1 | — | | `LoadEml` | method | before 11.6.1 | — | | `LoadMbx` | method | before 11.6.1 | `LoadMbxFile` | | `LoadMime` | method | before 11.6.1 | — | | `LoadXmlEmail` | method | before 11.6.1 | — | | `LoadXmlEmailString` | method | before 11.6.1 | — | | `LoadXmlFile` | method | before 11.6.1 | — | | `LoadXmlString` | method | before 11.6.1 | — | | `MxLookup` | method | before 11.6.1 | — | | `MxLookupAll` | method | before 11.6.1 | — | | `RenderToMimeBytes` | method | before 11.6.1 | — | | `SendMimeBytes` | method | before 11.6.1 | — | | `SendMimeToList` | method | before 11.6.1 | — | | `TransferMail` | method | before 11.6.1 | `FetchAll` | | `TransferMultipleMime` | method | before 11.6.1 | — | ## Related classes [`BinData`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wcpp/classes/BinData.md), [`Cert`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wcpp/classes/Cert.md), [`Email`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wcpp/classes/Email.md), [`EmailBundle`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wcpp/classes/EmailBundle.md), [`JsonObject`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wcpp/classes/JsonObject.md), [`PrivateKey`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wcpp/classes/PrivateKey.md), [`SecureString`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wcpp/classes/SecureString.md), [`Socket`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wcpp/classes/Socket.md), [`Ssh`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wcpp/classes/Ssh.md), [`SshKey`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wcpp/classes/SshKey.md), [`StringArray`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wcpp/classes/StringArray.md), [`StringBuilder`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wcpp/classes/StringBuilder.md), [`StringTable`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wcpp/classes/StringTable.md), [`Task`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wcpp/classes/Task.md), [`XmlCertVault`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wcpp/classes/XmlCertVault.md)