1 files changed, 801 insertions, 0 deletions

diff --git a/src/dtf/WixToolset.Dtf.WindowsInstaller/ProductInstallation.cs b/src/dtf/WixToolset.Dtf.WindowsInstaller/ProductInstallation.cs
new file mode 100644
index 00000000..27739e17
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.WindowsInstaller/ProductInstallation.cs
@@ -0,0 +1,801 @@
+// 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.Dtf.WindowsInstaller
+{
+    using System;
+    using System.Text;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Diagnostics.CodeAnalysis;
+
+    /// <summary>
+    /// Represents a unique instance of a product that
+    /// is either advertised, installed or unknown.
+    /// </summary>
+    public class ProductInstallation : Installation
+    {
+        /// <summary>
+        /// Gets the set of all products with a specified upgrade code. This method lists the
+        /// currently installed and advertised products that have the specified UpgradeCode
+        /// property in their Property table.
+        /// </summary>
+        /// <param name="upgradeCode">Upgrade code of related products</param>
+        /// <returns>Enumeration of product codes</returns>
+        /// <remarks><p>
+        /// Win32 MSI API:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msienumrelatedproducts.asp">MsiEnumRelatedProducts</a>
+        /// </p></remarks>
+        public static IEnumerable<ProductInstallation> GetRelatedProducts(string upgradeCode)
+        {
+            StringBuilder buf = new StringBuilder(40);
+            for (uint i = 0; true; i++)
+            {
+                uint ret = NativeMethods.MsiEnumRelatedProducts(upgradeCode, 0, i, buf);
+                if (ret == (uint) NativeMethods.Error.NO_MORE_ITEMS) break;
+                if (ret != 0)
+                {
+                    throw InstallerException.ExceptionFromReturnCode(ret);
+                }
+                yield return new ProductInstallation(buf.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Enumerates all product installations on the system.
+        /// </summary>
+        /// <returns>An enumeration of product objects.</returns>
+        /// <remarks><p>
+        /// Win32 MSI API:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msienumproducts.asp">MsiEnumProducts</a>,
+        /// </p></remarks>
+        public static IEnumerable<ProductInstallation> AllProducts
+        {
+            get
+            {
+                return GetProducts(null, null, UserContexts.All);
+            }
+        }
+
+        /// <summary>
+        /// Enumerates product installations based on certain criteria.
+        /// </summary>
+        /// <param name="productCode">ProductCode (GUID) of the product instances to be enumerated. Only
+        /// instances of products within the scope of the context specified by the
+        /// <paramref name="userSid"/> and <paramref name="context"/> parameters will be
+        /// enumerated. This parameter may be set to null to enumerate all products in the specified
+        /// context.</param>
+        /// <param name="userSid">Specifies a security identifier (SID) that restricts the context
+        /// of enumeration. A SID value other than s-1-1-0 is considered a user SID and restricts
+        /// enumeration to the current user or any user in the system. The special SID string
+        /// s-1-1-0 (Everyone) specifies enumeration across all users in the system. This parameter
+        /// can be set to null to restrict the enumeration scope to the current user. When
+        /// <paramref name="context"/> is set to the machine context only,
+        /// <paramref name="userSid"/> must be null.</param>
+        /// <param name="context">Specifies the user context.</param>
+        /// <returns>An enumeration of product objects for enumerated product instances.</returns>
+        /// <remarks><p>
+        /// Win32 MSI API:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msienumproductsex.asp">MsiEnumProductsEx</a>
+        /// </p></remarks>
+        public static IEnumerable<ProductInstallation> GetProducts(
+            string productCode, string userSid, UserContexts context)
+        {
+            StringBuilder buf = new StringBuilder(40);
+            UserContexts targetContext;
+            StringBuilder targetSidBuf = new StringBuilder(40);
+            for (uint i = 0; ; i++)
+            {
+                uint targetSidBufSize = (uint) targetSidBuf.Capacity;
+                uint ret = NativeMethods.MsiEnumProductsEx(
+                    productCode,
+                    userSid,
+                    context,
+                    i,
+                    buf,
+                    out targetContext,
+                    targetSidBuf,
+                    ref targetSidBufSize);
+                if (ret == (uint) NativeMethods.Error.MORE_DATA)
+                {
+                    targetSidBuf.Capacity = (int) ++targetSidBufSize;
+                    ret = NativeMethods.MsiEnumProductsEx(
+                        productCode,
+                        userSid,
+                        context,
+                        i,
+                        buf,
+                        out targetContext,
+                        targetSidBuf,
+                        ref targetSidBufSize);
+                }
+
+                if (ret == (uint) NativeMethods.Error.NO_MORE_ITEMS)
+                {
+                    break;
+                }
+
+                if (ret != 0)
+                {
+                    throw InstallerException.ExceptionFromReturnCode(ret);
+                }
+
+                yield return new ProductInstallation(
+                    buf.ToString(),
+                    targetSidBuf.ToString(),
+                    targetContext);
+            }
+        }
+
+        private IDictionary<string, string> properties;
+
+        /// <summary>
+        /// Creates a new object for accessing information about a product installation on the current system.
+        /// </summary>
+        /// <param name="productCode">ProductCode (GUID) of the product.</param>
+        /// <remarks><p>
+        /// All available user contexts will be queried.
+        /// </p></remarks>
+        public ProductInstallation(string productCode)
+            : this(productCode, null, UserContexts.All)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new object for accessing information about a product installation on the current system.
+        /// </summary>
+        /// <param name="productCode">ProductCode (GUID) of the product.</param>
+        /// <param name="userSid">The specific user, when working in a user context.  This
+        /// parameter may be null to indicate the current user.  The parameter must be null
+        /// when working in a machine context.</param>
+        /// <param name="context">The user context. The calling process must have administrative
+        /// privileges to get information for a product installed for a user other than the
+        /// current user.</param>
+        public ProductInstallation(string productCode, string userSid, UserContexts context)
+            : base(productCode, userSid, context)
+        {
+            if (String.IsNullOrEmpty(productCode))
+            {
+                throw new ArgumentNullException("productCode");
+            }
+        }
+
+        internal ProductInstallation(IDictionary<string, string> properties)
+            : base(properties["ProductCode"], null, UserContexts.None)
+        {
+            this.properties = properties;
+        }
+
+        /// <summary>
+        /// Gets the set of published features for the product.
+        /// </summary>
+        /// <returns>Enumeration of published features for the product.</returns>
+        /// <exception cref="InstallerException">The installer configuration data is corrupt</exception>
+        /// <remarks><p>
+        /// Because features are not ordered, any new feature has an arbitrary index, meaning
+        /// this property can return features in any order.
+        /// </p><p>
+        /// Win32 MSI API:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msienumfeatures.asp">MsiEnumFeatures</a>
+        /// </p></remarks>
+        public IEnumerable<FeatureInstallation> Features
+        {
+            get
+            {
+                StringBuilder buf = new StringBuilder(256);
+                for (uint i = 0; ; i++)
+                {
+                    uint ret = NativeMethods.MsiEnumFeatures(this.ProductCode, i, buf, null);
+
+                    if (ret != 0)
+                    {
+                        break;
+                    }
+
+                    yield return new FeatureInstallation(buf.ToString(), this.ProductCode);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the ProductCode (GUID) of the product.
+        /// </summary>
+        public string ProductCode
+        {
+            get { return this.InstallationCode; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether this product is installed on the current system.
+        /// </summary>
+        public override bool IsInstalled
+        {
+            get
+            {
+                return (this.State == InstallState.Default);
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether this product is advertised on the current system.
+        /// </summary>
+        public bool IsAdvertised
+        {
+            get
+            {
+                return (this.State == InstallState.Advertised);
+            }
+        }
+
+        /// <summary>
+        /// Checks whether the product is installed with elevated privileges. An application is called
+        /// a "managed application" if elevated (system) privileges are used to install the application.
+        /// </summary>
+        /// <returns>True if the product is elevated; false otherwise</returns>
+        /// <remarks><p>
+        /// Note that this property does not take into account policies such as AlwaysInstallElevated,
+        /// but verifies that the local system owns the product's registry data.
+        /// </p></remarks>
+        public bool IsElevated
+        {
+            get
+            {
+                bool isElevated;
+                uint ret = NativeMethods.MsiIsProductElevated(this.ProductCode, out isElevated);
+                if (ret != 0)
+                {
+                    throw InstallerException.ExceptionFromReturnCode(ret);
+                }
+                return isElevated;
+            }
+        }
+
+        /// <summary>
+        /// Gets the source list of this product installation.
+        /// </summary>
+        public override SourceList SourceList
+        {
+            get
+            {
+                return this.properties == null ? base.SourceList : null;
+            }
+        }
+
+        internal InstallState State
+        {
+            get
+            {
+                if (this.properties != null)
+                {
+                    return InstallState.Unknown;
+                }
+                else
+                {
+                    int installState = NativeMethods.MsiQueryProductState(this.ProductCode);
+                    return (InstallState) installState;
+                }
+            }
+        }
+
+        internal override int InstallationType
+        {
+            get
+            {
+                const int MSICODE_PRODUCT = 0x00000000;
+                return MSICODE_PRODUCT;
+            }
+        }
+
+        /// <summary>
+        /// The support link.
+        /// </summary>
+        public string HelpLink
+        {
+            get
+            {
+                return this["HelpLink"];
+            }
+        }
+
+        /// <summary>
+        /// The support telephone.
+        /// </summary>
+        public string HelpTelephone
+        {
+            get
+            {
+                return this["HelpTelephone"];
+            }
+        }
+
+        /// <summary>
+        /// Date and time the product was installed.
+        /// </summary>
+        public DateTime InstallDate
+        {
+            get
+            {
+                try
+                {
+                    return DateTime.ParseExact(
+                        this["InstallDate"], "yyyyMMdd", CultureInfo.InvariantCulture);
+                }
+                catch (FormatException)
+                {
+                    return DateTime.MinValue;
+                }
+            }
+        }
+
+        /// <summary>
+        /// The installed product name.
+        /// </summary>
+        public string ProductName
+        {
+            get
+            {
+                return this["InstalledProductName"];
+            }
+        }
+
+        /// <summary>
+        /// The installation location.
+        /// </summary>
+        public string InstallLocation
+        {
+            get
+            {
+                return this["InstallLocation"];
+            }
+        }
+
+        /// <summary>
+        /// The installation source.
+        /// </summary>
+        public string InstallSource
+        {
+            get
+            {
+                return this["InstallSource"];
+            }
+        }
+
+        /// <summary>
+        /// The local cached package.
+        /// </summary>
+        public string LocalPackage
+        {
+            get
+            {
+                return this["LocalPackage"];
+            }
+        }
+
+        /// <summary>
+        /// The publisher.
+        /// </summary>
+        public string Publisher
+        {
+            get
+            {
+                return this["Publisher"];
+            }
+        }
+
+        /// <summary>
+        /// URL about information.
+        /// </summary>
+        public Uri UrlInfoAbout
+        {
+            get
+            {
+                string value = this["URLInfoAbout"];
+                if (!String.IsNullOrEmpty(value))
+                {
+                    try
+                    {
+                        return new Uri(value);
+                    }
+                    catch (UriFormatException) { }
+                }
+
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// The URL update information.
+        /// </summary>
+        public Uri UrlUpdateInfo
+        {
+            get
+            {
+                string value = this["URLUpdateInfo"];
+                if (!String.IsNullOrEmpty(value))
+                {
+                    try
+                    {
+                        return new Uri(value);
+                    }
+                    catch (UriFormatException) { }
+                }
+
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// The product version.
+        /// </summary>
+        public Version ProductVersion
+        {
+            get
+            {
+                string ver = this["VersionString"];
+                return ProductInstallation.ParseVersion(ver);
+            }
+        }
+
+        /// <summary>
+        /// The product identifier.
+        /// </summary>
+        /// <remarks><p>
+        /// For more information, see
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/productid.asp">ProductID</a>
+        /// </p></remarks>
+        public string ProductId
+        {
+            get
+            {
+                return this["ProductID"];
+            }
+        }
+
+        /// <summary>
+        /// The company that is registered to use the product.
+        /// </summary>
+        public string RegCompany
+        {
+            get
+            {
+                return this["RegCompany"];
+            }
+        }
+
+        /// <summary>
+        /// The owner who is registered to use the product.
+        /// </summary>
+        public string RegOwner
+        {
+            get
+            {
+                return this["RegOwner"];
+            }
+        }
+
+        /// <summary>
+        /// Transforms.
+        /// </summary>
+        public string AdvertisedTransforms
+        {
+            get
+            {
+                return this["Transforms"];
+            }
+        }
+
+        /// <summary>
+        /// Product language.
+        /// </summary>
+        public string AdvertisedLanguage
+        {
+            get
+            {
+                return this["Language"];
+            }
+        }
+
+        /// <summary>
+        /// Human readable product name.
+        /// </summary>
+        public string AdvertisedProductName
+        {
+            get
+            {
+                return this["ProductName"];
+            }
+        }
+
+        /// <summary>
+        /// True if the product is advertised per-machine;
+        /// false if it is per-user or not advertised.
+        /// </summary>
+        public bool AdvertisedPerMachine
+        {
+            get
+            {
+                return this["AssignmentType"] == "1";
+            }
+        }
+
+        /// <summary>
+        /// Identifier of the package that a product is installed from.
+        /// </summary>
+        public string AdvertisedPackageCode
+        {
+            get
+            {
+                return this["PackageCode"];
+            }
+        }
+
+        /// <summary>
+        /// Version of the advertised product.
+        /// </summary>
+        public Version AdvertisedVersion
+        {
+            get
+            {
+                string ver = this["Version"];
+                return ProductInstallation.ParseVersion(ver);
+            }
+        }
+
+        /// <summary>
+        /// Primary icon for the package.
+        /// </summary>
+        public string AdvertisedProductIcon
+        {
+            get
+            {
+                return this["ProductIcon"];
+            }
+        }
+
+        /// <summary>
+        /// Name of the installation package for the advertised product.
+        /// </summary>
+        public string AdvertisedPackageName
+        {
+            get
+            {
+                return this["PackageName"];
+            }
+        }
+
+        /// <summary>
+        /// True if the advertised product can be serviced by
+        /// non-administrators without elevation.
+        /// </summary>
+        public bool PrivilegedPatchingAuthorized
+        {
+            get
+            {
+                return this["AuthorizedLUAApp"] == "1";
+            }
+        }
+
+        /// <summary>
+        /// Gets information about an installation of a product. 
+        /// </summary>
+        /// <param name="propertyName">Name of the property being retrieved.</param>
+        /// <exception cref="ArgumentOutOfRangeException">An unknown product or property was requested</exception>
+        /// <exception cref="InstallerException">The installer configuration data is corrupt</exception>
+        /// <remarks><p>
+        /// Win32 MSI APIs:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msigetproductinfo.asp">MsiGetProductInfo</a>,
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msigetproductinfoex.asp">MsiGetProductInfoEx</a>
+        /// </p></remarks>
+        public override string this[string propertyName]
+        {
+            get
+            {
+                if (this.properties != null)
+                {
+                    string value = null;
+                    this.properties.TryGetValue(propertyName, out value);
+                    return value;
+                }
+                else
+                {
+                    StringBuilder buf = new StringBuilder(40);
+                    uint bufSize = (uint) buf.Capacity;
+                    uint ret;
+
+                    if (this.Context == UserContexts.UserManaged ||
+                        this.Context == UserContexts.UserUnmanaged ||
+                        this.Context == UserContexts.Machine)
+                    {
+                        ret = NativeMethods.MsiGetProductInfoEx(
+                            this.ProductCode,
+                            this.UserSid,
+                            this.Context,
+                            propertyName,
+                            buf,
+                            ref bufSize);
+                        if (ret == (uint) NativeMethods.Error.MORE_DATA)
+                        {
+                            buf.Capacity = (int) ++bufSize;
+                            ret = NativeMethods.MsiGetProductInfoEx(
+                                this.ProductCode,
+                                this.UserSid,
+                                this.Context,
+                                propertyName,
+                                buf,
+                                ref bufSize);
+                        }
+                    }
+                    else
+                    {
+                        ret = NativeMethods.MsiGetProductInfo(
+                            this.ProductCode,
+                            propertyName,
+                            buf,
+                            ref bufSize);
+                        if (ret == (uint) NativeMethods.Error.MORE_DATA)
+                        {
+                            buf.Capacity = (int) ++bufSize;
+                            ret = NativeMethods.MsiGetProductInfo(
+                                this.ProductCode,
+                                propertyName,
+                                buf,
+                                ref bufSize);
+                        }
+                    }
+
+                    if (ret != 0)
+                    {
+                        return null;
+                    }
+
+                    return buf.ToString();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the installed state for a product feature.
+        /// </summary>
+        /// <param name="feature">The feature being queried; identifier from the
+        /// Feature table</param>
+        /// <returns>Installation state of the feature for the product instance: either
+        /// <see cref="InstallState.Local"/>, <see cref="InstallState.Source"/>,
+        /// or <see cref="InstallState.Advertised"/>.</returns>
+        /// <remarks><p>
+        /// Win32 MSI APIs:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiqueryfeaturestate.asp">MsiQueryFeatureState</a>,
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiqueryfeaturestateex.asp">MsiQueryFeatureStateEx</a>
+        /// </p></remarks>
+        public InstallState GetFeatureState(string feature)
+        {
+            if (this.properties != null)
+            {
+                return InstallState.Unknown;
+            }
+            else
+            {
+                int installState;
+                uint ret = NativeMethods.MsiQueryFeatureStateEx(
+                    this.ProductCode,
+                    this.UserSid,
+                    this.Context,
+                    feature,
+                    out installState);
+                if (ret != 0)
+                {
+                    throw InstallerException.ExceptionFromReturnCode(ret);
+                }
+                return (InstallState) installState;
+            }
+        }
+
+        /// <summary>
+        /// Gets the installed state for a product component.
+        /// </summary>
+        /// <param name="component">The component being queried; GUID of the component
+        /// as found in the ComponentId column of the Component table.</param>
+        /// <returns>Installation state of the component for the product instance: either
+        /// <see cref="InstallState.Local"/> or <see cref="InstallState.Source"/>.</returns>
+        /// <remarks><p>
+        /// Win32 MSI API:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiquerycomponnetstate.asp">MsiQueryComponentState</a>
+        /// </p></remarks>
+        public InstallState GetComponentState(string component)
+        {
+            if (this.properties != null)
+            {
+                return InstallState.Unknown;
+            }
+            else
+            {
+                int installState;
+                uint ret = NativeMethods.MsiQueryComponentState(
+                    this.ProductCode,
+                    this.UserSid,
+                    this.Context,
+                    component,
+                    out installState);
+                if (ret != 0)
+                {
+                    throw InstallerException.ExceptionFromReturnCode(ret);
+                }
+                return (InstallState) installState;
+            }
+        }
+
+        /// <summary>
+        /// Obtains and stores the user information and product ID from an installation wizard.
+        /// </summary>
+        /// <remarks><p>
+        /// This method is typically called by an application during the first run of the application. The application
+        /// first gets the <see cref="ProductInstallation.ProductId"/> or <see cref="ProductInstallation.RegOwner"/>.
+        /// If those properties are missing, the application calls CollectUserInfo.
+        /// CollectUserInfo opens the product's installation package and invokes a wizard sequence that collects
+        /// user information. Upon completion of the sequence, user information is registered. Since this API requires
+        /// an authored user interface, the user interface level should be set to full by calling
+        /// <see cref="Installer.SetInternalUI(InstallUIOptions)"/> as <see cref="InstallUIOptions.Full"/>.
+        /// </p><p>
+        /// The CollectUserInfo method invokes a FirstRun dialog from the product installation database.
+        /// </p><p>
+        /// Win32 MSI API:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msicollectuserinfo.asp">MsiCollectUserInfo</a>
+        /// </p></remarks>
+        public void CollectUserInfo()
+        {
+            if (this.properties == null)
+            {
+                uint ret = NativeMethods.MsiCollectUserInfo(this.InstallationCode);
+                if (ret != 0)
+                {
+                    throw InstallerException.ExceptionFromReturnCode(ret);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Some products might write some invalid/nonstandard version strings to the registry.
+        /// This method tries to get the best data it can.
+        /// </summary>
+        /// <param name="ver">Version string retrieved from the registry.</param>
+        /// <returns>Version object, or null if the version string is completely invalid.</returns>
+        private static Version ParseVersion(string ver)
+        {
+            if (ver != null)
+            {
+                int dotCount = 0;
+                for (int i = 0; i < ver.Length; i++)
+                {
+                    char c = ver[i];
+                    if (c == '.') dotCount++;
+                    else if (!Char.IsDigit(c))
+                    {
+                        ver = ver.Substring(0, i);
+                        break;
+                    }
+                }
+
+                if (ver.Length > 0)
+                {
+                    if (dotCount == 0)
+                    {
+                        ver = ver + ".0";
+                    }
+                    else if (dotCount > 3)
+                    {
+                        string[] verSplit = ver.Split('.');
+                        ver = String.Join(".", verSplit, 0, 4);
+                    }
+
+                    try
+                    {
+                        return new Version(ver);
+                    }
+                    catch (ArgumentException)
+                    {
+                    }
+                }
+            }
+
+            return null;
+        }
+    }
+}