June 18, 2022



New features


•  Added RDOExchangeMailboxStore.MakeEwsRequest and RDOExchangeAccount.MakeEwsRequest methods. These methods are similar to the mailbox.MakeEwsRequestAsync method exposed for the Web (JS) addins by Outlook. Unlike the JavaScript equivalent, MakeEwsRequest in Redemption is synchronous and is expected to run on a secondary thread (see here for more on using Redemption in secondary threads). There are no limitation  which EWS call can be made.
Note that MakeEwsRequest is designed to work in COM (VSTO) addins or Outlook VBA as it intercepts EWS requests made by Outlook itself to extract the credentials. It will work outside of the outlook.exe process only if Outlook cached the credentials or if RDOSession.LogonHostedExchangeMailbox was used to connect to Exchange (which requires explicit credentials). Also note that it is expected that the parent RDOSession object is created well ahead of time (e.g. when the COM/VSTO addin is loaded) prior to calling MakeEwsRequest to allow Redemption sufficient time to collect the credentials after Outlook makes its own EWS calls.


payload = _

"<?xml version=""1.0"" encoding=""utf-8""?>" & _

"<soap:Envelope xmlns:soap=""http://schemas.xmlsoap.org/soap/envelope/""" & _

"               xmlns:t=""http://schemas.microsoft.com/exchange/services/2006/types"">" & _

"  <soap:Header><t:RequestServerVersion Version=""Exchange2007_SP1""/></soap:Header>" & _

"  <soap:Body>" & _

"    <GetDelegate xmlns=""http://schemas.microsoft.com/exchange/services/2006/messages""" & _

"                 xmlns:t=""http://schemas.microsoft.com/exchange/services/2006/types""" & _

"                 IncludePermissions=""true"">" & _

"      <Mailbox>" & _

"        <t:EmailAddress>" & smtpAddress & "</t:EmailAddress>" & _

"      </Mailbox>" & _

"    </GetDelegate>" & _

"  </soap:Body>" & _



set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

set defaultAccount = Session.Accounts.GetOrder(1).Item(1)

if TypeName(defaultAccount) = "RDOExchangeAccount" Then

  MsgBox "This message box simulates a delay between creating RDOSession object " & _

         "and a call to MakeEwsRequest to allow it to intercept EWS calls made by Outlook"

  Session.CacheAutoDiscoverXml smtpAddress, Application.Session.AutoDiscoverXml 'speed things up

  reply = defaultAccount.MakeEwsRequest(payload)

  MsgBox reply

End If


Bug fixes


•   If used inside outlook.exe process space (from a COM/VSTO addin or Outlook VBA), Redemption could cause Exchange Server connection problems if Microsoft Viva was also installed.


•   For some Outlook profiles, RDOSession.PickFolder and RDOSelectFoldersDialog.Display showed an empty treeview with no stores or folders.


•   Creating a new Outlook client rule using RDOClientRules.Create in a message store without existing rules prevented Outlook from using, opening, or displaying the rules.


•   For some attachments created under macOS (with MIME type multipart/appledouble), calling RDOAttachment.SaveAsFile or saving the message in the MIME format (RDOMail.SaveAs(..., olRfc822)) could corrupt the file attachment data.


•   Importing appointments in the iCal format could sometimes fail to import the appointment subject. This is a version 6.1 specific problem.


•   Importing MIME (EML) files with recipients/sender that only contain an address (but no name) could leave "<" and ">" as parts of the email address. This is a version 6.1 specific problem.


•   Setting To/CC/BCC properties to a value that included an SMTP address with the ";" character (e.g. "user;name"domain.demo) inserted an erroneous recipient.


•   Accessing RDOExchangeMailboxStore.Delegates collection raised an exception if one or more delegates were invalid (e.g. missing from the Active Directory). The updated version raises an exception only when accessing the invalid delegate's properties; other valid delegates can still be accessed.


•   RDOStores.AddDelegateExchangeMailBoxStore could sometimes fail with authentication error.


•   Messages with a signature added with RDOSignature.ApplyTo, could have the signature duplicated if the message was later displayed and the user decides to switch to a different signature.


•   Importing some Fast Transfer Stream files (RDOMail.Import(..., olFTS)) could raise an exception "80070057 Error in ScDupPropset: MAPI_E_INVALID_PARAMETER"


•   Calling RDOStore.GetDefaultFolder could fail if a previous call to  RDOStore.GetDefaultFolder failed even if RDOFolder2.SetAsDefaultFolder was called after the first call to GetDefaultFolder.


•   Accessing RDOMail.HTMLBody property of an MSG file could sometimes include "~" instead of a non-breaking space.


•   If RDOSignature.ApplyTo was used to insert a signature with an image, the message displayed an attachment icon, even if there were no other attachments besides the the signature image(s).


•   Using RDOExchangeMailboxStore.Rules or RDOFolder2.Rules could sometimes fail with "IMAPIFolder.OpenProperty(PR_RULES_TABLE): MAPI_E_CALL_FAILED" exception when using cached mode profile.




November 24, 2021



New features


•  All Safe*Item objects (SafeMailItem, SafeContactItem, etc.) now expose new MarkSaved method. The method tricks the original OOM object assigned to the Item property into assuming that there are no pending changes to be saved. Closing the Outlook item after calling MarkSaved will not display the save prompt.

private void Inspector_Close()


    SafeMailItem smi = new SafeMailItem();

    smi.Item = _inspector.CurrentItem;

    //discard pending changes to let

    //the inspector close without a prompt




•  Added RDOPSTStore.OverridePSTDisableGrow method that allows to temporarily disable PSTDisableGrow policy on the per-PST file basis.
Note that PSTDisableGrowAllowAuthenticodeOverrides registry value must be set prior to calling RDOPSTStore.OverridePSTDisableGrow method since the parent registry key requires elevated rights even though is is a subkey of HKEY_CURRENT_USER.

set session = CreateObject("Redemption.RDOSession")

session.MAPIOBJECT = Application.Session.MAPIOBJECT

set pstStore = session.GetStoreFromID(Application.ActiveExplorer.CurrentFolder.Store.StoreID)



•  Added RDOIMAPAccount.DoNotSaveSentItems / MarkForDeletion / EnablePurgeOnSwitch properties exposed by the IMAP4 accounts..


Bug fixes


•   RDOFolder2.GetActivitiesForTimeRange and RDORecurrencePattern.GetOccurrence could sometimes return an extraneous weekly occurrence on a day preceding or following an actual occurrence.


•   RDOSession.LogonHostedExchangeMailbox could sometimes fail to open the address book.


•   RDOClientRule.Exceptions collection always returned generic RDOClientRuleCondition objects instead of specific objects corresponding to the exception's type (e.g. RDOClientTextRuleCondition or IRDOClientSensitivityRuleCondition).


•   RDOClientRule.IsLocalRule property returned wrong value in most cases.


•   RDOClientRules.Import failed to raise an exception if the specified file did no exist.


•   MIME export (RDOMail.SaveAs(..., olRfc822)) failed to properly export Unicode sender name if no SMTP address was available (e.g. when processing an MSG file with an EX address and no Exchange Server in the active MAPI session)


•   Importing an EML file with an ICS MIME part imported sender/subject/recipients from the primary MIME message header rather than the ICS part. It also ignored the SENT-BY attribute of the ORGANIZER field.


•   Accessing RDOMail.HTMLBody property of an MSG file could sometimes return no data or corrupted data for the pure RTF or plain text messages.


•   Accessing RDOMail.HTMLBody property of an MSG file or saving the message in the MIME (EML) format file could sometimes corrupt HTML images.


•   Importing EML (MIME) files failed to set PR_SENDER_SEARCH_KEY and PR_SENT_REPRESENTING_SEARCH_KEY MAPI properties.



August 22, 2021



New features


•  Client-side rules are now supported (Exchange Server-side rules have been supported since version 4.3).
Over 30 new objects exposing rules, actions, conditions, and exceptions available (or previously available) in Outlook.
Access client-side rules on the store basis (Exchange, PST, IMAP4, etc. through the RDOStore2.ClientRules property), export rules (RDOClientRules.Export), open standalone RWZ files (RDOSession.OpenRulesFile), or import RWZ files (RDOClientRules.Import) into a store. 

The example below creates a new client rule that moves received messages from a particular sender unless the subject contains predefined keywords.

set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

set colRules = Session.Stores.DefaultStore.ClientRules

Set oRule = colRules.Create("Test rule", olRuleReceive)

'Specify the condition in a ToOrFromRuleCondition object

'Condition is if the message is sent by "test@dimastr.com"

Set oFromCondition = oRule.Conditions.From

With oFromCondition

  .Enabled = True

  .Recipients.AddEx "Joe The User", "test@dimastr.com", "SMTP"

End With

'Specify the action in a MoveOrCopyRuleAction object

'Action is to move the message to the target folder

set oMoveTarget = Session.Stores.DefaultFolder(olFolderInbox).Folders.OpenOrAdd("Test folder")

Set oMoveRuleAction = oRule.Actions.MoveToFolder

With oMoveRuleAction

  .Enabled = True

  .Folder = oMoveTarget

End With

'Specify the exception condition for the subject in a TextRuleCondition object

'Exception condition is if the subject contains "fun" or "chat"

Set oExceptSubject = oRule.Exceptions.Subject

With oExceptSubject

  .Enabled = True

  .Text = Array("fun", "chat")

End With

'Update the rules


The following example open a standalone RWZ file and lists all rule names. Note that opening RWZ file and processing its rules does not require an active MAPI session.

set Session = CreateObject("Redemption.RDOSession")

set rules = Session.OpenRulesFile("c:\temp\test.rwz")

for each ClientRule in rules

   Debug.Print ClientRule.Name


•  IRDOSearches.AddCustom method now allows to specify the excluded folders by passing an array of either the default folder ids (e.g. olFolderJunk), entry ids, or an RDOFolder objects. Previously, only default folder ids were accepted.

set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

set Store = Session.Stores.DefaultStore

set Searches = Store.Searches

strSQL = "Subject LIKE '%Test%' "

Dim excludedFolders(2)

excludedFolders(0) = olFolderJunk

set excludedFolders(1) = Store.GetDefaultFolder(olFolderJunk)

excludedFolders(2) = Store.GetDefaultFolder(olFolderJunk).EntryID

set NewSearch = Searches.AddCustom("Test", strSQL, Store.IPMRootFolder, true, excludedFolders)


Bug fixes


•   Reading HTMLBody property from RDOMail object created on top of an MSG file could be slow for messages with large HTML content. The current version is 6 - 7 times faster.


•   Some MSG files with binary 0x0 characters instead of spaces in the RTF body could cause HTMLBody property truncation.


•   RDOSession.GetArchiveMailbox often returned an error unless it was used inside an Outlook COM addin.


•   RDOExchangeMailboxStore.IsArchive property sometimes returned false for the stores returned by RDOSession.GetArchiveMailbox


•   Importing some FTS files (Fast Transfer Stream produced by the ExportItem EWS verb) using RDOMail.Import(..., olFTS), could sometimes raise "Unexpected Property Type" exception.


•   Saving a message in the olRfc822 format (when Redemption first tries olRfc822_Outlook if available and then switches to olRfc822_Redemption if not) if used from inside Outlook (COM addin or VBA script) could sometimes add extraneous data at the end of the EML file.


•   Importing a MIME message (olRfc822 format) could sometimes incorrectly parse Received MIME header resulting in a wrong value of the RDOMail.ReceivedTime property.


•   Importing a MIME message with a plain text part without the Content-Type MIME header resulted in a missing message body.


•   RDOSession.ShowAddressBook method and RDOSelectNamesDialog object did not correctly show Unicode title and To/CC/BCC labels.


•   RDOSession.ShowAddressBook method and RDOSelectNamesDialog object sometimes retuned RDORecipients collection with the string properties in the ANSI format (PT_STRING8) rather than Unicode (PT_UNICODE), resulting in Unicode character corruption.


•   Saving message attachments using Attachment.SaveAsFile (SafeMailItem only, RDOMail object functioned properly) raised "Unknown attachment type (PR_ATTACH_METHOD): 7" exception when processing the new cloud attachments (olByWebReference = 7).


•   Saving in the MIME (EML) format using Redemption MIME converter (olRfc822_Redemption) did not export the In-Reply-To and References MIME headers for the Outlook messages without the PR_TRANSPORT_MESSAGE_HEADERS property (such as draft unsent messages).


•   RDOAttachment.Hidden property could erroneously return False for the image attachments that referred  to web images with a url containing HTTP parameters.




April 10, 2021



New features


•  Added RDOContact.Email1SmtpAddress / Email2SmtpAddress  / Email3SmtpAddress properties that return and set contact's SMTP addresses explicitly since Email1Address / Email2Address  / Email3Address properties can return "EX" type addresses for the contacts added from Exchange GAL. These properties are guaranteed to always return SMTP addresses (if available).


•  Added new export format - olRfc822_Tnef (1036), which creates a MIME formatted message with all MAPI-specific properties preserved in an infamous winmail.dat attachment.

rdoSaveAsType exportFormat = rdoSaveAsType.olRFC822_Redemption;

//Save in the MIME format.

//If the message is anything but a regular message,

//or is in the RTF format, or has any user properties set,

//export with a TNEF file attachment preserving all MAPI properties

if ((msg.BodyFormat == (int)rdoBodyFormat.olFormatRichText) ||

    (msg.MessageClass != "IPM.Note") ||

    (msg.UserProperties.Count > 0))


    exportFormat = rdoSaveAsType.olRFC822_Tnef;


msg.SaveAs(@"c:\temp\test.eml", exportFormat);


Bug fixes


•   Using Redemption inside Outlook (COM addin or VBA) could sometimes interfere with Outlook's connection to an Exchange Server by forcing basic authentication for the connections using authentication tokens.


•  After passing an unsaved Outlook item to RDOSession.GetRDOObjectFromOutlookObject, its Saved property could sometimes return true even if the item was not saved.


•  Importing a MIME (EML) file (RDOMail.Import(..., 1031)) with a non-standard line length (e.g. 77 characters instead of 76) in base-64 encoded MIME parts, Redemption could sometimes corrupt the attachments.


•  Importing a MIME (EML) file (RDOMail.Import(..., 1031)) with the topmost Received MIME header without a date-time stamp produced RDOMail.ReceivedTime with the value of 1/1/1980.


•  RDOSignature.ApplyTo did not correctly handle signatures with UTF-16 encoded HTML files.


•  Importing some MIME (EML) files with specifically formatted HTML stylesheets with XML-encoded special characters into standalone MSG file could produces messages unreadable by Outlook.


•  RDOFolders.OpenOrAddSearchFolder / AddSearchFolder  raised  "Could not convert variant of type (Error) into type (Boolean)" exception.



January 9, 2021



New features


•   Added SMTP_RememberPassword property to the POP3 and IMAP4 account objects. POP3_RememberPassword and IMAP_RememberPassword properties have already been previously exposed.


•   Added RDOTemplates object (retuned by RDOSession.Templates and RDOExchangeMailboxStore.Templates) that exposes Outlook templates (Exchange specific). You can add, read, update, and delete Exchange templates. 

RDOSession session = new RDOSession();

session.MAPIOBJECT =


RDOTemplates templates = session.Templates;

RDOTemplate template1 = templates.Add(

    "See report",

    "Please see the attached last quarter report.");

RDOTemplate template2 = templates.Add(

    "Submit support ticket",

    @"Please submit support ticket at<br>"+

    "<a href=""https://www.mycompany.demo/support"">" +


templates.Save(); //can also call RDOTemplate.Save



Bug fixes


•  Using RDOSession.GetRDOObjectFromOutlookObject  or Safe*Item against an unsaved message could prevent that message from ever being saved and could raise an exception (Exceed maximum allowed of hooks) after GetRDOObjectFromOutlookObject was called a few times.


•  Saving a plain text message in the HTML format (RDOMail.SaveAs(..., olHTML)) could sometimes produce a file without the message body with the message headers only.


•  Reading RDOMail.HTMLBody property or saving in the HTML format could produce "Unbalanced stack or queue operation" exception for some corrupted messages with invalid RTF-encoded HTML body.


•  RDOFolder2.GetActivitiesForTimeRange and RDORecurrencePattern.GetOccurrence did not correctly handle locales where the week starts on Monday (rather than Sunday) when calculating weekly recurrence patterns.


•  RDOAddressEntry.GetPicture  method sometimes returned null in the cached mode even if the picture was available on the server.


•  Releasing a Redemption object (such as SafeMailItem or RDOSession) in the Explorer.InlineResponseClose event could sometimes make Outlook crash (it would attempt to close the inline response editor twice). This problem is also fixed in Outlook 16.0.13617.10000, the updated version of Redemption will work around the problem in the older versions of Outlook as well.


•  Saving an appointment or a meeting request/response in the MIME format now adds both plain text and text/calendar parts. Previously, the EML file contained only the text/calendar part.


•  Saving a message with reply recipients in the MIME (EML) format could corrupt the Reply-To MIME header if the entries were GAL users rather than one-off SMTP entries.


•  Outlook Object Model compatibility: setting RDOAppointmentItem.End property (without also setting the Start property) adjusted the Start property as well (leaving Duration intact). Doing the same in OOM left the Start property the same (thus only affecting Duration).


•  RedemptionLoader (all languages) was updated to include the SafeApplication object introduced in version 5.25.



November 1, 2020



New features


•   Added RDOFolders.OpenOrAdd and RDOFolders.OpenOrAddSearchFolder methods that open an existing folder (if it exists) or create a new one.  These methods are more efficient (they are implemented on the store provider level) than the usual practice of first attempting to call RDOFolders.Add, catch the exception, and then retrieve the existing folder by name using RDOFolders.Item (or RDOFolders[]).  See the sample script below for an example.


•   Added support for the favorite folders with the RDOSession.Favorites and RDOStore2.Favorites collections.
RDOFavorites object allows to enumerate existing favorite folders as well as add, edit, and delete folder favorites .

Set MySession = CreateObject("Redemption.RDOSession")

MySession.MAPIOBJECT = Application.Session.MAPIOBJECT

Set Inbox = MySession.GetDefaultFolder(olFolderInbox)

'open or add a folder

set NewFolder = Inbox.Folders.OpenOrAdd("The Favorite Folder")

set Favorites = MySession.Favorites

'retrieve an existing favorite object by the folder object

'can also be retrieved by name or index

set Favorite = Favorites.Item(NewFolder)

if Favorite Is Nothing Then

  set Favorite = Favorites.Add(NewFolder)

End If

Outlook for iOS Favorites


•   New SafeApplication object. Like other Safe* objects, it exposes functionality not exposed through the native OOM object (Outlook.Application). ApplicationPath and Bitness properties are exposed as well as BeforePrint event.

Note that unlike the Safe*Item objects, SafeApplication object is not MAPI based and hence can be used even if the bitness of the calling process (and Redemption) does not match the bitness of Outlook.
The example below intercepts the BeforePrint event (not exposed in the Outlook Object Model) and displays a warning if it finds a string that looks like a Social Security Number in the body of the message to be printed.

private Redemption.SafeApplication _safeApplication;

private Outlook.Application _application;


public TestForm()


    _application = new Outlook.Application();

    _safeApplication = new SafeApplication();

    _safeApplication.Item = _application;

    _safeApplication.BeforePrint += _safeApplication_BeforePrint;



private void _safeApplication_BeforePrint(object Item)


    Outlook.MailItem mailItem = Item as Outlook.MailItem;

    if (mailItem != null)


        string body = mailItem.Body;

        body = body.Replace("\r", "").Replace("\n", "");

        Match ssnMatch = new Regex(@"(?<!\d)\d{3}([- ])\d{2}\1\d{4}(?!\d)").Match(body);

        if (ssnMatch.Success)


            //unfortunately, the event is not cancelable

            MessageBox.Show("The message you are about to print appears to contain a "+

                            "Social Security Number.\n" +

                            "Please destroy the printout when you are done.",

                            "Printing from Outlook",







•   Added RDOExchangeMailboxStore.GetOutOfOfficeAssistantWithCredentials method that allows to explicitly specify the credentials to be used by the returned RDOOutOfOfficeAssistant object. for its EWS calls.


•   Added RDOExchangeMailboxStore.PrimaryStore and RDOExchangePublicFoldersStore.PrimaryStore properties.
The property returns an instance of the RDOExchangeMailboxStore object that represents the primary Exchange mailbox in the given Exchange account. E.g.. if an Exchange account has 4 stores (primary mailbox M1, delegate mailboxes D1 and D2, and a Public Folders store P1), PrimaryStore property for all these stores will return the primary mailbox M1.

The property was introduced to avoid the need to access RDOStore.StoreAccount property.  RDOAccount object returned by RDOStore.StoreAccount. wraps the IOlkAccount MAPI object, which has thread affinity and can raise an exception if accessed on a secondary thread. To avoid the cross-thread access exceptions, one can, for example, use RDOExchangeMailboxStore.PrimaryStore.Owner.SMTPAddress in place of RDOExchangeMailboxStore.StoreAccount.CurrentUser.SMTPAddress.



Bug fixes


•   Releasing an instance of the RDOMail object created on top of an MSG file (RDOSession.GetMessageFromMsgFile / CreateMessageFromMsgFile) in a 64 bit application (including Outlook) could sometimes cause a crash.


•   Using RDOSession.GetRDOObjectFromOutlookObject  against an inline response message (Explorer.ActiveInlineResponse) could sometimes prevent Outlook from correctly updating the original message being replied to (e.g. the reply icon might be missing).


•   Reading RDOMail.HTMLBody property or exporting to the MIME  or MHTML file format from a message created on top of an MSG file (RDOSession.GetMessageFromMsgFile / CreateMessageFromMsgFile ) could sometimes corrupt Unicode / Emoji characters and/or HTML styles and list bullets as well as insert superfluous line breaks.


•   Simultaneously exporting multiple RTF-formatted messages to the MIME or MHTML formats in parallel threads could sometimes cause a lock.


•   Importing or exporting meeting requests or responses  (VCALENDAR) in the MIME or iCal formats could sometimes skip location, start, and recipients as well import the the calendar item as RDOAppointmentItem rather than RDOMeetingItem.


•   Saving a message with a category in the HTML or MHTML format could produce a file that Microsoft Word showed without spaces between some words.


•   Setting the RDOMail.Sent property on an unsaved message after importing an MSG file using RDOMail.Import(..., olMsg) could sometimes raise the MAPI_E_COMPUTED exception.


•   Deleting a MAPI property using RDOMail.Fields[] (by setting it to null) on a message opened on top of an MSG file could sometimes leave the property intact if the property tag or the DASL property name did not specify the property type (e.g. "http://schemas.microsoft.com/mapi/string/{00020386-0000-0000-C000-000000000046}/content-type").


•   Documentation: RDOMail.CreateConversationIndex method was not documented.



August 1, 2020



New features


•   All Safe*Item objects (SafeMailItem, SafeContactItem, etc.) now expose the new Commit method. The method commits all pending changes that only exist in the Outlook internal cache without actually saving the item. Previously, an Outlook object must have been saved (by calling the Save method) to make pending changes made through the Outlook Object Model or Outlook UI visible to Extended MAPI and Redemption. Calling Save can be undesirable as it persists the item and makes it visible to the end user (e.g. in the Drafts folder), which can require the saved item to be tracked and deleted. Moreover, after calling Save ,Outlook would no longer prompt the user to save the pending changes.

Commit method preserves the unsaved state of the item while making all the latest changes visible to Redemption without actually persisting the item. If the item has no pending changes, Commit does nothing.

RDOSession.GetRDOObjectFromOutlookObject now also silently commits the changes at the time of the call before returning an RDO object corresponding to the Outlook object passed as the parameter.

'create new message, modify it without saving

set newMailItem = Application.CreateItem(0)


'access the newly created unsaved item using Redemption

set sItem = CreateObject("Redemption.SafeMailItem")

sItem.Item = newMailItem

'Redemption will not see the new recipient added above using OOM

MsgBox "# of recipients before Commit:" & vbCrLf & sItem.Recipients.Count

'after calling Commit, Redemption can see pending changes

'without saving the item


MsgBox "# of recipients after Commit:" & vbCrLf & sItem.Recipients.Count


•   Added RDOExchangeMailboxStore.IsArchive property. Since both delegate and archive Exchange stores are represented by the RDOExchangeMailboxStore object and the StoreKind property returns  skDelegateExchangeMailbox for both kinds of mailboxes, IsArchive property allows to distinguish between delegate mailboxes that belong to another user and an archive mailbox owned by the current user.

foreach (RDOStore store in session.Stores)


    RDOExchangeMailboxStore exStore = store as RDOExchangeMailboxStore;

    if ((exStore != null) && (!exStore.IsArchive))


        //only process primary and delegate Exchange mailboxes that are not online archives




        MessageBox.Show($"Skipped store '{store.Name}'");




•   Added RDOSession.GetCachedSharedMailbox and GetCachedSharedDefaultFolder methods that allow to access delegate stores and folders cached in the primary account's OST file.  Accessing shared stores is a lot more efficient then using RDOSession.GetSharedMailbox and GetSharedDefaultFolder methods as there is no reason to retrieve the auto-discover XML to construct the delegate store entry id and then open the store in the online mode.

//try to open a cached delegate Inbox first

//if that fails, try to open the online version

string mailboxName = "Redemption Support";

RDOFolder folder = null;



    folder = session.GetCachedSharedDefaultFolder(mailboxName, rdoDefaultFolders.olFolderInbox);


catch(COMException e)


    if (e.ErrorCode != (int)MAPICode.MAPI_E_NOT_FOUND) throw;



        //could not find the cached folder, try its online version

        folder = session.GetSharedDefaultFolder(mailboxName, rdoDefaultFolders.olFolderInbox);



RDOItems items = folder.Items;





•   Added RDOExchangeAccount.CachedDelegateStores property that lists all cached delegate stores in the given local Exchange account. The property is a subset of the RDOExchangeAccount.DelegateStores (which lists all delegate mailboxes in the account regardless of the cached/online state). The collection will be empty if delegate mailboxes are not cached or if there are no delegate mailboxes for the primary mailbox.

StringBuilder sb = new StringBuilder();

foreach (RDOAccount account in session.Accounts)


    RDOExchangeAccount exAccount = account as RDOExchangeAccount;

    if (exAccount != null)


        sb.AppendLine($"Exchange account {exAccount.Name}");

        foreach(IRDOStore store in exAccount.CachedDelegateStores)


            sb.AppendLine($"  cached delegate mailbox: {store.Name}");






•   Saving messages in the olMsgWithSummary format now exposes user properties (that is, custom properties added using RDOMail.UserProperties.Add or MailItem.UserProperties.Add) in the Custom tab of the file properties dialog in Windows Explorer.
olMsgWithSummary Windows Explorer


•   RDOSession.CacheAutodiscoverXml now allows to pass an Autodiscover Url instead of XML. The given url will later be used to retrieve the Autodiscover XML for the specified SMTP address whenever Redemption will need it (GetSharedDefaultMailbox, LogonHostedExchangeMailbox, etc.) thus avoiding the need to probe multiple Autodiscover urls (some of which can take a considerable amount of time to return or timeout).


•   Performance optimization - accessing standalone MSG file using IStream COM interface (RDOSession.CreateMessageFromIStream and RDOSession.GetMessageFromIStream) and importing/exporting using the IImportExport interface is now at least 50% faster.



Bug fixes


•   Saving in the MSG format (RDOMail.SaveAs(..., olMsg)) under Exchange Online could crash after June 30, 2020 (when Exchange online started stamping the messages with the KeyPhraseScores named property) if the MAPI message or its parent MAPI session had to be marshaled between different threads or different processes due to a bug in the MAPI marshalling code that could not handle PT_MV_I8 type MAPI properties. The current version of Redemption skips all PT_MV_I8 properties.


•   Setting RDOMail.Sent property after importing an MSG file using RDOMail.Import could raise Error in Set_Sent: MAPI_E_COMPUTED exception.
The same problem manifested itself in the RDOMail.CopyTo method (some properties could become corrupted, the attachments could be missing, etc.).


•   Saving a file in the olMsgWithSummary format caused Windows Explorer to display the Due Date column with a time offset instead of just date.


•   Creating Redemption objects (such as RDOSession) raised an exception (Catastrophic failure (Exception from HRESULT : 0x8000FFFF (E_UNEXPECTED))) under Outlook builds 16.0.12730.20206 and 16.0.12624.20520 due to an access violation in msmapi32.dll when calling MAPIInitialize.


•   Calling RDOSession.LogonHostedExchangeMailbox without credentials could result in an error.


•   When importing some EML files directly into MSG files, some HTML special characters could become corrupted and displayed in the resulting message, e.g. "&quot;" could becomes "quot;".


•   Exporting in the MIME format might not preserve the first line of the existing MIME headers (stored in the  PR_TRANSPORT_MESSAGE_HEADERS property) if the header was wrapped to the next line.


•   RDOSession.Stores.AddDelegateExchangeMailBoxStore sometimes failed to properly check if the given delegate mailbox has already been added to the profile, resulting in a duplicate store.


•   Accessing RDOStore2.QuickSteps in an IMAP4 or PST store could sometimes produce Error in IMAPIFolder.CreateFolder: MAPI_E_COLLISION exception.


•   RDOSelectFoldersDialog  on new profiles could sometimes display no stores or folders at all.


•   Saving some MSG files in the HTML or MHTML format, HTML list items could be prefixed with the "*" character.



April 22, 2020



New features


•   Added support for accessing MSG files using IStream interface rather than file (in case the data resides in memory etc. rather than file system). Use RDOSession.GetMessageFromIStream to open RDOMail object on top of an existing MSG-formatted IStream and RDOSession.CreateMessageFromIStream to create a brand new RDOMail object on top of an IStream COM object (see example below).

•   RDOMail object now allows to export/import to/from various file formats using IStream COM interface rather than the file system. Cast  RDOMail object (and objects derived from it, such as RDOContactItem, RDOAppointmentItem, etc.)  to the IImportExport interface .

//the example below uses a sample FileIStream class that implements the IStream COM interface

//Download FileIStream implementation.

//The code below is the same as

//  msg = session.CreateMessageFromMsgFile(@"c:\temp\647_ImportExport\new.msg");

//   msg.Import(@"c:\temp\647_ImportExport\sample.fts", rdoSaveAsType.olFTS);

//  msg.Save();

//Create a new MSG file - new file, r/w access

using (FileIStream msgFileStream = new FileIStream(@"c:\temp\ImportExport\new.msg", true, true))


    msg = session.CreateMessageFromIStream(msgFileStream as IStream);

    IImportExport importExport = msg as IImportExport;

    //open existing file with read-only access. You can create a memory based (or any other) stream instead<

    using (FileIStream fileStream = new FileIStream(@"c:\temp\ImportExport\sample.fts", false, false))


        importExport.Import(fileStream as IStream, rdoSaveAsType.olFTS);




    msg = null;



•   Added olMsgWithSummary (1035) file format. The format is fully compatible with the olMsg and olMsgUnicode formats, but adds a few dozen properties that Windows Explorer and SharePoint can understand and display as separate columns in the Details view.

Redemption adds properties common to all items (such as Subject, Date Received, Sender Name, etc.) as well as properties specific to contacts, tasks, and appointments.

olMsgWithSummary Windows Explorer

Set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

Set Item = Session.GetMessageFromID(Application.ActiveExplorer.Selection(1).EntryID)

Item.SaveAs "c:\temp\688\test.msg", &H40B


•   Added RDOAccounts.AddLDAPAccount method that allows to add an LDAP account to the active profile.

set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

set LdapAccount = Session.Accounts.AddLDAPAccount("Test LDAP Account", _

                                     "www.zflexldap.com", 389, _



•   Added RDOLDAPAccount.Password and EnableBrowsing properties.


•   Support for the store display order in the Outlook folder pane. Added RDOStore2.DisplayOrder property and RDOStores.GetDisplayOrder() method (returns RDOStoresDisplayOrderList collection, which allows to retrieve and set the order):

RDOPstStore store = session.Stores.AddPSTStore(@"c:\temp\important.pst", Missing.Value, "Most important store");

(store as RDOStore2).DisplayOrder = 2; //second store, show after the primary mailbox - the property is 1 based


•   RDOMail.SetProps method now allows to delete multiple properties as well as set multiple properties.  To delete a property, set its corresponding value in the values array to null or a variant of type error.


•   Expanded support for multiple Exchange accounts in a profile - previously, RDOAddressEntry.Details could sometimes display an empty details dialog, and some RDOAddressEntry properties could be empty, etc..
Added RDOExchangeAccount.GetAddressEntryFromID / GetAddressListFromID methods.
Address book objects returned from the message store objects (such as RDOMail.Sender / SentOnBehalfOf /etc.) are now Exchange account aware.


•   Improved handling of the non-standard values of the Importance, X-Priority, X-MSMail-Priority MIME headers and improved parsing of the non-standard SMTP addresses by the Redemption MIME importer.



Bug fixes


•   Using Redemption in an Outlook COM addin could sometimes cause Outlook to display authentication prompts for the RPC and RPC-over-HTTP Exchange Server connections.
It could also cause Outlook search to return no results until Outlook is restarted.


•   Redemption could sometimes cause an access violation on the parent process shutdown.


•   Some embedded message attachments could be skipped by the Redemption MIME importer.


•   RDOMail.HTMLBody property of a message opened on top of an MSG file (e.g. using RDOSession.GetMessageFromMsgFile) could sometimes include RTF control words , such as \intbl, \qc, etc. The same problem manifested itself when an EML (MIME) file was created from a standalone MSG file.


•   Importing MIME files with inline attachments and printing them using Outlook could result in Outlook listing embedded (inline) attachments alongside regular attachments in the printout.


•   Redemption MIME Importer could not correctly parse some "Content-Type" MIME header parameters.


•   Under Outlook 2007, RDOSession.Logoff sometimes caused "Not logged on. Please log on first" exception if RDOSession.Accounts collection was used prior to the call.


•   Saving in the Fast Transfer Stream (FTS) format (RDOMail.SaveAs(..., olFTS)) produced a exception for the messages with the by-value attachments if the PR_ATTACH_DATA_BIN MAPI property was missing.


•   Calling RDOSession.GetArchiveMailbox could raise an exception (Could not convert variant of type (Error) into type (Integer)) if the archive mailbox was located in a different domain.


•   RDOFolderSynchronizer.SyncItems could raise "Error in IExchangeExportChanges::Synchronize: MAPI_E_CALL_FAILED" exception if a restriction was used and it included a named property (such as Categories).


•   Setting RDOMail.Sender or RDOMail.SentOnBehalfOf properties to a one-off RDOAddressEntry object with a Unicode name could mangle the RDOMail.SenderName and RDOMail,SentOnBehalfOfName properties.


•   RDOExchangeMailboxStore.IsCached could sometimes return false even if the store was cached.


•   RDOSession.PickFolder and RDOSession.GetSelectFoldersDialog sometimes did not show the stores in the same order shown by Outlook.


•   RDOFolders.Sort only allowed to pass as a parameter an integer property tag or an array of integers, but not a DASL name (string) or an array of strings.


•   Importing MSG or Fast Transfer Stream (FTS) files (RDOMail.Import(..., olMsg / olFTS)), did not import the read/unread state and (for the unsaved messages) send/unsent state.


•   Importing in the vCard or iCal formats ((RDOMail.Import(..., olVCard / olICal))) did not set sent and received times (REV field in vCard and DTSTAMP field in iCal).



December 24, 2019



New features


•   Added RDOSession.IsAttachmentBlocked method (a wrapper for the IAttachmentSecurity MAPI interface). Returns True if the given filename is blocked by Outlook and False otherwise.

set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

MsgBox Session.IsAttachmentBlocked("MyHarmlessFile.txt")


•   Added RDORecipients / RDORecipient.ExpandDL method that allows to replace Distribution Lists in a message recipient list with the members of that list. You can expand the distribution lists recursively and/or limit the expansion to only private distribution lists - MAPIPDL distribution lists can only be accessed locally since they do not have  an externally meaningful address and only exist in the context of the store that contains the corresponding RDODistListItem object.


•   AuthKey property (available on the creatable Redemption objects) is deprecated and is now ignored. Please use RedemptionLoader to restrict access to the Redemption objects.


Bug fixes


•   Standalone applications that use Redemption could experience  a crash in jitv.dll on shutdown in November 2019 builds of Outlook due to a bug in jitv.dll.


•   RDOSession.LogonHostedExchangeMailbox failed in the latest builds of Outlook (which always attempt to use an OAuth token even if Basic credentials are supported by the Exchange mailbox and supplied by LogonHostedExchangeMailbox).


•   Decrypted message (returned from RDOEntryptedMessage.GetDecryptedMessage) body would sometimes contain no line breaks and saving the decrypted message as an MSG file could produce a message with no visible body.


•   Importing MIME files with a TNEF (winmail.dat) part sometimes corrupted RTF body wiping out embedded OLE objects.


•   Importing MIME files with a with a plain text only body using the Redemption MIME converter (olRfc822_Redemption) sometimes produced messages in the HTML format.


•   Some MSG files created by saving an embedded message attachment (returned from RDOAttachment.EmbeddedMsg) by calling RDOMail.SaveAs(..., olMsg) displayed an empty body when opened by Outlook.


•   Folders displayed by RDOSession.PickFolder, might be shown unsorted if none of the subfolders have ever been explicitly rearranged by a user


•   RDOMail.Account property sometimes returned null even if an account was explicitly assigned to the item.


•   Importing MIME (EML) files using Redemption MIME converter (olRfc822_Redemption) could sometimes raise an exception for some EML files with specially formatted RFC2231-style wrapped MIME headers.


•   EML files produced by saving in the MIME format messages or attachments with a large number of spaces (ASCII 0x20), were excessively large if quoted-printable encoding was used for the particular MIME part


•   64 bit only: reading RDOMail.HTMLBody property from a message returned by RDOSession.GetMessageFromMsgFile sometimes returned an empty string.


•   Calling RDOAppointmentItem.Send sometimes raised MAPI_E_OBJECT_CHANGED exception under the latest versions of Exchange  in the online mode.


•   RDOSession.GetArchiveMailbox / GetSharedMailBox / GetSharedDefaultFolder / AddDelegateExchangeMailBoxStore under latest versions of Outlook could cause heap corruption (resulting in abnormal process termination) if an ambiguous name was passed as a parameter.


•   For MIME messages imported using the Outlook MIME converter (olRfc822_Outlook), RDOAttachment.Hidden could erroneously return True for the regular visible attachment's



July 27, 2019



New features


•   Added RDOFolders.Find / FindNext / Restrict / Sort methods. These methods are similar to the methods exposed by the RDOItems collection, but folder level methods were never exposed by Redemption or the Outlook Object Model. Using these methods is more efficient than iterating over all subfolders, especially if the parent folder is in the online mode and/or has a large number of child subfolders.

set Session = CreateObject("Redemption.RDOSession")
Session.MAPIOBJECT = Application.Session.MAPIOBJECT
set IPMRoot = Session.Stores.DefaultStore.IPMRootFolder
set vFolders = IPMRoot.Folders
"Name", false
set vFolder = vFolders.Find("Name LIKE 'C%' ")
while not (vFolder is Nothing)
set vFolder = vFolders.FindNext


•   Added support for removing/undoing appointment exceptions to restore the original recurrence pattern either for the whole series or a particular occurrence: RDORecurrencePattern.Exceptions.Clear to remove all exceptions and  RDOExceptions.Restore  / RDOException.Restore to undo a particular exception.

set Session = CreateObject("Redemption.RDOSession")
Session.MAPIOBJECT = Application.Session.MAPIOBJECT
set appt = Session.GetMessageFromID(Application.ActiveExplorer.Selection(1).EntryID)


•   Performance enhancement: faster load times - Redemption lazy-loads time zone definitions form the registry when it accesses a date-time property for the first time. Loading localized time zone names could be slow since doing so requires loading Windows resource dlls. In the current version, the localized time zone names are only loaded when they are needed.


Bug fixes


•   Some Fast Transfer Stream (FTS) files created by RDOMail.SaveAs(..., olFTS) could not be uploaded to Exchange using the UploadItems EWS operation ("Data is corrupt., End of buffer reached prematurely."  error was returned).


•   Importing some Fast Transfer Stream (FTS) files using RDOMail.Import(..., olFTS) could raise an exception (Unexpected property type) if the file contained properties of type PT_SVREID. (such as the PidTagSentMailSvrEID property).


•   New all-day appointments created by Redemption (RDOAppointmentItem returned from RDOFolder.Items.Add(olAppointmentItem)) would sometimes be shown incorrectly by the mobile versions of Outlook (iOS and Android) due to the missing start and end time zone blobs (only the legacy time zone blob was present).


•   RDOSession.Nicknames or RDOExchangeMailboxStore.Nicknames sometimes returned stale (or no) data under Outlook 2013 or newer if accessed before Outlook flushed the latest data from its temporary cache to a hidden item in the Inbox folder.


•   Attaching an EML file created by Redemption to an Outlook message and converting that message to MIME format could produce a corrupted file since the MIME boundary generated by Redemption might not be unique enough.


•   Importing MIME (EML) files into standalone MSG files (returned by  RDOSession.CreateMessageFromMsgFile or GetMessageFromMsgFile) under Outlook 2010 or older sometimes either damaged HTML body or was shown corrupted when replying to or forwarding the message.


•   Importing MIME (EML) files using Redemption MIME converter (olRfc822_Redemption) sometimes could erroneously pick HTML  message body from an embedded message attachment (if it existed) if the primary message did not have the HTML part.


•   Exporting in the MIME (EML) format using Redemption MIME converter (olRfc822_Redemption) could sometimes create a duplicate BCC header if the original MIME headers already contained a BCC header.


•   .Net runtime compatibility: if a Redemption event that passed an empty string parameter (e.g. ParentEntryID parameter in the RDOStore.OnMessageModifiedEx event) was invoked, the .Net event handler would not be executed.


•   Setting HTMLBody property on a standalone MSG file returned by  RDOSession.CreateMessageFromMsgFile or GetMessageFromMsgFile sometimes could result in a damaged HTML body.


•   RDOAttachment.HIdden returned false for the images referenced by the HTML body by the file name rather than content id or location.


•   RDOTimezone.NameLocalized / DaylightDesignationLocalized / StandardDesignationLocalized properties returned non-localized time zone names  under the latest builds of Windows 10.


•   If HTML body data mistakenly specified UTF-16 as the codepage, RDOMail.HTMLBody property returned corrupted text.


•   Accessing RDOMail.SaveSentMessageFolder property before accessing any other property could have produced an error.


•   Passing Office 365 Teams/Groups folder to RDOMail.CopyTo / Move raised MAPI_E_NO_ACCESS exception.



March 23, 2019



New features


•   Added ForwardAsAttachment and NewMeeting events to the SafeMailItem object. These events are exposed by Outlook on the low level (IConnectionPointContainer / IConnectionPoint / etc.), but they are not defined in the type library, making it impossible to use them in VBA / VB Script and non-trivial in the .Net languages.

The events are similar to the MailItem.Reply / ReplyAll / Forward events in the Outlook Object Model.

private SafeMailItem _sItem;

private MailItem _oItem;


_oItem = _application.ActiveExplorer().Selection[1];

_sItem = new SafeMailItem();

_sItem.Item = _oItem;

_sItem.ForwardAsAttachment += OnForwardAsAttachment;


private void OnForwardAsAttachment(object Forward, ref bool Cancel)


    MailItem newMessage = (MailItem)Forward;

    if (OlSensitivity.olConfidential == _oItem.Sensitivity)


        MessageBox.Show($"Confidential message '{_oItem.Subject}' cannot be forwarded");

        Cancel = true;




        newMessage.Subject = _oItem.Subject;

        newMessage.Body = $"Please see the attached message '{_oItem.Subject}'.";




•   Outlook Object Model parity: added content indexer support to the search queries used by RDOItems.Restrict and MAPITable.ExecSQL. You can now use ci_phrasematch and ci_startswith operators instead of / in addition to = and LIKE operators. Make sure the store supports content indexing by checking the new RDOStore2 / RDOPSTStore / RDOExchangeMailbox / RDOEASStore.IsInstantSearchEnabled property first. Keep in mind that these operators only work on queries returning multiple matches, which means RDOItems.Find / FindNext will not work.

Set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

Set store = Session.Stores.DefaultStore

query = ""

If store.IsInstantSearchEnabled Then

    query = "Subject ci_phrasematch 'Redemption'"

    Debug.Print "Instant search is enabled"


    query = "Subject like '%Redemption%'"

    Debug.Print "Instant search is NOT enabled"

End If

Set folder = Store.GetDefaultFolder(olFolderInbox)

Set items = folder.Items

Set result = items.Restrict(query)

Debug.Print result.Count & " matches found"



Bug fixes


•   Setting RDOAppointmentItem.Start / End / Duration properties could lead to unexpected errors on machines with missing time zone MUI files.


•   Saving in the MSG file format (RDOMail.SaveAs and Safe*Item.SaveAs) sometimes produced MSG files in plain text even if the original message was HTML.


•   RDOSignature.ApplyTo could corrupt Unicode signature characters if the signature character set (as specified in the HTML header) was different from the current system code page and the Unicode characters were not HTML-encoded.


•   RDOSession.GetAutodiscoverXml did not respect the value of the RDOSession.MAPITimeoutShort and always used a short timeout.


•   SafeInspector.ActiveInlineResponseDiscard and ActiveInlineResponsePopOut actions were reversed  under some older builds of Outlook.


•   Importing MIME files with an attachment without an extension using Redemption MIME converter (olRfc8222_Redemption), a default extension ".dat" was added.


•   Exporting in the MIME format using Redemption MIME converter  (olRfc8222_Redemption), Message-ID header was not exported if PR_INTERNET_MESSAGE_ID property was missing even if the message id was present in the PR_TRANSPORT_MESSAGE_HEADERS property.


•   Importing an iCal file (RDOAppointmentItem.Import or RDOFolder2.Import) would not mark the imported appointment as all-day if DTEND field was not present.


•   Importing a vCard file (RDOAppointmentItem.Import or RDOFolder2.Import) raised an exception if the image specified in the vCard file was invalid / unrecognizable rather than ignoring the error.




January 28, 2019



This version is a hotfix for the appointment issues (version specific)


Bug fixes


•   Setting RDOAppointmentItem.Start / End / Duration properties could lead to unexpected errors.

•   Reading RDOAppointmentItem.Start and End properties returned from RDOFolder2.GetActivitiesForTimeRange for a folder with free/busy-only access rights raised MAPI_E_NO_ACCESS exceptions.

•   The interop dlls (Interop.Redemption.dll  and Interop.Profman.dll) were signed, but not strongly named.



January 22, 2019



New features, bug fixes, Windows 10, Outlook 2016/2019 and Outlook Centennial (Windows Store) compatibility


New features


•   Added the ability to export and import items in the Fast Transfer Stream format (used by the Exchange Server and its Exchange Web Services API - ExportItems and UploadItems operations).
This makes it possible  to upload and download full fidelity Exchange items using Exchange Web Services (EWS) - Fast Transfer Stream uses format similar to the MSG files and preserves all MAPI properties without conversion to or from MIME - you can convert data downloaded from EWS to MSG or PST format or upload MSG or PST files to an Exchange mailbox through EWS.

All Redemption methods capable of exporting or importing data (RDOMail.SaveAs / Import, Safe*Item.SaveAs / Import, RDOFolder2.Import) now support this new format through the new rdoSaveAsType.olFTS enum (1034).

Set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

Set Folder = Session.GetFolderFromID(Application.ActiveExplorer.CurrentFolder.EntryID)

Set item = Folder.Items.Add

item.Sent = true

item.Import "c:\temp\test.fts", olFTS



•   Added RDOExchangeMailboxStore.IsConsumerAccount property. Returns true for a free outlook.com mailbox, and false otherwise.


•   Outlook 2016 / 2019 compatibility: Added RDOAppointmentItem.DoNotForwardMeeting / DoNotAllowProposeNewTime properties.


•   Saving messages in the MSG format (RDOMail.SaveAs(..., olMsg)) performance was improved by as much as 90% in case of an online Exchange store.


•   The performance of importing MSG files (RDOMail.Import(..., olMsg)) into an online Exchange store was improved by as much as 50%.


•   The performance of the RDOFolder2.GetActivitiesForTimeRange method was improved by 50% - 80%.


•   Accessing RDOMail.Sender, RDOMail.SentOnBehalfOf, RDOMail.ReplyRecipients, RDODistListItem.OneOffMembers, RDORecipient.AddressEntry properties no longer requires an active MAPI session (e.g. if an MSG file is opened using RDOSession.GetMessageFromMSGFile without calling Logon or setting the MAPIOBJECT property) as long as the address is a one-off SMTP address.


Bug fixes


•   Creating any Redemption object (such as RDOSession or SafeMailItem) under Outlook 2016 November 2018 update could crash if an older version of mso.dll was already loaded by the parent process, e.g. when running under an older (2010/2013) version of msaccess.exe or if an older Access OLEDB provider was loaded in the process address space prior to using Redemption.


•   Creating any Redemption object (such as RDOSession or SafeMailItem) under Windows 10 with no Outlook installed could cause a crash in mmgaclient.dll (Windows 10 bug).


•   RDOSession.GetArchiveMailbox did not use auto discover XML cached by RDOSession.CacheAutodisocverXml.


•   RDOSession.Stores.AddDelegateExchangeMailBoxStore required Outlook restart after a delegate mailbox was added under Outlook 2016 or 2019.


•   RDOMail.Delete failed to delete the message if the message was opened in the online mode (e.g. using MAPI_NO_CACHE flag) and the parent cached folder did not contain the message (e.g. if it was outside of the time range cached by the OST store).


•   MAPIUtils.HrArrayToString method could be slow for large arrays


•   RDOFolder2.Import method could be slow with large EML files if the Redemption MIME converter (olRfc822_Redemption) was used.


•   RDOMail.SaveAs created an MSG file with only the message body and recipients populated for some corrupted messages in PST stores.


•   Importing iCalendar (ICS) files using RDOAppointmentItem.Import or RDOFolder2.Import, if the meeting organizer was listed as both the organizer and as an attendee, the organizer was not marked as such in Outlook.


•   Accessing SafeRibbon.Controls collection under Outlook 2016/2019 sometimes raised "Could not convert variant of type (OleStr) into type (Int64)" exception.


•   When the ribbon was compacted under Outlook 2016/2019, SafeInspector.ActiveInlineResponseDiscard and ActiveInlineResponsePopOut actions were reversed  - ActiveInlineResponseDiscard was popping the inline response instead of discarding it, and ActiveInlineResponsePopOut was discarding the inline response instead of showing the inline response in a new inspector.



October 6, 2018



New features, bug fixes, Windows 10, Outlook 2019 (beta) and Outlook Centennial (Windows Store) compatibility


•   Added RDOFolder2.Import method. The method allows to import from a file, IStream COM interface, or from a variant array (of byte or of variant). All import formats supported by RDOMail.Import are supported by RDOFolder2.Import.  Since RDOMail.Import method signature cannot be changed to support an import source other than a file (a frequently requested Redemption feature), this method can be used instead.

The method allows to import iCal files with multiple events or vCard files with multiple contacts. For all other formats, a single new item is created. The method returns RDOItems collection with the newly created items. To retrieve RDOFolder2 interface, cast any RDOFolder object to RDOFolder2.

Set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

Set Folder = Session.GetDefaultFolder(olFolderCalendar)

Set items = Folder.Import("c:\temp\MultipleItems.ics", olICal)

For Each item In items

  debug.Print item.Subject



•   RDOMail.Import and Safe*Item.Import methods now support olTxt format (olRtf and olHTML formats were supported before). In case of the file based data, Import is an easier and more reliable option that setting the RTFBody, HTMLBody, or Body properties as the file contents would not have to be converted to a Unicode string first before setting the body properties.


•   Specifying "Recipients / To / CC /BCC" in the RDOItems.Find/Restrict/etc. SQL queries, only searched the PR_DISPLAY_NAME and PR_EMAIL_ADDRESS MAPI properties in the recipient table. The latest version will also match on the PR_SMTP_ADDRESS recipient property.


Bug fixes


•   Under Windows 10 October 2018 Update (1809), accessing any DateTime property resulted in the "System Error. Code: 18. There are no more files" exception when Redemption attempted to load the time zone definitions.


•   RDOSignature.ApplyTo erroneously copied the signature to the clipboard wiping out any existing clipboard content.


•   Accessing RDOSignature.HTMLBody property sometimes produced "No mapping for the Unicode character exists in the target multi-byte code page" exception.


•   Under Outlook Centennial (Windows Store), calling RDOContactItem.AddPicture, passing RDOAttachment object to the RDOMail.Attachments.Add method, or reading the RDOAttachment.FileSize property resulted in the "Interface not supported" exception.


•   Under Outlook Centennial (Windows Store),  RDOSession.LogonPstStore crashed the calling process due to a bug in the HrValidateIPMTree MAPI function,


•   Under Outlook Centennial (Windows Store), handling RDOItems or RDOFolders events could lead (after processing at least one event) to the MAPI system shutdown requiring application or mmgaserver.exe restart due to a bug in the ScCopyProps MAPI function.


•   Some MSG files produced by Redemption (RDOMail.SaveAs(..., olMsg)) were missing parts of the message body when displayed by Outlook even if RDOMail.Body returned correct data.


•   On some systems loading Redemption showed a message box with an error "Missing procedure entry point ShowBucketedString@8 could not be located"


•   RDOItems.Sort could not handle quoted property names in the DASL format (unquoted property names worked as expected).


•   RDOMail.Move failed to move the message if the message was opened in the online mode (e.g. using MAPI_NO_CACHE flag) and the parent cached folder did not contain the message (e.g. if it was outside of the time range cached by the OST store).


•   Importing some iCal files with multiple attendees, one of which contained an invalid ("invalid:nomail") email, import sometimes causes MAPI_E_INVALID_PARAMETER exception from IMessage::ModifyRecipients.


•   Importing MIME files with a plain text body only and double Unix-style line breaks (0x0D, 0x0D) using Redemption MIME converter (olRfc8222_Redemption) could corrupt the message body.




May 29, 2018



New features, bug fixes, Outlook Centennial (Windows App Store) compatibility


•   Outlook Object Model parity - RDOAttachments.Add now supports adding web-by-reference (RDOAttachment.Type == olByWebReference (7)) attachments. The Source parameter must be a valid http or https url and Type parameter must be olByWebReference.


•   Added new property - RDOSession.HeadersOnlyOnSlowConnection. Corresponds to "Send / Receive | Download | On Slow Connectiosn Download Only Headers" in the Outlook UI.

Highslide JS


•   RDOSession.ExchangeConnectionMode property can now be set (it was read-only previously). Not all rdoExchangeConnectionMode enum values are allowed: olCachedDisconnected (the same as setting the RDOSession.Offline property to true), olCachedConnectedHeaders, olCachedConnectedDrizzle, olCachedConnectedFull can be used (see the screenshot above)


•   Added RDORecipient.AddressType property. This property was added to discourage the use of the RDORecipient.AddressEntry.Type property usage pattern- accessing RDORecipient.AddressEntry (which returns an instance of the RDOAddressEntry object) can be expensive, especially in the online mode.


•   RDOSelectFoldersDialog object (returned by RDOSession.PickFolder) icons were updated to match Outlook 2016 folder icons. When running under Outlook 2013 or older, old style icons are used to be consistent with the Outlook UI.

Highslide JS


Bug fixes


•   Under Outlook Centennial, retrieving items from the RDOFolder.Items collection failed (Error in PropCopyMore: MAPI_E_INVALID_PARAMETER) .


•   Under Outlook Centennial, RDOAddressEntry object returned from RDOSession.CurrentUser had all properties empty .


•   RDOStore.StoreKind property sometimes returned skEAS instead of skIMAP4 under Outlook Centennial.


•   RDOSession.GetSharedMailbox  failed under Outlook 2013 or older.


•   RDOSearchFolder.SearchCriteria.AsSQL raised an exception under the latest builds of Outlook 2016.


•   RDOSelectFoldersDialog object (returned from RDOSession.PickFolder) sorted the folders alphabetically, rather than in the order displayed by Outlook.


•   RDOMail.BodyFormat property returned olFormatPlain and RDOSignature.ApplyTo inserted plain text signature for the new messages (Body / HTMLBody / RtfBody properties never set)


•   Retrieving free/busy information failed under locales with a time separator other than ":".


•   No properties could be set on existing recurring recurring appointment exceptions (setting properties on new exceptions worked properly).


•   Setting RDORecurrencePattern.PatternEndDate property sometimes added one extra occurrence (as returned by the RDORecurrencePattern.Occurrences property).


•   Redemption MIME exporter sometimes corrupted Unicode characters in the message body when exporting MIME files when quoted-printable MIME encoding was used.


•   Redemption MIME importer did not import Categories and message flag if they were specified in an EML file.


•   Redemption MIME importer replaced Unicode characters with "?" in the display names of embedded message attachments.


•   Better RDOSession.GetSharedMailbox error handling - instead of raising a generic "Could not find the store DN" exception, the error now includes extra information that led to that error.


•   Setting RDOMail.HTMLBody property on a standalone MSG file returned from RDOSession.GetMessageFromMsgFIle / CreateMessageFromMsgFIle sometimes resulted in Outlook displaying the MSG file in plain text.


•   RDOMail.HTMLBody property returned garbage if the native HTML erroneously specified "unicode" as the content charset.


•   RDOAddressListSearch.GetResults raised MAPI_E_END_OF_SESSION exception when used for the very first time in a session under Outlook 2016.


•   Importing some malformed MSG files (RDOMail.Import(..., olMsg)) created by third-party software failed to import the message body.






February 19, 2018



New features and improvements


•   Added support for the Windows Store version of Outlook 2016 . Previous versions of Redemption could not find and load the MAPI system (which is installed in a different location and the executables have different file names)


•   Added RDOStore2.GetFolderFromPath method. Similar to the RDOSession.GetFolderFromPath method, but allows to open a folder by path on the per-store level. RDOStore2.GetFolderFromPath includes an optional parameter (CanCreate) that can be used to create the folders along the path if they do not already exist.. If the folder path includes the store name (prefixed with "\\"), it is ignored. This makes it possible to retrieve RDOFolder.FolderPath from a folder in one store and recreate the same path in another store.

RDOSession session = new RDOSession();


RDOStore store = session.Stores.DefaultStore;

RDOStore2 store2 = store as RDOStore2;

RDOFolder folder = store2.GetFolderFromPath(@"Inbox\Test folder", true);



•   Added  RDOExchangeMailboxStore.AutoDiscoverUrl / LastSyncTime (may not be present on all stores) / MAPIHTTPMailboxInternalUrl / MAPIHTTPMailboxExternalUrl / MAPIHTTPAddressbookInternalUrl / MAPIHTTPAddressbookExternalUrl properties.


•   Added RDORecurrencePattern.FirstDayOfWeek property - recurrence pattern specific first day of week (can be different from the local setting).


•   MAPITable.ExecSQL performance was greatly improved (especially against an online Exchange store). If a restriction was specified, the previous versions defaulted to using the MAPI equivalent of Find/FindNext retrieving one row at a time rather than using Restrict by default to retrieve multiple rows in a single call.  This was previously done to mitigate Exchange Server performance issues when the server cached the queries; newer versions of Exchange  handle restrictions much better now.


•   Added RDOSyncMessageItem.Fields[] and RDOSyncMessageItem.PropList properties that allow to access the list of property tags and their values provided by the ICS API  (especially if RDOFolderSynchronizer.IncludeSyncProperties was used to request extra properties) without opening the message using RDOSyncMessageItem.Item.


Bug fixes


•   RDOMail.HTMLBody property and saving messages in the HTML format produced corrupted text for some codepages.


•   Exporting messages in the MIME format using built-in Redemption MIME converter (RDOMail.SaveAs(..., olRfc822_Redemption)) sometimes corrupted Unicode characters HTML body in the exported MIME message if the code page specified in the HTML header did not match the actual data in the HTML body.


•   When accessing a read-only MSG files opened using RDOSession.GetMessageFromMsgFile, Redemption returned empty values for named MAPI properties accessed using RDOMail.Fields[] and for properties based on named MAPI properties (e.g. RDOAppointmentItem.Location).


•   When RDOMail object created on top of an MSG file was deleted or simply released while references to its child recipients or attachments were still alive, those references could cause an access violation later when the child objects were released (either explicitly or by the .Net Garbage Collector).


•   Opening a folder in the  online mode (using MAPI_NO_CACHE flag) sometimes caused its child messages (from the Items collection and Items event handlers) to return empty values for the named properties (such RDOMail.Mileage, RDOAppointmentItem.Start, etc.)


•   Redemption MIME import/export sometimes did not correctly handle recipient/sender display names with special characters (such as ", <, >, etc.)


•   Redemption MIME importer sometimes (if the code page was not explicitly specified) misidentified the message code page as UTF-7 if character sequences like "+1-" were present in the message body.


•   Redemption MIME importer was slow when converting large (10 Mb+) text (or text based) attachments using quoted-printable encoding.


•   RDOMail.ReplyRecipients collection sometimes mangled Unicode characters.


•   Setting RDOMail.ReplyRecipients collection to that from another message or passing RDOMail.ReplyRecipients collection to RDOAddressBook.ShowAddressBook could cause memory corruption or crash.


•   RDOExchangeAccount.User property under cached Office 365 profile sometimes returned RDOAddressEntry object with most fields blank.


•   RDOSession.GetSharedDefaultFolder sometimes caused an access violation instead of raising a meaningful COM exception when a name that cannot be resolved was passed as a parameter.


•   When saving HTML messages in the olHTML format (RDOMail.SaveAs), the date in the "Due By" header could be corrupted when running under a locale other than English.


•   Importing ICS files (RDOAppointmentItem.Import(..., olICal)) with a present but  empty ORGANIZER field could produce an exception.


•   When setting RDOMail.Sender and RDOMail.SentOnBehalfOf properties, PR_SenderSimpleDispName and PR_SentRepresentingSimpleDispName MAPI properties were not being set, sometimes resulting in OWA showing empty sender name.



October 4, 2017


This version is a hotfix for the problem introduced in version when Redemption defaulted to the Japanese language (see below).


Bug fixes

•   Instead of using the Outlook or system locale, Redemption defaulted to the Japanese language for its UI (RDOSession.PickFolder) and methods that required localizable stings (e.g. RDOMail.SaveAs(..., olTxt), RDOStore.ValidateIPMTree, etc.). This problem was version specific.


•   RDOSession.OutlookVersion property sometimes retrieved the version information from the MAPI system (olmapi32.dll) rather than outlook.exe.



October 1, 2017



New features and improvements


•   Added RDOFolderSynchronizer.IncludeSyncProperties collection that allows to specify which properties must be included by the sync, which can significantly reduce the network traffic during synchronization.


•   Added enumerator support (foreach) to the PropList collection returned by the MAPIProp.GetPropList property (most Redemption objects are derived from the MAPIProp object - RDOMail, RDOFolder, RDOAttachment, etc.)


•   Added RDOAddressBook. ResolveNameCheckOrder property (rdoResolveNameCheckOrder enum). Determines the order in which a name is resolved by the address book. Prior to multiple Exchange Server support in Outlook 2010, the order was always determined by the RDOAddressBook.SearchPath list. Starting with Outlook 2010,  the order can change based on the currently selected store in Outlook.




Bug fixes


•   RDOMail.HTMLBody and Safe*Item.HTMLBody properties sometimes returned HTML body with Unicode characters corrupted if the message code page did not match the code page specified in the HTML body header.


•   RDOSession.CurrentUser sometimes under cached Office 365 profile returned RDOAddressEntry object with most fields blank.


•   Setting most RDONickName properties corrupted the property values.


•   Outlook MIME converter (used by the olRfc822 and olRfc822_Outlook formats) sometimes produced as access violation when converting some Office 365 message stamped with a invalid property. Redemption now removes the invalid  properties before using the Outlook MIME converter (IConverterSession). Note that the Redemption MIME converter (olRfc822_Redemption) was not affected.


•   When retrieving autodicover XML, Redemption could hang in an infinite loop if one url was redirecting to another url redirecting to the first one (self-redirections were handled in the previous versions).


•   RDOEncryptedMessage.GetDecryptedMesage could not handle signed messages with the message class of IPM.NOTE.SMIME (instead of the expected IPM.NOTE.SMIME.MultipartSigned)


•   RDOSession.GetRDOObjectFromOutlookObject returned an error for some signed or encrypted Outlook messages with an invalid or missing certificate.


•   For certain recurring appointment exceptions, the same RDOException object was returned for multiple items from the RDOExceptions collection.


•   For some nicknames, RDONickName.SMTPAddress property returned an empty string.


•   When Outlook 2007 was installed prior to installing Outlook 2016, Redemption sometimes loaded olmapi32.dll instead of msmapi32.dll resulting in an application crash.


•   Safe*Item's Attachment object did not support OneDrive (Type == olOneDrive)  attachments in Attachment.SaveAsFile method.  RDOAttachment.SaveAsFile functioned properly.


•   Redemption MIME converter exported recipients differently from the Outlook converter (IConverterSession) when converting an Outlook NDR to a MIME file.


•   Redemption MIME sometimes failed to import MIME headers  when malformed MIME files with mixed (0x0D, 0x0A) and (0x0D) line breaks were processed


•   RDOSession.GetSharedMailbox sometimes returned the primary mailbox in the profile instead of the specified delegate mailbox.


•   RDOSession.PickFolder dialog box was displayed in English for the Japanese and Chinese versions of Office.


•   ProfMan library: Profile.OpenProfileSection did not raise an exception if an invalid GUID was specified and instead created  a new profile section with a random GUID. Profile.OpenProfileSection now also allows to pass a hex sting representing the GUID (such as a hex string returned by RDOAccount.Fields[] for a PT_BINARY property or a hex string returned by MAPIUtils.HrArrayToString)


•   Incremental Change Synchronization API (ICS): RDOSyncFolderItem.Item property raised MAPI_E_NOT_FOUND exception for the folders that were created in the online store but not yet downloaded to the cached local store.


•   RDOAttachment.HIdden property was always true for the attachments of messages returned from the RDOEncryptedMessage.GetDecryptedMessage.method.




May 16, 2017

Version - a hot fix for the out-of-memory problem when accessing a large number of appointments.


•   Accessing a large number of the RDOAppointmentItem objects was slow and could cause out-of-memory errors in 32 bit applications.


•   Redemption could not handle cached Outlook autodiscover XML that only contained a redirect to another url.




May 07, 2017



New features and improvements


•   Added RDOAddressBook.AllRooms and RDOExchangeAccount.AllRooms properties that returns an instance of the RDOAddressList object representing the Exchange "All Rooms" address book container


set Session = CreateObject("Redemption.RDOSession")
Session.MAPIOBJECT = Application.Session.MAPIOBJECT
set ABDialog = Session.GetSelectNamesDialog
ABDialog.InitialAddressList = Session.AddressBook.AllRooms
ABDialog.AllowMultipleSelection = false
ABDialog.Caption = "Select a room"
ABDialog.ShowOnlyInitialAddressList = true
ABDialog.ForceResolution = true
set roomRecipients = ABDialog.Display(true)


•   Added RDOTimezone.NameLocalized / StandardDesignationLocalized / DaylightDesignationLocalized properties that contain time zone names in the current Windows locale.


•   Added two new values to the rdoDefaultFolders enumeration used by RDOSession.GetDefaultFolder / RDOStore.GetDefaultFolder  - olFolderArchive (corresponds to the Archive default folder in Exchange mailboxes) and olFolderAllItemsSearch (corresponds to the "All Items" search folder containing all items in the given Exchange mailbox).


•    Faster MIME import for messages with large number of recipients (hundreds or thousands)


•    RDOSession.GetRDOObjectFromOutlookObject  now supports the account object - given an Account Outlook object, it will return the matching RDOAccount object.


•    RDOAttachments.Add method can now take another RDOAttachment object as a parameter


Bug fixes


•    Date/time properties for the various Redemption objects (such as RDOMail,. RDOAppointmentItem, etc.) sometimes returned wrong values for the dates in the past if the Windows language was other than English - Redemption failed to locate the correct list of dynamic DSTs based on the localized time zone name.

This issue also caused RDOSession.Timezones.CurrentTimeZone property to return null on non-English versions of Windows.


•    RDOSession.GetAutoDiscoverXML would sometimes fail with an error like "CheckSynchronize called from thread xyz, which is NOT the main thread".  The same problem sometimes caused GetSharedMailbox to fail if used on a secondary thread.


•    RDOAddressBook.GetAddressEntryFromStoreItem  sometimes produced an access violation in the 64 bit version of Redemption.


•    Recurring appointments created in a local time zone different from the appointment time zone (RDOAppointmentItem.StartTimezone / EndTimezone) were sometimes missing first or last occurrence.


•    Signed messages in the EML format imported using Redemption MIME converter (olRfc822_Redemption) created an attachment with an invalid attachment type (0)


•    RDOMail.PrintOut raised a generic MAPI_E_INVALID_PARAM error instead of an exception informing the caller that there is no active session for the messages with no active MAPI session (e.g. messages returned by RDOSession.CreateMessageFromMsgFile / GetMessageFromMsgFile ).


•    Setting the RDORecurrencePattern.PatternEndDate property sometimes produced invalid results.


•    Calling RDOSession.LogonHostedExchangeMailbox under Outlook 2016 with no credentials (if the user is running under the identity of the domain user who owns the specified mailbox) raised a MAPI_E_LOGON_FAILED error


•    RDORecipients.Add / AddEx sometimes corrupted Unicode characters under the Hebrew locale


•    Redemption sometimes failed to use autodiscover XML already cached by Outlook.


•    RDOFolder2.GetActivitiesForTimeRange failed to return some activities.


•    RDOSession.PickFolder would not allow to select the top level folder of any store (version 5.12 specific).


•    Importing iCal files using (RDOAppointmentItem.Import(..., olICal) failed to import X-MS-OLK-SENDER field if it was different from the ORGANIZER field.


•    Could not read RDOAppointmentItem.Start /End /AllDay properties for the private appointments in delegate mailboxes.


•    Delay (several seconds) when calling RDOStore.StoreAccount when more than one version of Outlook is installed


•    Could not load MAPI system under Outlook 2013 when running under a Local System account (e.g. in a Windows service)


•    Redemption MIME importer could not correctly process some RFC2231 formatted attachment names.


•    For the Office 365 mailboxes upgraded from outlook.com accounts, the MAPI session created by LogonHostedExchangeMailbox sometimes hanged when resolving message recipients.


•    RDOAppointmentItem.GlobalAppointmentID  property sometimes (depending on the start date and the time zone) returned different values before and after the instance was turned into an exception.


•    Setting the RDOAppointmentItem.HTMLBody / RtfBody properties on an instance of a recurring appointment created the exception, but set the body on the master appointment instead of the specified occurrence.



January 09, 2017


Miscellaneous and Outlook 2013 / 2016 / Click-To-Run specific fixes.


New features and improvements


•    Redemption MIME converter could not import RFC2231 formatted attachments with wrapped long file names.  Note that Outlook (and Outlook MIME converter invoked when olRFC822_Outlook format is specified) does not handle attachments like that.  To make sure Redemption converter is used, specify the olRFC822_Redemption format when calling RDOMail.Import.


Bug fixes


•    RDONicknames.Add created duplicate entries and sometimes caused heap corruption resulting in a crash.


•    RDOSignature.ApplyTo did not copy the HTML styles from the signature to the specified message resulting in the signature text with a wrong font .


•    RDOSignature.ApplyTo sometimes missed images that had special characters or were located in custom folders.


•    RDOSignature.ApplyTo corrupted the resulting message text if the signature contained extended Unicode characters and the original message body did not .


•    Saving in the olHTMLEmbeddedImages format (RDOMail.SaveAs, the images in the HTML body are saved inside the <img> HTML tags) leaked memory and could result in the application running out of memory if called repeatedly.


•    RDOSession.LogonHostedExchangeMailbox / GetAutodiscoverXml / etc. did not use HTTP proxy settings configured in the Internet Explorer.


•    RDOAddressEntry object returned from RDOSession.CurrentUser sometimes returned empty strings for most of its properties for some on-prem Exchange servers.


•    Saving a recurring appointment with exceptions created on top of an MSG file (RDOSession.GetMessageFromMsgFile)) in the ICS format (RDOAppointmentItem.SaveAs(..., olICal) produced "Error in IMessage.OpenAttach: MAPI_E_NO_ACCESS" exception.


•    Saving an appointment in the MIME format (RDOAppointmentItem.SaveAs(..., olRfc822)) produced the "The parameter is incorrect" exception if the appointment was in a time zone that could not be recognized locally.


•    RDOSession.Stores.AddDelegateExchangeMailBoxStore did not work with RPC-over-HTTP and MAPI-over-HTTP stores.


•    Outlook Object Model compatibility fix: for the MAPI_P1 recipients, RDORecipient.Type returned 0 instead of MAPI_P1 (0x10000000).


•    Calling RDOCategories.Add before accessing any other RDOCategories properties or methods caused RDOCategories object to skip populating the default categories if no categories were present in the store.


•    Importing iCal, vTodo, and vCard files (RDOMail.Import) with UTT-8 encoded data under Japanese / Chinese / Korean locales sometimes resulted in corrupted data.


•    Importing some ICS files (RDOMail.Import) produced by iPhone sometimes generated '$/R' is not a valid integer value exception.


•    Setting RDOContactItem.Email1Address / Email2Address / Email3Address to an empty string sometimes produced invalid data


•    Several Redemption methods that allow to pass HWND of the parent window (such as RDOAddressBook.ResolveName, RDOMail.Display, etc.) could not handle COM variants produced by .Net and could not use  Explorer or Inspector Outlook objects passed as parameters.


•    vCard files created by RDOContactItem.SaveAs(..., olVCard) encoded line returns in quoted-printable values as "\n" instead of of "=0D=0A".


•    Folder selection dialog (RDOSession.PickFolder) could display an access violation error when expanding a folder that only contained subfolders inaccessible to the current user.


•    Folder selection dialog (RDOSession.PickFolder) sometimes came up with an empty folder tree if there was an EAS store in the profile.


•    RDOSesssion.AddDelegateExchangeMailboxStore raised an exception if autodiscover XML could not be retrieved instead of falling back to the pre RPC-over-HTTP logic.


•    Importing EML (MIME) files using Redemption MIME converter (olRfc822_Redemption) placed all MIME headers into the message body if the message did not contain any MIME parts .and did not contain a terminating empty line.


•    SafeInspector.Text and SelText properties returned an error if the inspector had a custom form region with a browser control.


•    SafeInspector.WordEditor returned null instead of raising an exception if there was an exception returned by the Word editor.


•    RDOTaskItem.MarkComplete / MarkCompleteEx did not remove the reminder from the completed instance of a recurring task and did not advance the reminder to the next instance for the recurring tasks.


•    Setting RDOContactItem.Email1EntryID / Email2EntryID / Email3EntryID to a value with a Unicode SMTP address, produced ???? for the email display name.


•    Setting RDORecurencePattern.Duration / StartTime / EndTime properties instead of RDOAppointmentItem.Duration / Start / End properties sometimes produced appointments with unexpected duration/start/end properties.


•    RDOException.OriginalDate returned wrong value for all-day appointments.


•    RDORecipient.SMTPAddress raised an exception instead of returning an empty string if there was no active MAPI session available (e.g. for the messages returned by RDOSession.GetMessageFromMsgFile which does not require a call to RDOSession.Logon or setting the RDOSession.MAPIOBJECT property).


•    RDOAppointmentItem.Attachments collection for the RDOAppointmentItem objects representing exceptions or instances of recurring appointments sometimes returned attachments from the master appointment containing recurrence exceptions.


•    RDOMail.BodyFormat property  sometimes returned olFormatPlain for RTF (olFormatRichText) emails.


•    RDOMail.BodyFormat property sometimes returned olFormatPlain for some HTML messages.




May 07, 2016



More Outlook 2016 and Click-To-Run fixes and tweaks as well as new features.


New features and improvements


•    Creating. modifying, and saving new RDOContactItem, RDOAppointmenttItem and RDOTaskItem objects is now much faster (3-5 times) in the online Exchange mailboxes.



Inspector inspector = application.ActiveInspector();

MailItem mailItem = (MailItem)inspector.CurrentItem;

if (string.IsNullOrEmpty(mailItem.Subject))


    SafeInspector safeInspector = new Redemption.SafeInspector();

    safeInspector.Item = inspector;

    MessageBox.Show("The message must have a subject");




•    Added RDOSession.MAPIVersion and RDOSession.MAPIDllFileName properties. OutlookVersion and Version properties were implemented previously.


•    Added RDOMail.MarkAsTask method (marks the item as a task and assigns a task interval for the object).


•    Added RDOExchangeMailboxStore.MonthsToKeepOffline and DaysToKeepOffline properties.


•    Support for the OneDrive attachments in Outlook 2016 - added olOneDrive value to the rdoAttachmentType enum used by the RDOAttachment.Type property. Note that OneDrive attachments saved by the RDOAttachment.SaveAsFile method are always saved as link files with the URL extension (even if a different extension is specified) for the consistency with the Outlook Object Model.


•    cpEnterprise value was added to the rdoCredentialPersist enumeration (used by RDOCredentials.Add).


•    Methods requiring EWS or autodiscover calls to an Exchange server (RDOSession.GetSharedMailbox, (RDOSession.GetAutodiscoverXml, etc.) can now use cached Outlook credentials saved when the user checks the "Remember my credentials" checkbox in the authentication prompt dialog in Outlook.


•    RDOSession.PickFolder method and RDOSelectFoldersDialog object are now much faster in the profiles with a large number of stores, especially delegate Exchange mailboxes (the stores are no longer opened when the dialog is displayed).



Bug fixes


•    Outlook 2016 installed in the click-to-run mode (C2R) sometimes caused Redemption to fail to load the MAPI system (missing api-ms-win-crt-string-l1-1-0.dll file).


•    RDOAppointmenttItem.Respond sometimes caused a hard crash in ntdll.dll.


•    November 19, 2015, update for Outlook 2013 (KB2975838) caused Redemption to crash when calling RDOSession.Logon / LogonExchangeMailbox / LogonHostedExchangeMailbox /LogonPstStore.


•    RDOMail.SaveAs(..., olMsg) under Exchange 2016 saved RTF messages with embedded OLE attachments were sometimes created in a corrupted state.


•    Setting a MAPI property using SafeRecipient.Fields sometimes caused application crash. The RDORecipient object functioned properly.


•    RDOSearch.Delete raised 0x8000FFFF (Catastrophic failure) exception.


•    RDOSession.CurrentUser.Name returned "?"s for the Unicode characters under POP3/SMTP and IMAP4/SMTP accounts (Outlook bug). Exchange accounts behaved properly.


•    RDOAppointmenttItem.Send sometimes produced meeting requests with no body under the standalone version of MAPI.


•    Installing the 64 bit version of Redemption (redemption64.dll) using Windows Installer (MsiExec) sometimes caused "Redemption64.dll failed to register. HRESULT -1066598274. Contact your support personnel" error to be displayed,.


•    RDOFolder.OnMessageCreated event did not fire when a new message was created in the folder.


•    RDOFolder.OnMessageCreated  event fired when a message was deleted instead of the RDOFolder.OnMessageDeleted event (which never fired).


•    RDOAccount.ReplySignature and RDOAccount.NewMessageSignature returned an error if the signature was reset to (none) in Outlook options.


•    RDOSession.GetArchiveMailbox failed for the archive mailboxes in a different domain (e.g. an on-premise primary mailbox and an Office 365 hosted archive mailbox).


•    Importing EML (MIME) files using Redemption MIME converter (olRfc822_Redemption) sometimes hanged for the EML files with only HTML (no plain text) message body.


•    RDOOutOfOfficeAssistant ignored explicitly specified credentials (e.g.  by the RDOAdrressEntry.GetOutOfOfficeAssistant method) when the settings were saved.


•    Setting the RDOOutOfOfficeAssistant.OutOfOffice property would force the OOF state to be "Enabled" instead of "Scheduled" even if the State property was explicitly set.


•    RDOAccount.AccountCategories property never returned the acStore (1) bit. Instead, acMail (2) bit was always returned.


•    RDOAppointmenttItem.Parent property for the recurrence instance appointments returned by RDOFolder2.GetActivitiesForTimeRange or RDORecurrencePattern.Item pointed to the parent folder instead of the parent (master) appointment.  This bug was introduced in version 5.10.


•    Calling RDOAppointmenttItem.Save on a recurrence instance returned by RDOFolder2.GetActivitiesForTimeRange or RDORecurrencePattern.Item and deleted using RDOAppointmenttItem.Delete caused both deleted and modified exceptions to be created resulting in the recurrence instance staying intact.


•    RDORecurrencePattern.GetOccurence sometimes raised "The activity does not occur on <date>" exception for the last instance of a recurring sequence depending on the end time and the time zone.




October 17, 2015



Hotfix: version released on October 5, 2015, created, upon registering with regsvr32.exe, an empty registry key (HKCR\TypeLib\{2D5E2D34-BED5-4B9F-9793-A31E26E6806E}\5.10) that can prevent .Net run-time from being able to create or use Redemption objects (TYPE_E_LIBNOTREGISTERED). The updated version will not create that key and will delete the erroneous key if it exists.


Bug fixes


•    When registered with regsvr32.exe, version created an empty registry key HKCR\TypeLib\{2D5E2D34-BED5-4B9F-9793-A31E26E6806E}\5.10 sometimes causing .Net to raise a TYPE_E_LIBNOTREGISTERED exception. The updated version will not create that key and will remove it if present when the dll is installed using regsvr32.exe.

•    RDOMail.Delete(dfMoveToDeletedItems) sometimes silently failed on IMAP4 stores without raising any errors.

•    RDOMail.Reply / ReplyAll / Forward sometimes garbled new message headers under locale other than English.

•    RDOMail.Reply / ReplyAll / Forward always created localized headers even if "Options | Advanced | Use English for message headers..." in Outlook was set.

•    RDOMailboxDelegates.Save sometimes raised HTTP error 500.





October 05, 2015



This release focuses on Outlook 2016 support (released September 22, 2015).

Note: older versions of Redemption would cause a crash in the Outlook 2016 MAPI marshalling system when a MAPI object is marshaled out-of-proc, e.g.  when setting the RDOSession.MAPIOBJECT property or when using SafeMailItem or MAPITable objects.


New features


•    RDOSession.LogonHostedExchangeMailbox now fully supports Outlook 2016.


•    Added RDOSession.UseEWSImpersonation property. If set to true, forces Redemption to add the ExchangeImpersonation header when making EWS calls (e.g. when retrieving free/busy range or mail tips).


•    Added RDOMail.SetProps method that allows to set multiple properties in a single call (RDOMail.GetProps to read multiple properties was added in version 5.0)

 dim tags(3)
dim values(3)

'OOM property name
tags(0) = "Subject" 'PR_SUBJECT_W
'DASL property names
tags(1) = "http://schemas.microsoft.com/mapi/proptag/0x00390040" 'PR_CLIENT_SUBMIT_TIME
tags(2) = "http://schemas.microsoft.com/mapi/proptag/0x0E060040" 'PR_MESSAGE_DELIVERY_TIME
'integer property tag
tags(3) = &H1000001F 'PR_BODY_W

values(0) = "Test subject"
values(1) = #9/1/2015 2:00PM# 'This is UTC
values(2) = #9/1/2015 3:00PM# 'This is UTC
values(3) = "Test body"

set Session = CreateObject("Redemption.RDOSession")
Session.MAPIOBJECT = Application.Session.MAPIOBJECT
set Folder = Session.GetDefaultFolder(olFolderDrafts)
set Msg = Folder.Items.Add
Msg.SetProps tags, values


Bug fixes

•   MAPI marshalling in Outlook 2016 was broken resulting in a crash when setting the RDOSession.MAPIOBJECT property to Namespace.MAPIOBJECT from Outlook or when using SafeMailItem or MAPITable objects in a process other than outlook.exe.


•   RDOSession.LogonHostedExchangeMailbox did not work under Outlook 2016.


•   The order of the autodiscover probes in the Active Directory was changed to test for the most often used configurations first thus eliminating the timeouts when attempting to connect to the non-existent LDAP servers.


•   RDOSignatures collection sometimes could not find any signatures in the versions of Outlook with a locale other than English


•   Messages created using RDOMail.Reply / ReplyAll / Forward sometimes corrupted Unicode recipient names.


•   Importing MIME messages with TNEF attachments (such as those created by the Exchange server) using RDOMail.Import and the built-in Redemption converter (olRfc822_Redemption) imported the messages in the plain text format


•   Importing MSG files in the RTF format using RDOMail.Import (.., olMsg) turned RTF messages into HTML messages.


•   Importing vCard files using RDOMail.Import (.., olVCard) did not import addresses for the vCard files with field grouping (e.g. item1.ADR - some Apple products create vCard files like that).


•   Exporting messages in the iCalendar format using built-in Redemption MIME converter (RDOMail.SaveAs(..., olICal)) did not export embedded message or OLE attachments. Note that the Outlook Object Model does not export such attachments.


•   Exporting messages in the MIME format using built-in Redemption MIME converter (RDOMail.SaveAs(..., olRfc822_Redemption)) sometimes corrupted Unicode names in the Reply-To MIME header.


•   Exporting vCard files using RDOMail.SaveAs (.., olVCard) sometimes did not correctly export the business address. 


•   RDOSelectFoldersDialog dialog did not update the values of the Left, Top, Width, Height properties during and after the folder selection dialog was shown.


•   Importing iCalendar (olICal) or MIME (olRfc822_Redemption) with a calendar/text MIME part raised "End time must be greater than the start time" exception instead of defaulting to a duration of 15 minutes for appointments with the (invalid) end time less than the start time.


•   RDOAddressEntry.GetFreeBusy did not respect the value of the RDOSession.SkipAutodiscoverLookupInAD property


•   RDOAttachment.SaveAsFile method could not save embedded message attachments deeper than 14 levels.


•   Customized versions of Redemption.dll did not use the custom type library name specified in customize.exe.


•   RDOEncryptedMessage.GetDecryptedMessage sometimes raised MAPI_E_NO_ACCESS exception for the encrypted messages in one of the Public Folders store.



June 25, 2015



This release focuses on the upcoming Outlook 2016 support as well as performance improvements, especially when connected to a hosted remote online Exchange store.


New features


•    RDOMail and the objects derived from it (RDOContactItem, RDOAppointmentItem, RDOTaskItem, etc) were revamped to minimize the number of RPC calls made when an item is created, modified, accessed or saved. In some cases, the number of RPC calls was cut down by a factor of 10, resulting in a greatly increased performance under an online Exchange store.


•   Setting RDOMail.To / CC / BCC properties was slow for a large number of recipients. Version 5.9 speeds up setting these properties by up to a factor of 100 when setting hundreds of recipients.


•    Improved MAPI event handling (RDOMail, RDOFolder, RDOStore, RDOItems, RDOFolders events). In the older versions, when a MAPI notification was received, Redemption would switch to the main thread (where the corresponding object was created) using SendMessage Windows API function, thus blocking the MAPI notification thread until the main thread finished processing the event. This degraded the performance, caused some events to be skipped, and sometimes caused hangs when the IMAP4 provider was used. The newest version of Redemption queues the notifications internally and returns immediately without blocking the MAPI notifications thread. The notifications are processed later (the order of events is preserved) when the main thread is idle.


•    Added RDOAddressEntry.GetMailTips method that allows to retrieve Out-Of-Office text, max message size, etc. for an Exchange mailbox. See RDOMailTips object for more information.

set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

Session.SkipAutodiscoverLookupInAD = true

set AdrEntry = Session.AddressBook.ResolveName("user@domain.demo")

set mailTips = AdrEntry.GetMailTips("me@domain.demo", "<My Password>") 'optional authentication parameters for EWS

MsgBox mailTips.MaxMessageSize   


•    Added RDOAddressEntry.GetOutOfOfficeAssistant method that allows to retrieve Out-Of-Office settings for an Exchange mailbox. OOF settings were previously implemented only through RDOExchangeMailboxStore.OutOfOfficeAssistant property, which required to open the mailbox first. Note that RDOAddressEntry.GetOutOfOfficeAssistant (unlike RDOAddressEntry.GetMailTips) requires impersonation privileges.

set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

Session.SkipAutodiscoverLookupInAD = true

set AdrrEntry = Session.AddressBook.ResolveName("user@domain.demo")

set oofSettings = AdrrEntry.GetOutOfOfficeAssistant("me@domain.demo", "<My Password>") 'optional authentication parameters for EWS

MsgBox oofSettings.StartTime     


•    Added RDOSession.SkipAutodiscoverLookupInAD property. Normally, Redemption methods that require autodiscover XML (such as LogonHostedExchangeMailbox, GetSharedMailbox, free/busy methods, etc.) look (each in a separate thread) for the autodiscover XML in a few predetermined HTTP locations with a timeout of 5 seconds. A lookup in the Active Directory however, especially if the remote server cannot be contacted through LDAP, can take a long time to time out. Set SkipAutodiscoverLookupInAD property to true if you are connecting to a hosted Exchange server. Leave it as false if you are connecting to an on-premises Exchange serer that does not publish autodiscover through HTTP.


•    Importing iCal files (RDOAppointmentItem.Impor(..., olICal) is now much faster for the appointments with a large (>100) list of attendees as attendees are now added in a single call.


•    Added RDORecipient.SMTPAddress property - jumps through a few hoops to retrieve the SMTP address while trying to avoid opening the underlying address entry. Similar to RDOAddressEntry.SMTPAddress, but attempts to retrieve the data from the message recipient table avoiding expensive calls to open the underlying address book object.


set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

set Item = Session.GetMessageFromID(Application.ActiveExplorer.Selection(1).EntryID)

for each Recip in Item.Recipients

    Debug.Print Recip.SMTPAddress



•    Added RDOAddressBook.ExchangeAddressToEntryId method. It allows to open and use address entries hidden from GAL. E.g. you can read the legacyDN attribute from the Active Directory and use it to call RDOAddressBook.ExchangeAddressToEntryId, which can then be used to open the GAL address entry (RDOSession.GetAddressEntryFromId) even if it is hidden, and pass it to RDOSession.GetSharedMailbox.


set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT


set addressEntry = Session.GetAddressEntryFromId(userEntryId)

set delegateStore = Session.GetSharedMailbox(addressEntry)

MsgBox delegateStore.GetDefaultFolder(olFolderInbox).Items.Count


Bug fixes


•   Loading Redemption under Outlook 2016 (when running outside of the outlook.exe process space) displayed the "The operating system is not presently configured to run this application" message box. All Redemption  objects were unusable.


•   RDOFolder2..GetActivitiesForTimeRange would always skip the last occurrence of recurring appointments for the time zones east of Greenwich.


•   RDOMail.Print would hang if used on a secondary thread that does not run the Windows message pump (GetMessage / TranslateMessage / DispatchMessage).


•   RDOUserProperty.Delete raised an error (Access violation) in the 64 bit version of Redemption (32 bit version functioned properly).


•   Reading the RDOMail.HTMLBody hanged for some HTML messages.


•   RDOStores.UnwrapStore always returned the original store passed as the parameter. This problem was specific to version 5.8.


•   Creating appointments (RDOAppointment object) that end at midnight UTC sometimes produced invalid appointments with the end time earlier than the start time.


•   RDOContactItems.Birthday property behavior was inconsistent with the Outlook Object Model - if both PidLidBirthdayLocal and PidTagBirthday were present and contained different values, OOM returned PidTagBirthday while Redemption preferred PidLidBirthdayLocal.


•   RDOAppointment object sometimes saved recurrence pattern with the pattern start and end dates one day off.


•   VCF (vCard) files created by Redemption (RDOContactItem.SaveAs(..., olVCard)) did not specify the code page for the Western European languages.


•   VCF (vCard) files created by Redemption (RDOContactItem.SaveAs(..., olVCard)) did not did not include the contact's picture if the contact was retrieved from an MSG file (RDOSession.GetMessageFromMsgFile).


•   RDOEncryptedMessage.GetDecryptedMessage raised "Not logged in" exception if the encrypted message was opened using RDOSession.GetMessageFromMsgFile without calling RDOSession.Logon. Signed messages function properly.


•   MAPIUtils.HrSetOneProp and Safe*Item.Fields[] etc. "dirtied" the underlying Outlook object by resetting the Subject property, which resulted in Outlook changing the ConversationIndex property. This version resets the MessageClass property, which does not seem to cause any side-effects.


•   Redemption did not use locally cached autodiscover XML when PreferLocalXML registry value was set .


•   RDOMail.Fields() did not understand some DASL property names in the urn:schemas:contacts.* namespace (such as urn:schemas:contacts:mailingpostaladdress).


•   RDOMail.Fields() did not decode "%" encoded DASL property names (e.g. http://schemas.microsoft.com/mapi/string/{00020329-0000-0000-C000-000000000046}/Test%20Name).


•   RDOSession.GetDefaultFolder(olFolderSentItems) sometimes raised an error when used on a secondary thread.


•   RDOSignature.Apply sometimes truncated the signature


•   RDOSelectFoldersDialog disabled the Ok button if both AllowMultipleSelection and ContainerClass were set and the user select the root store folder.


•   Exporting messages with an empty body in the MIME format using built-in Redemption MIME converter (RDOMail.SaveAs(..., olRfc822_Redemption)) sometimes hanged.


•   Exporting messages with a large (~100Mb) embedded messages attachments in the MIME format in 32 bit using built-in Redemption MIME converter (RDOMail.SaveAs(..., olRfc822_Redemption)) sometimes raised out-of-memory error.


•   Accessing RDOAppointmentItem.End property for the exceptional appointments returned from the RDOException.Item property sometimes crashed the calling process with a stack overflow.


•   RDOMail.SaveAs(.., olRfc822_Redemption) raised "Error in Storage.OpenStream: STG_E_FILENOTFOUND" for some RTF formatted messages.


•   RDOMail.SaveAs(.., olRfc822_Redemption) sometimes corrupted sender and recipient names when saving in the Korean, Japanese, or Chinese code pages (other codepages including UTF-8 were not affected).


•   RDOMail.SaveAs(.., olRfc822_Redemption) raised E_FAIL exception for the contacts (IPM.Contact) if there was no active MAPI session (e.g. RDOSession.Logon was not called and a message was opened using RDOsession.GetMessageFromMsgFile).


•   RDOSearchFolder.SearchCriteria.AsSQL returned an empty string for brand new search folders before RDOSearchFolder.Start was called even if RDOSearchFolder.SearchCriteria.AsSQL was explicitly set before.


•   RDOAppointmentItem.Import(.., olICal) did not set the Organizer / Sender / SentOnBehalfOf properties.


•   RDOStore.ValidateIPMTree under German locate named "Sent Items" folder "Gesendete Objekte" instead of "Gesendete Elemente" used by Outlook 2010 and newer.


•   Importing MIME messages using RDOMail.Import and the built-in Redemption converter (olRfc822_Redemption) imported the p7m attachment for the signed or encrypted messages twice .


•   RDOMail.HTMLBody property was slow in 64 bit for the plain text messages with a large body and a large number of characters that must be HTML-encoded (such as <, >, &).


•   When setting RDOMail.To / CC / BCC properties, Redemption would add everything following a double semicolon (;;) as a single recipient.


•   RDOIMAPAccount.SaveSentMessageFolder sometimes returned the profile's default Sent Items folder rather than the IMAP4 store's folder.







New features


•    Added RDORecipients.AddMultiple method. Adding recipients one at a time can severely degrade the performance as the time it takes to add a single recipient is proportional to the number of existing recipients in a message. RDORecipients.AddMultiple allows to add  hundreds of recipients in a single call with a performance improvement on the order of 100. RDORecipients.AddMultiple takes an array of string, RDORecipient, RDOAddressEntry, RDOContactItem or RDODistListItem objects..


dim Recips(2)

Recips(0) = "dmitry@dimastr.com"

Recips(1) = "test@dimastr.com"

Recips(2) = "redemption@dimastr.com"

set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

set Contacts = Session.GetDefaultFolder(olFolderContacts)

set Drafts = Session.GetDefaultFolder(olFolderDrafts)

set Msg = Drafts.Items.Add

Msg.Recipients.AddMultiple(Recips. olTo)


Msg.Subject = "test"



•    Added RDOAddressBook.GetAddressEntryFromStoreItem. Returns an instance of the RDOAddressEntry object from an RDOContactItem or RDODistListItem object. This is the counterpart of the GetContact and GetDistList methods implemented by the RDOAddressEntry object.


•    Added SafeExplorer.ActiveInlineResponseDiscard and SafeExplorer.ActiveInlineResponsePopOut methods. Note that ActiveInlineResponsePopOut  functionality is not exposed by the Outlook Object Model at all, and MailItem.Close cannot be used for the inline responses returned by the Explorer.ActiveInlineResponse property.


set sExplorer = CreateObject("Redemption.SafeExplorer")

sExplorer.Item = Application.ActiveExplorer



•    Added RDOSession.Signatures collection that allows to read, create, and modify Outlook signatures. See RDOSignatures and RDOSignature objects for more information.


set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

for each Signature in Session.Signatures

  Debug.Print Signature.Name



•    Added RDOAccount.ReplySignature and RDOAccount.NewMessageSignature properties.


set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

set Drafts = Session.GetDefaultFolder(olFolderDrafts)

set Msg = Drafts.Items.Add

Msg.To = "dmitry@dimastr.com"

Msg.Subject = "testing signatures"

Msg.HTMLBody = "<html><body>some <b>bold</b> message text</body></html>"

set Account = Session.Accounts.GetOrder(2).Item(1) 'first mail account

if Not (Account Is Nothing) Then

  set Signature = Account.NewMessageSignature

  if Not (Signature Is Nothing) Then

    Signature.ApplyTo Msg, false 'apply at the bottom

  End If

End If



•    Added RDOExchangeMailboxStore.GetOwaNicknames property that exposes Exchange 2010 nicknames (Exchange 2013 uses the same nicknames list as Outlook). The current version of Redemption provides read-only access to the OWA nicknames.


•    Added RDOCalendarOptions.TimeZone / WorkDays / WorkDayStart / WorkDayEnd properties. RDOCalendarOptions object can be accessed using the RDOExchangeMailbox.CalendarOptions property.


•    Added RDOSession.MAPIFormMgr property (returns RDOMAPIFormMgr object) that exposes MAPI forms available in the current MAPI session. See RDOMAPIFormMgr, RDOMAPIFormContainer and RDOMAPIFormInfo objects for more details.


set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

set PersonaFormContainer = Session.MAPIFormMgr.OpenLocalFormContainer

for each FormInfo in PersonaFormContainer

  Debug.Print FormInfo.DisplayName



•    Added RDOFolder2.Rules property. Exchange server rules  are already exposed on the store level (stored in the store's Inbox folder) through the RDOExchangeMailboxStore.Rules property. RDOFolder2.Rules adds support for rules on the folder level to support the Public Folders store, where rules can be set on any mail enabled folder.


•    Added RDOSession.CacheAutodiscoverXml and RDOSession.GetAutodiscoverXml methods that allow to cache autodiscover XML instead of  retrieving it each time it is needed. This allows to speed up Redemption methods that require  autodiscover, such as RDOSession.LogonHostedExchangeMailbox, RDOSession.GetArchiveMailbox, , RDOSession.GetSharedMailbox, RDOOutOfOfficeAssistant,


•    Redemption now retrieves autodiscover XML information from the Outlook cache (if available) first before attempting to download it from a remote server.


•    Exposed RDOAccount.JunkEmailOptions property. Starting with Outlook 2010, Junk Mail options are stored on the per-account basis for the POP3/SMTP accounts.


•    RDORule.RawConditions and RDORule.Actions properties are now settable (which means you can copy rules between two Exchange mailboxes). If any named property tags are used by the conditions or actions, they are properly reset to the appropriate named properties in the target mailbox.


•    Added RDORule.ProviderData property.


•    Exchange version of MAPI cannot handle Outlook Address Book (OAB) address entries (since it does not include the OAB provider). RDOSession.GetAddressEntryFromID can now handle such entries internally.


•    Added MinHeight and MinWidth properties to the RDOSelectFoldersDialog object.



Bug fixes


•   RDODistListItem.AddMember raised an error for the address entries pointing to address lists.


•   Saving HTML messages with more than 60 images in the olHTMLEmbeddedImages format (RDOMail.SaveAs) sometimes hanged.


•   MAPITable.ExecSQL sometimes raised an error (MAPI_E_CALL_FAILED) when both "TOP" and "WHERE" clauses were specified.


•   Importing MIME messages using RDOMail.Import and the built-in Redemption converter (olRfc822_Redemption) failed to correctly import messages with mixed Windows (0xD,0xA) and Unix (0xA) line breaks.


•   Exporting encrypted or signed MIME messages using built-in Redemption MIME converter (RDOMail.SaveAs(..., olRfc822_Redemption)) always specified smime-type=signed-data for both signed and encrypted messages.


•   RDOMail.Display(true) sometimes raised "Error in IMAPISession.ShowForm: MAPI_E_INVALID_PARAMETER"  exception when running under 64 bit version of Outlook under Windows 8.


•   64 bit version of Redemption raised E_UNEXPECTED exception instead of MAPI_E_USER_CANCEL from RDOAddressBook.ShowAddressBook when the address book dialog was cancelled.


•   RDOException.OriginalDate / StartDateTime / EndDateTime properties returned invalid values for some appointments created by the older (Outlook 2002 or below) versions of Outlook.


•   Importing MSG files (RDOMail.Import) without an RTF body (PR_HRML only) resulted in plain text messages under the online Exchange store (cached Exchange and PST stores were fine)


•   RDOMail.Parent property for the messages retrieved from a search folder (RDOSearchFolder) returned the search folder rather than the actual parent folder (RDOFolder).


•   If the IN operator was the only SQL operator used in MAPITable.ExecSQL  / RDOItems.Find / RDOItems.Restrict (e.g. "Categories IN ('one', 'two')" ), Redemption raised an exception "Assertion failed: Number of fields == 1"


•   RDOSession.GetMessageFromMsgFile always returned a generic RDOMail object instead of a more specific kind (e.g. RDOEncryptedMessage or RDOContactItem derived from RDOMail) for the Unicode MSG files under the standalone version of MAPI (Outlook version of MAPI always worked fine).


•   RDOEncryptedMessage.GetDecryptedMessage raised "Not logged in" exception if the encrypted/signed message was opened using RDOSession.GetMessageFromMsgFile ;e without calling RDOSession.Logon.


•   RDOTaskItem.MarkComplete / MarkCompleteEx sometimes set Start and DueDate properties one day too early.


•   RDORecurrencePattern.PatternEndDate sometimes was 1 day off.


•   Setting RDORecurrencePattern.PatternEndDate did not update the RDORecurrencePattern.Occurrences property.


•   RDOMail.Send did not raise a COM exception if IMessage::SubmitMessage MAPI call returned an error (e.g. when trying to send on behalf of a wrong user).


•   Creating a new appointment (RDOAppointmentItem) under online Office 365 mailbox store sometimes produced "Error in Set_ReminderSet: MAPI_E_INVALID_PARAMETER" exception.


•   Sending a meeting request/update (RDOAppointmentItem.Send) under online Office 365 mailbox store sometimes produced "Error in IMessage::SaveChanges: MAPI_E_INVALID_PARAMETER" exception.


•   RDOUserProperty.Delete or RDOUserProperty.Remove sometimes raised an access violation exception.


 •   Copying messages between Exchange and PST stores (RDOMail.CopyTo) sometimes did not preserve  created / last modified dates.


•   RDOAccounts.AddPOP3Account sometimes returned IOlkAccountManager.FindAccount: E_ACCT_NOT_FOUND exception


•   RDOSession.LogonHostedExchangeMailbox raised E_UNEXPECTED exception when it was used with empty user name and password instead of using the current user's credentials.


•   Unicode MSG files opened using RDOSession.GetMessageFromMsgFile under the standalone (Exchange) version of MAPI returned empty strings for the RDORecipient.Name / Address / etc. string properties.


•   Saving modified recurrence data for the RDOAppointmentItem or RDOTaskItem objects always reset the pattern start date to the start date of the appointment or task.






New features


•    Added CloseOnDoubleClick and  Left, Top, Width, Height properties to the RDOSelectFoldersDialog object.


•    Added RDOEncryptedMessage.CertificateIssuerName property.


•    Added RDOAddressList.Search property (returns RDOAddressListSearch object) that allows to set search criteria on a particular address list (represented by the RDOAddressList object). WARNING: among standard Outlook Address book providers, only the Exchange Address Book provider supports this feature. This method is necessary since most address book providers provide no or very little search support (unlike store providers).

set Session = CreateObject("Redemption.RDOSession")
Session.MAPIOBJECT = Application.Session.MAPIOBJECT
set AddrList = Session.Addressbook.GAL
set Search = AddrList.Search
Search.FirstName = "John"
Search.City = "Phoenix"
set AddressEntries = Search.GetResults
for each AddressEntry in AddressEntries
    Debug.Print AddressEntry.Name


•    Added RDOFolder.OnProgress event. It fires when RDOFolder.CopyTo is called and reflects the progress of the folder copy operation.


•    Added RDOAddressEntry.Owners property (corresponds to the ExchangeDistributionList.GetOwners method in the Outlook Object Model). This property is Exchange specific.

dim Session, ae, vOwner

set Session = CreateObject("Redemption.RDOSession")

Session.MAPIOBJECT = Application.Session.MAPIOBJECT

set ae = Session.AddressBook.Resolvename("DL List name>")

for each vOwner in ae.Owners

  debug.print vOwner.Name



•    Added SafeInspector.FocusEditor method. It allows to bring focus back to the editor from some other control (e.g. from a user control in an Inspector region).

set sInspector = CreateObject("Redemption.SafeInspector")
sInspector.Item = Application.ActiveInspector


•    Added SafeExplorer.ActiveInlineResponseSend method. Outlook Object Model does not allow to call MailItem.Send on a message returned by the Explorer.ActiveInlineResponse property. SafeExplorer.ActiveInlineResponseSend works around that limitation.

set oExplorer = Application.ActiveExplorer
set Item = oExplorer.ActiveInlineResponse
Item.UserProperties.Add("Redemption test", olText).Value = "test value"
set sExplorer = CreateObject("Redemption.SafeExplorer")
sExplorer.Item = oExplorer


•    Added RDOSearchFolder.IsContentIndexedSearch / IsStaticSearch properties (Exchange specific)


•    Importing MIME messages using RDOMail.Import now auto detects the message code page is one is not specified in the MIME headers.


•    Exporting MIME messages using built-in Redemption MIME converter (RDOMail.SaveAs(..., olRfc822_Redemption)) now exports contacts (MIME type text/vcard) and tasks (MIME type text/calendar). Appointments (MIME type text/calendar) were already exported before.




Bug fixes


•   RDOSession.LogonHostedExchangeMailbox method sometimes displayed credentials prompt (if RDOSession.ParentWindows property was set) or returned an error when connecting to an Exchange 2010 mailbox.


•   SafeAppointmentItem.Send sometimes caused memory heap corruption causing the application to crash. RDOAppointmentItem.Send functioned properly.


•   Importing MIME messages using RDOMail.Import and the built-in Redemption converter (olRfc822_Redemption) sometimes corrupted MAPI memory heap resulting in an application crash.


•   Importing MIME messages using RDOMail.Import and the built-in Redemption converter (olRfc822_Redemption) sometimes added ";" to the recipient email address.


•   Importing MIME messages using RDOMail.Import and the built-in Redemption converter (olRfc822_Redemption) failed to correctly import the DRM protected messages.


•   Importing MIME messages using RDOMail.Import sometimes failed to import sender related properties if only the sender email address was available.


•   Importing MIME messages using RDOMail.Import sometimes failed to import MIME messages with a TNEF part. This problem was specific to version 5.6.


•   Importing vCard files using RDOMail.Import raised an error if vCard included a PHOTO header with VALUE=URL attribute. The latest version downloads the image from the specified url and adds it as the contact picture.


•   Importing vTodo files using RDOMail.Import did not correctly import the reminder time if it was specified in UTC time zone.


•   Importing vTodo files using RDOMail.Import and saving vTodo files using RDOMail.SaveAs(..., olVTodo) did not correctly process the task's priority.


•   Importing some EML files to a standalone MSG file sometimes caused Outlook to display the "The operation failed because of a registry or installation problem. Restart Outlook and try again. If the problem persists, reinstall." error message when opening the resulting MSG file.


•   Exporting MIME messages using built-in Redemption MIME converter (RDOMail.SaveAs(..., olRfc822_Redemption)) failed to save existing empty headers stored in the PR_TRANSPORT_MESSAGE_HEADERS property.


•   Exporting MHTML messages  (RDOMail.SaveAs(..., olMHTML)) sometimes failed to save embedded images for the message that used to be in the RTF format with embedded OLE objects.


•   Exporting iCal messages  (RDOMail.SaveAs(..., olICal)) sometimes corrupted Unicode characters under non-Latin language operating systems (suck as Chinese versions of Windows).


•   Exporting iCal messages  (RDOMail.SaveAs(..., olICal)) sometimes did not correctly export exception dates (EXDATE iCal header) for the time zones east of GMT.


•   Exporting HTML messages  (RDOMail.SaveAs(..., olHTML)) sometimes raised Index out of bounds exception for the messages with binary (PT_BINARY) user properties.


•   Exporting tasks in the vTodo format  (RDOMail.SaveAs(..., olVToDo)) did not export the PERCENT-COMPLETE header if RDOTaskItem.PercentComplete property was 0.


•   Exporting tasks in the vTodo format  (RDOMail.SaveAs(..., olVToDo)) did not export the RRULE and DTSTART properties in the TIMEZONE part.


•   RDOMail.Import did not correctly import monthly BYDAY recurrences with a modifier (e.g. RRULE:FREQ=MONTHLY;INTERVAL=1;BYDAY=3WE)


•   RDOAppointmentItem.Start and RDOException.StartDateTime properties sometimes returned wrong values for the appointment exceptions created in a time zone different from teh local time zone.


•   RDORecurrencePattern.GetOccurence hanged for non-recurring appointments or tasks.


•   RDOExchangeMailboxStore.IsCached / RDOExchangePublicFoldersStore.IsCached property always returned the value for the primary mailbox store in the profile even if there were multiple mailboxes in the profile.


•   RDOReminders.Count sometimes returned 0 for the delegate Exchange stores.


•   RDOSession.GetArchiveMailbox did not use the credentials passed to RDOSession.LogonHostedExchangeMailbox or set using RDOSession.ExchangeConnectionProperties.


•   RDOSelectFoldersDialog did not adjust the position of the folder tree view if the RDOSelectFoldersDialog.LabelCaption property contained line breaks.


•   Setting RDORecipient.Fields[] to an invalid value (e.g. setting a PT_BINARY property to a variant other than an array or a hex string) sometimes raised an access violation instead of throwing a meaningful error.


•   RDOTaskItem.Send sometimes caused an access violation if one of the task recipients could not be resolved.


•   Reading named MAPI properties using RDOMail.Fields[] raised an exception if the property did not exist instead of returning an empty variant for the read-only messages (e.g. messages created on top of read-only MSG files or opened in the read-only mode from an Outlook folder).


•   Search folders created by Redemption (RDOStore2.Searches and RDOFolders.AddSearchFolder) did not include any results under Exchange 2013 online store. This was due to the NON_CONTENT_INDEXED_SEARCH flag used (still needed for Exchange 2010).


•   Redemption cached the value of the local time zone on start up and did not refresh it even if the local Windows time zone was changed


•   Retrieving RDOStore.Reminders sometimes caused an error.


•   RDOSession.LogonHostedExchangeMailbox sometimes showed the credentials prompt even though the correct credentials were specified.


•   SafeInspector.SelText property sometimes returned an empty string even if text was selected in the inspector.


•   RDOSession.GetFolderFromPath sometimes returned errors if the store name contained encoded characters (such as %, \, etc.)


•   Accessing RDOSession.Accounts property returned "Error in IOlkAccountManager.Init: 0x800C8001" exception under Outlook 2013 Click-To-Run if an older version of Outlook (e.g. 2007 or 2010) was also installed.


•   RDOMail.Reply / ReplyAll / Forward always used Arial as the font for the new message even if a different font was specified in Outlook options.


•   Accessing RDOSession.Accouns collection under a brand new profile (never used by Outlook) raised "Error in IOlkAccountManager.Init : MAPI_E_NOT_ENOUGH_MEMORY" exception under Outlook 2007. The same error was raised in other versions of Outlook if the global profile section was missing or corrupt.






New features



Bug fixes






This release mostly deals with Outlook 2013 support as well as general bug fixes.

Note that if you are using Outlook 2013 click-to-run (C2R) setup (e.g. Office 2013 downloaded from outlook.com), you may receive errors when using Safe*Item objects or when setting the RDOSession.MAPIOBJECT property in a process other than outlook.exe. To fix these MAPI marshalling errors, please download Outlook_2013_C2R_fix.ZIP.


New features


Bug fixes:


September 2, 2012



New features:




Bug fixes:






New features:


Bug fixes:





Bug fixes:




New features and major stability improvements in the 64 bit version and under the RedemptionLoader.

New features:

Bug fixes:






New features:


Bug fixes:





New features:



Bug fixes:





New features:

Bug fixes:





New features:

Bug fixes:





New features:

Bug fixes:




New features:

Bug fixes:


Version This version does not introduce any new functionality, but only fixes several issues introduced in the previous versions.

Bug fixes




New features

Bug fixes:




New features

Bug fixes:



New features


Bug fixes:













The primary goal of this intermediate release was stability under every supported version of Outlook (98 through 2003) in every possible configuration, language pack or service pack whether Redemption is used in a COM add-in or a in separate exe. There were dozens of bugs fixed ranging from access violations to inconsistent behavior.

The only three new features are: