1 files changed, 437 insertions, 0 deletions

diff --git a/src/WixToolset.Core.WindowsInstaller/Ole32/Storage.cs b/src/WixToolset.Core.WindowsInstaller/Ole32/Storage.cs
new file mode 100644
index 00000000..c6a43bc4
--- /dev/null
+++ b/src/WixToolset.Core.WindowsInstaller/Ole32/Storage.cs
@@ -0,0 +1,437 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Ole32
+{
+    using System;
+    using System.Runtime.InteropServices;
+    using FILETIME = System.Runtime.InteropServices.ComTypes.FILETIME;
+    using STATSTG = System.Runtime.InteropServices.ComTypes.STATSTG;
+
+    /// <summary>
+    /// Specifies the access mode to use when opening, creating, or deleting a storage object.
+    /// </summary>
+    internal enum StorageMode
+    {
+        /// <summary>
+        /// Indicates that the object is read-only, meaning that modifications cannot be made.
+        /// </summary>
+        Read = 0x0,
+
+        /// <summary>
+        /// Enables you to save changes to the object, but does not permit access to its data.
+        /// </summary>
+        Write = 0x1,
+
+        /// <summary>
+        /// Enables access and modification of object data.
+        /// </summary>
+        ReadWrite = 0x2,
+
+        /// <summary>
+        /// Specifies that subsequent openings of the object are not denied read or write access.
+        /// </summary>
+        ShareDenyNone = 0x40,
+
+        /// <summary>
+        /// Prevents others from subsequently opening the object in Read mode.
+        /// </summary>
+        ShareDenyRead = 0x30,
+
+        /// <summary>
+        /// Prevents others from subsequently opening the object for Write or ReadWrite access.
+        /// </summary>
+        ShareDenyWrite = 0x20,
+
+        /// <summary>
+        /// Prevents others from subsequently opening the object in any mode.
+        /// </summary>
+        ShareExclusive = 0x10,
+
+        /// <summary>
+        /// Opens the storage object with exclusive access to the most recently committed version.
+        /// </summary>
+        Priority = 0x40000,
+
+        /// <summary>
+        /// Indicates that an existing storage object or stream should be removed before the new object replaces it.
+        /// </summary>
+        Create = 0x1000,
+    }
+
+    /// <summary>
+    /// Wrapper for the compound storage file APIs.
+    /// </summary>
+    internal sealed class Storage : IDisposable
+    {
+        private bool disposed;
+        private IStorage storage;
+
+        /// <summary>
+        /// Instantiate a new Storage.
+        /// </summary>
+        /// <param name="storage">The native storage interface.</param>
+        private Storage(IStorage storage)
+        {
+            this.storage = storage;
+        }
+
+        /// <summary>
+        /// Storage destructor.
+        /// </summary>
+        ~Storage()
+        {
+            this.Dispose();
+        }
+
+        /// <summary>
+        /// The IEnumSTATSTG interface enumerates an array of STATSTG structures.
+        /// </summary>
+        [ComImport, Guid("0000000d-0000-0000-C000-000000000046"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+        public interface IEnumSTATSTG
+        {
+            /// <summary>
+            /// Gets a specified number of STATSTG structures.
+            /// </summary>
+            /// <param name="celt">The number of STATSTG structures requested.</param>
+            /// <param name="rgelt">An array of STATSTG structures returned.</param>
+            /// <param name="pceltFetched">The number of STATSTG structures retrieved in the rgelt parameter.</param>
+            /// <returns>The error code.</returns>
+            [PreserveSig]
+            uint Next(uint celt, [MarshalAs(UnmanagedType.LPArray), Out] STATSTG[] rgelt, out uint pceltFetched);
+
+            /// <summary>
+            /// Skips a specified number of STATSTG structures in the enumeration sequence.
+            /// </summary>
+            /// <param name="celt">The number of STATSTG structures to skip.</param>
+            void Skip(uint celt);
+
+            /// <summary>
+            /// Resets the enumeration sequence to the beginning of the STATSTG structure array.
+            /// </summary>
+            void Reset();
+
+            /// <summary>
+            /// Creates a new enumerator that contains the same enumeration state as the current STATSTG structure enumerator.
+            /// </summary>
+            /// <returns>The cloned IEnumSTATSTG interface.</returns>
+            [return: MarshalAs(UnmanagedType.Interface)]
+            IEnumSTATSTG Clone();
+        }
+
+        /// <summary>
+        /// The IStorage interface supports the creation and management of structured storage objects.
+        /// </summary>
+        [ComImport, Guid("0000000b-0000-0000-C000-000000000046"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+        private interface IStorage
+        {
+            /// <summary>
+            /// Creates and opens a stream object with the specified name contained in this storage object.
+            /// </summary>
+            /// <param name="pwcsName">The name of the newly created stream.</param>
+            /// <param name="grfMode">Specifies the access mode to use when opening the newly created stream.</param>
+            /// <param name="reserved1">Reserved for future use; must be zero.</param>
+            /// <param name="reserved2">Reserved for future use; must be zero.</param>
+            /// <param name="ppstm">On return, pointer to the location of the new IStream interface pointer.</param>
+            void CreateStream(string pwcsName, uint grfMode, uint reserved1, uint reserved2, out IStream ppstm);
+
+            /// <summary>
+            /// Opens an existing stream object within this storage object using the specified access permissions in grfMode.
+            /// </summary>
+            /// <param name="pwcsName">The name of the stream to open.</param>
+            /// <param name="reserved1">Reserved for future use; must be NULL.</param>
+            /// <param name="grfMode">Specifies the access mode to be assigned to the open stream.</param>
+            /// <param name="reserved2">Reserved for future use; must be zero.</param>
+            /// <param name="ppstm">A pointer to IStream pointer variable that receives the interface pointer to the newly opened stream object.</param>
+            void OpenStream(string pwcsName, IntPtr reserved1, uint grfMode, uint reserved2, out IStream ppstm);
+
+            /// <summary>
+            /// Creates and opens a new storage object nested within this storage object with the specified name in the specified access mode.
+            /// </summary>
+            /// <param name="pwcsName">The name of the newly created storage object.</param>
+            /// <param name="grfMode">A value that specifies the access mode to use when opening the newly created storage object.</param>
+            /// <param name="reserved1">Reserved for future use; must be zero.</param>
+            /// <param name="reserved2">Reserved for future use; must be zero.</param>
+            /// <param name="ppstg">A pointer, when successful, to the location of the IStorage pointer to the newly created storage object.</param>
+            void CreateStorage(string pwcsName, uint grfMode, uint reserved1, uint reserved2, out IStorage ppstg);
+
+            /// <summary>
+            /// Opens an existing storage object with the specified name in the specified access mode.
+            /// </summary>
+            /// <param name="pwcsName">The name of the storage object to open.</param>
+            /// <param name="pstgPriority">Must be NULL.</param>
+            /// <param name="grfMode">Specifies the access mode to use when opening the storage object.</param>
+            /// <param name="snbExclude">Must be NULL.</param>
+            /// <param name="reserved">Reserved for future use; must be zero.</param>
+            /// <param name="ppstg">When successful, pointer to the location of an IStorage pointer to the opened storage object.</param>
+            void OpenStorage(string pwcsName, IStorage pstgPriority, uint grfMode, IntPtr snbExclude, uint reserved, out IStorage ppstg);
+
+            /// <summary>
+            /// Copies the entire contents of an open storage object to another storage object.
+            /// </summary>
+            /// <param name="ciidExclude">The number of elements in the array pointed to by rgiidExclude.</param>
+            /// <param name="rgiidExclude">An array of interface identifiers (IIDs) that either the caller knows about and does not want
+            /// copied or that the storage object does not support, but whose state the caller will later explicitly copy.</param>
+            /// <param name="snbExclude">A string name block (refer to SNB) that specifies a block of storage or stream objects that are not to be copied to the destination.</param>
+            /// <param name="pstgDest">A pointer to the open storage object into which this storage object is to be copied.</param>
+            void CopyTo(uint ciidExclude, IntPtr rgiidExclude, IntPtr snbExclude, IStorage pstgDest);
+
+            /// <summary>
+            /// Copies or moves a substorage or stream from this storage object to another storage object.
+            /// </summary>
+            /// <param name="pwcsName">The name of the element in this storage object to be moved or copied.</param>
+            /// <param name="pstgDest">IStorage pointer to the destination storage object.</param>
+            /// <param name="pwcsNewName">The new name for the element in its new storage object.</param>
+            /// <param name="grfFlags">Specifies whether the operation should be a move (STGMOVE_MOVE) or a copy (STGMOVE_COPY).</param>
+            void MoveElementTo(string pwcsName, IStorage pstgDest, string pwcsNewName, uint grfFlags);
+
+            /// <summary>
+            /// Reflects changes for a transacted storage object to the parent level.
+            /// </summary>
+            /// <param name="grfCommitFlags">Controls how the changes are committed to the storage object.</param>
+            void Commit(uint grfCommitFlags);
+
+            /// <summary>
+            /// Discards all changes that have been made to the storage object since the last commit operation.
+            /// </summary>
+            void Revert();
+
+            /// <summary>
+            /// Returns an enumerator object that can be used to enumerate the storage and stream objects contained within this storage object.
+            /// </summary>
+            /// <param name="reserved1">Reserved for future use; must be zero.</param>
+            /// <param name="reserved2">Reserved for future use; must be NULL.</param>
+            /// <param name="reserved3">Reserved for future use; must be zero.</param>
+            /// <param name="ppenum">Pointer to IEnumSTATSTG* pointer variable that receives the interface pointer to the new enumerator object.</param>
+            void EnumElements(uint reserved1, IntPtr reserved2, uint reserved3, out IEnumSTATSTG ppenum);
+
+            /// <summary>
+            /// Removes the specified storage or stream from this storage object.
+            /// </summary>
+            /// <param name="pwcsName">The name of the storage or stream to be removed.</param>
+            void DestroyElement(string pwcsName);
+
+            /// <summary>
+            /// Renames the specified storage or stream in this storage object.
+            /// </summary>
+            /// <param name="pwcsOldName">The name of the substorage or stream to be changed.</param>
+            /// <param name="pwcsNewName">The new name for the specified substorage or stream.</param>
+            void RenameElement(string pwcsOldName, string pwcsNewName);
+
+            /// <summary>
+            /// Sets the modification, access, and creation times of the indicated storage element, if supported by the underlying file system.
+            /// </summary>
+            /// <param name="pwcsName">The name of the storage object element whose times are to be modified.</param>
+            /// <param name="pctime">Either the new creation time for the element or NULL if the creation time is not to be modified.</param>
+            /// <param name="patime">Either the new access time for the element or NULL if the access time is not to be modified.</param>
+            /// <param name="pmtime">Either the new modification time for the element or NULL if the modification time is not to be modified.</param>
+            void SetElementTimes(string pwcsName, FILETIME pctime, FILETIME patime, FILETIME pmtime);
+
+            /// <summary>
+            /// Assigns the specified CLSID to this storage object.
+            /// </summary>
+            /// <param name="clsid">The CLSID that is to be associated with the storage object.</param>
+            void SetClass(Guid clsid);
+
+            /// <summary>
+            /// Stores up to 32 bits of state information in this storage object.
+            /// </summary>
+            /// <param name="grfStateBits">Specifies the new values of the bits to set.</param>
+            /// <param name="grfMask">A binary mask indicating which bits in grfStateBits are significant in this call.</param>
+            void SetStateBits(uint grfStateBits, uint grfMask);
+
+            /// <summary>
+            /// Returns the STATSTG structure for this open storage object.
+            /// </summary>
+            /// <param name="pstatstg">On return, pointer to a STATSTG structure where this method places information about the open storage object.</param>
+            /// <param name="grfStatFlag">Specifies that some of the members in the STATSTG structure are not returned, thus saving a memory allocation operation.</param>
+            void Stat(out STATSTG pstatstg, uint grfStatFlag);
+        }
+
+        /// <summary>
+        /// The IStream interface lets you read and write data to stream objects.
+        /// </summary>
+        [ComImport, Guid("0000000c-0000-0000-C000-000000000046"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+        private interface IStream
+        {
+            /// <summary>
+            /// Reads a specified number of bytes from the stream object into memory starting at the current seek pointer.
+            /// </summary>
+            /// <param name="pv">A pointer to the buffer which the stream data is read into.</param>
+            /// <param name="cb">The number of bytes of data to read from the stream object.</param>
+            /// <param name="pcbRead">A pointer to a ULONG variable that receives the actual number of bytes read from the stream object.</param>
+            void Read([Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] byte[] pv, int cb, IntPtr pcbRead);
+
+            /// <summary>
+            /// Writes a specified number of bytes into the stream object starting at the current seek pointer.
+            /// </summary>
+            /// <param name="pv">A pointer to the buffer that contains the data that is to be written to the stream.</param>
+            /// <param name="cb">The number of bytes of data to attempt to write into the stream.</param>
+            /// <param name="pcbWritten">A pointer to a ULONG variable where this method writes the actual number of bytes written to the stream object.</param>
+            void Write([MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] byte[] pv, int cb, IntPtr pcbWritten);
+
+            /// <summary>
+            /// Changes the seek pointer to a new location relative to the beginning of the stream, the end of the stream, or the current seek pointer.
+            /// </summary>
+            /// <param name="dlibMove">The displacement to be added to the location indicated by the dwOrigin parameter.</param>
+            /// <param name="dwOrigin">The origin for the displacement specified in dlibMove.</param>
+            /// <param name="plibNewPosition">A pointer to the location where this method writes the value of the new seek pointer from the beginning of the stream.</param>
+            void Seek(long dlibMove, int dwOrigin, IntPtr plibNewPosition);
+
+            /// <summary>
+            /// Changes the size of the stream object.
+            /// </summary>
+            /// <param name="libNewSize">Specifies the new size of the stream as a number of bytes.</param>
+            void SetSize(long libNewSize);
+
+            /// <summary>
+            /// Copies a specified number of bytes from the current seek pointer in the stream to the current seek pointer in another stream.
+            /// </summary>
+            /// <param name="pstm">A pointer to the destination stream.</param>
+            /// <param name="cb">The number of bytes to copy from the source stream.</param>
+            /// <param name="pcbRead">A pointer to the location where this method writes the actual number of bytes read from the source.</param>
+            /// <param name="pcbWritten">A pointer to the location where this method writes the actual number of bytes written to the destination.</param>
+            void CopyTo(IStream pstm, long cb, IntPtr pcbRead, IntPtr pcbWritten);
+
+            /// <summary>
+            /// Ensures that any changes made to a stream object open in transacted mode are reflected in the parent storage object.
+            /// </summary>
+            /// <param name="grfCommitFlags">Controls how the changes for the stream object are committed.</param>
+            void Commit(int grfCommitFlags);
+
+            /// <summary>
+            /// Discards all changes that have been made to a transacted stream since the last call to IStream::Commit.
+            /// </summary>
+            void Revert();
+
+            /// <summary>
+            /// Restricts access to a specified range of bytes in the stream.
+            /// </summary>
+            /// <param name="libOffset">Integer that specifies the byte offset for the beginning of the range.</param>
+            /// <param name="cb">Integer that specifies the length of the range, in bytes, to be restricted.</param>
+            /// <param name="dwLockType">Specifies the restrictions being requested on accessing the range.</param>
+            void LockRegion(long libOffset, long cb, int dwLockType);
+
+            /// <summary>
+            /// Removes the access restriction on a range of bytes previously restricted with IStream::LockRegion.
+            /// </summary>
+            /// <param name="libOffset">Specifies the byte offset for the beginning of the range.</param>
+            /// <param name="cb">Specifies, in bytes, the length of the range to be restricted.</param>
+            /// <param name="dwLockType">Specifies the access restrictions previously placed on the range.</param>
+            void UnlockRegion(long libOffset, long cb, int dwLockType);
+
+            /// <summary>
+            /// Retrieves the STATSTG structure for this stream.
+            /// </summary>
+            /// <param name="pstatstg">Pointer to a STATSTG structure where this method places information about this stream object.</param>
+            /// <param name="grfStatFlag">Specifies that this method does not return some of the members in the STATSTG structure, thus saving a memory allocation operation.</param>
+            void Stat(out STATSTG pstatstg, int grfStatFlag);
+
+            /// <summary>
+            /// Creates a new stream object that references the same bytes as the original stream but provides a separate seek pointer to those bytes.
+            /// </summary>
+            /// <param name="ppstm">When successful, pointer to the location of an IStream pointer to the new stream object.</param>
+            void Clone(out IStream ppstm);
+        }
+
+        /// <summary>
+        /// Creates a new compound file storage object.
+        /// </summary>
+        /// <param name="storageFile">The compound file being created.</param>
+        /// <param name="mode">Specifies the access mode to use when opening the new storage object.</param>
+        /// <returns>The created Storage object.</returns>
+        public static Storage CreateDocFile(string storageFile, StorageMode mode)
+        {
+            IStorage storage = NativeMethods.StgCreateDocfile(storageFile, (uint)mode, 0);
+
+            return new Storage(storage);
+        }
+
+        /// <summary>
+        /// Opens an existing root storage object in the file system.
+        /// </summary>
+        /// <param name="storageFile">The file that contains the storage object to open.</param>
+        /// <param name="mode">Specifies the access mode to use to open the storage object.</param>
+        /// <returns>The created Storage object.</returns>
+        public static Storage Open(string storageFile, StorageMode mode)
+        {
+            IStorage storage = NativeMethods.StgOpenStorage(storageFile, IntPtr.Zero, (uint)mode, IntPtr.Zero, 0);
+
+            return new Storage(storage);
+        }
+
+        /// <summary>
+        /// Copies the entire contents of this open storage object into another Storage object.
+        /// </summary>
+        /// <param name="destinationStorage">The destination Storage object.</param>
+        public void CopyTo(Storage destinationStorage)
+        {
+            this.storage.CopyTo(0, IntPtr.Zero, IntPtr.Zero, destinationStorage.storage);
+        }
+
+        /// <summary>
+        /// Opens an existing Storage object with the specified name according to the specified access mode.
+        /// </summary>
+        /// <param name="name">The name of the Storage object.</param>
+        /// <returns>The opened Storage object.</returns>
+        public Storage OpenStorage(string name)
+        {
+            IStorage subStorage;
+
+            this.storage.OpenStorage(name, null, (uint)(StorageMode.Read | StorageMode.ShareExclusive), IntPtr.Zero, 0, out subStorage);
+
+            return new Storage(subStorage);
+        }
+
+        /// <summary>
+        /// Disposes the managed and unmanaged objects in this object.
+        /// </summary>
+        public void Dispose()
+        {
+            if (!this.disposed)
+            {
+                Marshal.ReleaseComObject(this.storage);
+
+                this.disposed = true;
+            }
+
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// The native methods.
+        /// </summary>
+        private sealed class NativeMethods
+        {
+            /// <summary>
+            /// Protect the constructor since this class only contains static methods.
+            /// </summary>
+            private NativeMethods()
+            {
+            }
+
+            /// <summary>
+            /// Creates a new compound file storage object.
+            /// </summary>
+            /// <param name="pwcsName">The name for the compound file being created.</param>
+            /// <param name="grfMode">Specifies the access mode to use when opening the new storage object.</param>
+            /// <param name="reserved">Reserved for future use; must be zero.</param>
+            /// <returns>A pointer to the location of the IStorage pointer to the new storage object.</returns>
+            [DllImport("ole32.dll", PreserveSig = false)]
+            [return: MarshalAs(UnmanagedType.Interface)]
+            internal static extern IStorage StgCreateDocfile([MarshalAs(UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint reserved);
+
+            /// <summary>
+            /// Opens an existing root storage object in the file system.
+            /// </summary>
+            /// <param name="pwcsName">The file that contains the storage object to open.</param>
+            /// <param name="pstgPriority">Most often NULL.</param>
+            /// <param name="grfMode">Specifies the access mode to use to open the storage object.</param>
+            /// <param name="snbExclude">If not NULL, pointer to a block of elements in the storage to be excluded as the storage object is opened.</param>
+            /// <param name="reserved">Indicates reserved for future use; must be zero.</param>
+            /// <returns>A pointer to a IStorage* pointer variable that receives the interface pointer to the opened storage.</returns>
+            [DllImport("ole32.dll", PreserveSig = false)]
+            [return: MarshalAs(UnmanagedType.Interface)]
+            internal static extern IStorage StgOpenStorage([MarshalAs(UnmanagedType.LPWStr)] string pwcsName, IntPtr pstgPriority, uint grfMode, IntPtr snbExclude, uint reserved);
+        }
+    }
+}