private static void CheckInstallResult(uint ret)
{
switch (ret)
{
case (uint)NativeMethods.Error.SUCCESS: break;
case (uint)NativeMethods.Error.SUCCESS_REBOOT_REQUIRED: Installer.rebootRequired = true; break;
case (uint)NativeMethods.Error.SUCCESS_REBOOT_INITIATED: Installer.rebootInitiated = true; break;
default: throw InstallerException.ExceptionFromReturnCode(ret);
}
}
public void ApplyTransform(string transformFile, TransformErrors errorConditionsToSuppress)
{
if (string.IsNullOrWhiteSpace(transformFile))
{
throw new ArgumentNullException("transformFile");
}
uint ret = NativeMethods.MsiDatabaseApplyTransform((int)this.Handle, transformFile, (int)errorConditionsToSuppress);
if (ret != 0)
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
}
/// <summary>
/// Sets the value of a field to a nullable integer.
/// </summary>
/// <param name="field">Specifies the field to set.</param>
/// <param name="value">new value of the field</param>
/// <exception cref="ArgumentOutOfRangeException">The field is less than 0 or greater than the
/// number of fields in the Record.</exception>
/// <remarks><p>
/// Win32 MSI API:
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msirecordsetinteger.asp">MsiRecordSetInteger</a>
/// </p></remarks>
/// <seealso cref="SetInteger(int,int)"/>
public void SetNullableInteger(int field, int?value)
{
this.CheckRange(field);
uint ret = RemotableNativeMethods.MsiRecordSetInteger(
(int)this.Handle,
(uint)field,
value.HasValue ? (int)value : Int32.MinValue);
if (ret != 0)
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
}
/// <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));
}
}
public void Execute(Record executeParams)
{
uint ret = RemotableNativeMethods.MsiViewExecute(
(int)this.Handle,
(executeParams != null ? (int)executeParams.Handle : 0));
if (ret == (uint)NativeMethods.Error.BAD_QUERY_SYNTAX)
{
throw new BadQuerySyntaxException(this.sql);
}
else if (ret != 0)
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
}
/// <summary>
/// Finalizes the persistent form of the database. All persistent data is written
/// to the writeable database, and no temporary columns or rows are written.
/// </summary>
/// <exception cref="InvalidHandleException">the Database handle is invalid</exception>
/// <remarks><p>
/// For a database open in <see cref="DatabaseOpenMode.ReadOnly"/> mode, this method has no effect.
/// </p><p>
/// For a database open in <see cref="DatabaseOpenMode.CreateDirect" /> or <see cref="DatabaseOpenMode.Direct" />
/// mode, it is not necessary to call this method because the database will be automatically committed
/// when it is closed. However this method may be called at any time to persist the current state of tables
/// loaded into memory.
/// </p><p>
/// For a database open in <see cref="DatabaseOpenMode.Create" /> or <see cref="DatabaseOpenMode.Transact" />
/// mode, no changes will be persisted until this method is called. If the database object is closed without
/// calling this method, the database file remains unmodified.
/// </p><p>
/// Win32 MSI API:
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msidatabasecommit.asp">MsiDatabaseCommit</a>
/// </p></remarks>
public void Commit()
{
if (this.summaryInfo != null && !this.summaryInfo.IsClosed)
{
this.summaryInfo.Persist();
this.summaryInfo.Close();
this.summaryInfo = null;
}
uint ret = NativeMethods.MsiDatabaseCommit((int)this.Handle);
if (ret != 0)
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
}
/// <summary>
/// Executes an action sequence described in the specified table.
/// </summary>
/// <param name="sequenceTable">Name of the table containing the action sequence.</param>
/// <exception cref="InvalidHandleException">the Session handle is invalid</exception>
/// <exception cref="InstallCanceledException">the user exited the installation</exception>
/// <remarks><p>
/// This method queries the specified table, ordering the actions by the numbers in the Sequence column.
/// For each row retrieved, an action is executed, provided that any supplied condition expression does
/// not evaluate to FALSE.
/// </p><p>
/// An action sequence containing any actions that update the system, such as the InstallFiles and
/// WriteRegistryValues actions, cannot be run by calling DoActionSequence. The exception to this rule is if
/// DoActionSequence is called from a custom action that is scheduled in the InstallExecuteSequence table
/// between the InstallInitialize and InstallFinalize actions. Actions that do not update the system, such
/// as AppSearch or CostInitialize, can be called.
/// </p><p>
/// Win32 MSI API:
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msisequence.asp">MsiSequence</a>
/// </p></remarks>
public void DoActionSequence(string sequenceTable)
{
if (string.IsNullOrWhiteSpace(sequenceTable))
{
throw new ArgumentNullException("sequenceTable");
}
this.ValidateSessionAccess();
uint ret = RemotableNativeMethods.MsiSequence((int)this.Handle, sequenceTable, 0);
if (ret != 0)
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
}
/// <summary>
/// Makes the current process the owner of the multi-package installation transaction.
/// </summary>
/// <param name="attributes">Select optional behavior when joining the transaction.</param>
/// <exception cref="InvalidHandleException">The transaction handle is not valid.</exception>
/// <exception cref="InstallerException">The transaction could not be joined.</exception>
/// <remarks><p>
/// Win32 MSI API:
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msijointransaction.asp">MsiJoinTransaction</a>
/// </p></remarks>
public void Join(TransactionAttributes attributes)
{
IntPtr hChangeOfOwnerEvent;
uint ret = NativeMethods.MsiJoinTransaction((int)this.Handle, (int)attributes, out hChangeOfOwnerEvent);
if (ret != 0)
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
this.ownerChangeEvent = hChangeOfOwnerEvent;
if (this.ownerChangeEvent != IntPtr.Zero && this.ownerChangeListeners.Count >= 1)
{
new Thread(this.WaitForOwnerChange).Start();
}
}
/// <summary>
/// Removes a specified disk from the set of registered disks.
/// </summary>
/// <param name="diskId">ID of the disk to remove</param>
/// <remarks><p>
/// Win32 MSI API:
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msisourcelistclearmediadisk.asp">MsiSourceListClearMediaDisk</a>
/// </p></remarks>
public bool Remove(int diskId)
{
uint ret = NativeMethods.MsiSourceListClearMediaDisk(
this.installation.InstallationCode,
this.installation.UserSid,
this.installation.Context,
(uint)this.installation.InstallationType,
(uint)diskId);
if (ret != 0)
{
// TODO: Figure out when to return false.
throw InstallerException.ExceptionFromReturnCode(ret);
}
return(true);
}
/// <summary>
/// Sets a record stream field from a file. Stream data cannot be inserted into temporary fields.
/// </summary>
/// <param name="field">Specifies the field of the Record to set.</param>
/// <param name="filePath">Specifies the path to the file containing the stream.</param>
/// <exception cref="ArgumentOutOfRangeException">The field is less than 0 or greater than the
/// number of fields in the Record.</exception>
/// <remarks><p>
/// The contents of the specified file are read into a stream object. The stream persists if
/// the Record is inserted into the Database and the Database is committed.
/// </p><p>
/// To reset the stream to its beginning you must pass in null for filePath.
/// Do not pass an empty string, "", to reset the stream.
/// </p><p>
/// Setting a stream with this method is more efficient than setting a field to a
/// FileStream object.
/// </p><p>
/// Win32 MSI API:
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msirecordsetstream.asp">MsiRecordsetStream</a>
/// </p></remarks>
public void SetStream(int field, string filePath)
{
this.CheckRange(field);
if (string.IsNullOrWhiteSpace(filePath))
{
throw new ArgumentNullException("filePath");
}
uint ret = RemotableNativeMethods.MsiRecordSetStream((int)this.Handle, (uint)field, filePath);
if (ret != 0)
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
}
/// <summary>
/// Checks to see if sufficient disk space is present for the current installation.
/// </summary>
/// <returns>True if there is sufficient disk space; false otherwise.</returns>
/// <remarks><p>
/// Win32 MSI API:
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiverifydiskspace.asp">MsiVerifyDiskSpace</a>
/// </p></remarks>
public bool VerifyDiskSpace()
{
this.ValidateSessionAccess();
uint ret = RemotableNativeMethods.MsiVerifyDiskSpace((int)this.Handle);
if (ret == (uint)NativeMethods.Error.DISK_FULL)
{
return(false);
}
else if (ret != 0)
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
return(true);
}
/// <summary>
/// Adds or updates a disk of the media source for the product or patch.
/// </summary>
/// <remarks><p>
/// Win32 MSI API:
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msisourcelistaddmediadisk.asp">MsiSourceListAddMediaDisk</a>
/// </p></remarks>
public void Add(MediaDisk item)
{
uint ret = NativeMethods.MsiSourceListAddMediaDisk(
this.installation.InstallationCode,
this.installation.UserSid,
this.installation.Context,
(uint)this.installation.InstallationType,
(uint)item.DiskId,
item.VolumeLabel,
item.DiskPrompt);
if (ret != 0)
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
}
/// <summary>
/// Generates an advertise script. The method enables the installer to write to a
/// script the registry and shortcut information used to assign or publish a product.
/// </summary>
/// <param name="packagePath">Path to the package of the product being advertised</param>
/// <param name="scriptFilePath">path to script file to be created with the advertise information</param>
/// <param name="transforms">Semi-colon delimited list of transforms to be applied. This parameter may be null.</param>
/// <param name="locale">The language to use if the source supports multiple languages</param>
/// <param name="processor">Targeted processor architecture.</param>
/// <param name="instance">True to install multiple instances through product code changing transform.
/// Advertises a new instance of the product. Requires that the <paramref name="transforms"/> parameter
/// includes the instance transform that changes the product code.</param>
/// <seealso cref="AdvertiseProduct"/>
/// <remarks><p>
/// Win32 MSI APIs:
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiadvertiseproduct.asp">MsiAdvertiseProduct</a>,
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiadvertiseproductex.asp">MsiAdvertiseProductEx</a>
/// </p></remarks>
public static void GenerateAdvertiseScript(
string packagePath,
string scriptFilePath,
string transforms,
int locale,
ProcessorArchitecture processor,
bool instance)
{
if (string.IsNullOrWhiteSpace(packagePath))
{
throw new ArgumentNullException("packagePath");
}
if (string.IsNullOrWhiteSpace(scriptFilePath))
{
throw new ArgumentNullException("scriptFilePath");
}
if (!File.Exists(packagePath))
{
throw new FileNotFoundException(null, packagePath);
}
uint platform = 0;
switch (processor)
{
case ProcessorArchitecture.X86: platform = (uint)1; break;
case ProcessorArchitecture.IA64: platform = (uint)2; break;
case ProcessorArchitecture.Amd64: platform = (uint)4; break;
}
uint ret = NativeMethods.MsiAdvertiseProductEx(
packagePath,
scriptFilePath,
transforms,
(ushort)locale,
platform,
instance ? (uint)1 : 0);
if (ret != 0)
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
}
/// <summary>
/// Examines a shortcut and returns its product, feature name, and component if available.
/// </summary>
/// <param name="shortcut">Full path to a shortcut</param>
/// <returns>ShortcutTarget structure containing target product code, feature, and component code</returns>
/// <remarks><p>
/// Win32 MSI API:
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msigetshortcuttarget.asp">MsiGetShortcutTarget</a>
/// </p></remarks>
public static ShortcutTarget GetShortcutTarget(string shortcut)
{
StringBuilder productBuf = new StringBuilder(40);
StringBuilder featureBuf = new StringBuilder(40);
StringBuilder componentBuf = new StringBuilder(40);
uint ret = NativeMethods.MsiGetShortcutTarget(shortcut, productBuf, featureBuf, componentBuf);
if (ret != 0)
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
return(new ShortcutTarget(
productBuf.Length > 0 ? productBuf.ToString() : null,
featureBuf.Length > 0 ? featureBuf.ToString() : null,
componentBuf.Length > 0 ? componentBuf.ToString() : null));
}
public IList <InstallCost> GetTotalCost()
{
this.ValidateSessionAccess();
IList <InstallCost> costs = new List <InstallCost>();
StringBuilder driveBuf = new StringBuilder(20);
for (uint i = 0; true; i++)
{
int cost, tempCost;
uint driveBufSize = (uint)driveBuf.Capacity;
uint ret = RemotableNativeMethods.MsiEnumComponentCosts(
(int)this.Handle,
null,
i,
(int)InstallState.Default,
driveBuf,
ref driveBufSize,
out cost,
out tempCost);
if (ret == (uint)NativeMethods.Error.NO_MORE_ITEMS)
{
break;
}
if (ret == (uint)NativeMethods.Error.MORE_DATA)
{
driveBuf.Capacity = (int)++driveBufSize;
ret = RemotableNativeMethods.MsiEnumComponentCosts(
(int)this.Handle,
null,
i,
(int)InstallState.Default,
driveBuf,
ref driveBufSize,
out cost,
out tempCost);
}
if (ret != 0)
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
costs.Add(new InstallCost(driveBuf.ToString(), cost * 512L, tempCost * 512L));
}
return(costs);
}
/// <summary>
/// Extracts information from a patch that can be used to determine whether the patch
/// applies on a target system. The method returns an XML string that can be provided to
/// <see cref="DetermineApplicablePatches(string,string[],InapplicablePatchHandler,string,UserContexts)"/>
/// instead of the full patch file.
/// </summary>
/// <param name="patchPath">Full path to the patch being queried.</param>
/// <returns>XML string containing patch data.</returns>
/// <remarks><p>
/// Win32 MSI API:
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiextractpatchxmldata.asp">MsiExtractPatchXMLData</a>
/// </p></remarks>
public static string ExtractPatchXmlData(string patchPath)
{
StringBuilder buf = new StringBuilder("");
uint bufSize = 0;
uint ret = NativeMethods.MsiExtractPatchXMLData(patchPath, 0, buf, ref bufSize);
if (ret == (uint)NativeMethods.Error.MORE_DATA)
{
buf.Capacity = (int)++bufSize;
ret = NativeMethods.MsiExtractPatchXMLData(patchPath, 0, buf, ref bufSize);
}
if (ret != 0)
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
return(buf.ToString());
}
/// <summary>
/// Gets the full component path for a qualified component that is published by a product and
/// performs any necessary installation. This method prompts for source if necessary and increments
/// the usage count for the feature.
/// </summary>
/// <param name="component">Specifies the component ID for the requested component. This may not be the
/// GUID for the component itself but rather a server that provides the correct functionality, as in the
/// ComponentId column of the PublishComponent table.</param>
/// <param name="qualifier">Specifies a qualifier into a list of advertising components (from PublishComponent Table).</param>
/// <param name="installMode">Installation mode; this can also include bits from <see cref="ReinstallModes"/></param>
/// <param name="product">Optional; specifies the product to match that has published the qualified component.</param>
/// <returns>Path to the component</returns>
/// <remarks><p>
/// Win32 MSI APIs:
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiprovidequalifiedcomponent.asp">MsiProvideQualifiedComponent</a>
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiprovidequalifiedcomponentex.asp">MsiProvideQualifiedComponentEx</a>
/// </p></remarks>
public static string ProvideQualifiedComponent(string component, string qualifier, InstallMode installMode, string product)
{
StringBuilder pathBuf = new StringBuilder(512);
uint pathBufSize = (uint)pathBuf.Capacity;
uint ret = NativeMethods.MsiProvideQualifiedComponentEx(component, qualifier, unchecked ((uint)installMode), product, 0, 0, pathBuf, ref pathBufSize);
if (ret == (uint)NativeMethods.Error.MORE_DATA)
{
pathBuf.Capacity = (int)++pathBufSize;
ret = NativeMethods.MsiProvideQualifiedComponentEx(component, qualifier, unchecked ((uint)installMode), product, 0, 0, pathBuf, ref pathBufSize);
}
if (ret != 0)
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
return(pathBuf.ToString());
}
/// <summary>
/// Opens an installer package for an installed product using the product code.
/// </summary>
/// <param name="productCode">Product code of the installed product</param>
/// <returns>A Session object allowing access to the product database and install engine,
/// or null if the specified product is not installed.</returns>
/// <exception cref="ArgumentException">An unknown product was requested</exception>
/// <exception cref="InstallerException">The product could not be opened</exception>
/// <exception cref="InstallerException">The installer configuration data is corrupt</exception>
/// <remarks><p>
/// Note that only one Session object can be opened by a single process. OpenProduct cannot be
/// used in a custom action because the active installation is the only session allowed.
/// </p><p>
/// The Session object should be <see cref="InstallerHandle.Close"/>d after use.
/// It is best that the handle be closed manually as soon as it is no longer
/// needed, as leaving lots of unused handles open can degrade performance.
/// </p><p>
/// Win32 MSI API:
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiopenproduct.asp">MsiOpenProduct</a>
/// </p></remarks>
public static Session OpenProduct(string productCode)
{
int sessionHandle;
uint ret = NativeMethods.MsiOpenProduct(productCode, out sessionHandle);
if (ret != 0)
{
if (ret == (uint)NativeMethods.Error.UNKNOWN_PRODUCT)
{
return(null);
}
else
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
}
return(new Session((IntPtr)sessionHandle, true));
}
/// <summary>
/// Gets the full path to a Windows Installer component containing an assembly. This method prompts for a source and
/// increments the usage count for the feature.
/// </summary>
/// <param name="assemblyName">Assembly name</param>
/// <param name="appContext">Set to null for global assemblies. For private assemblies, set to the full path of the
/// application configuration file (.cfg file) or executable file (.exe) of the application to which the assembly
/// has been made private.</param>
/// <param name="installMode">Installation mode; this can also include bits from <see cref="ReinstallModes"/></param>
/// <param name="isWin32Assembly">True if this is a Win32 assembly, false if it is a .NET assembly</param>
/// <returns>Path to the assembly</returns>
/// <remarks><p>
/// Win32 MSI API:
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiprovideassembly.asp">MsiProvideAssembly</a>
/// </p></remarks>
public static string ProvideAssembly(string assemblyName, string appContext, InstallMode installMode, bool isWin32Assembly)
{
StringBuilder pathBuf = new StringBuilder(512);
uint pathBufSize = (uint)pathBuf.Capacity;
uint ret = NativeMethods.MsiProvideAssembly(assemblyName, appContext, unchecked ((uint)installMode), (isWin32Assembly ? (uint)1 : 0), pathBuf, ref pathBufSize);
if (ret == (uint)NativeMethods.Error.MORE_DATA)
{
pathBuf.Capacity = (int)++pathBufSize;
ret = NativeMethods.MsiProvideAssembly(assemblyName, appContext, unchecked ((uint)installMode), (isWin32Assembly ? (uint)1 : 0), pathBuf, ref pathBufSize);
}
if (ret != 0)
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
return(pathBuf.ToString());
}
/// <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()));
}
}
public void Modify(ViewModifyMode mode, Record record)
{
if (record == null)
{
throw new ArgumentNullException("record");
}
uint ret = RemotableNativeMethods.MsiViewModify((int)this.Handle, (int)mode, (int)record.Handle);
if (mode == ViewModifyMode.Insert || mode == ViewModifyMode.InsertTemporary)
{
record.IsFormatStringInvalid = true;
}
if (ret != 0)
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
}
/// <summary>
/// Sets the designated mode flag for the current install session.
/// </summary>
/// <param name="mode">The type of mode to be set.</param>
/// <param name="value">The desired value of the mode.</param>
/// <exception cref="InvalidHandleException">the Session handle is invalid</exception>
/// <exception cref="ArgumentOutOfRangeException">an invalid mode flag was specified</exception>
/// <exception cref="InvalidOperationException">the mode cannot not be set</exception>
/// <remarks><p>
/// Win32 MSI API:
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msisetmode.asp">MsiSetMode</a>
/// </p></remarks>
public void SetMode(InstallRunMode mode, bool value)
{
this.ValidateSessionAccess();
uint ret = RemotableNativeMethods.MsiSetMode((int)this.Handle, (uint)mode, value);
if (ret != 0)
{
if (ret == (uint)NativeMethods.Error.ACCESS_DENIED)
{
throw new InvalidOperationException();
}
else
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
}
}
/// <summary>
/// Fetches the next sequential record from the view, or null if there are no more records.
/// </summary>
/// <exception cref="InstallerException">the View is not in an active state</exception>
/// <exception cref="InvalidHandleException">the View handle is invalid</exception>
/// <remarks><p>
/// The Record object should be <see cref="InstallerHandle.Close"/>d after use.
/// It is best that the handle be closed manually as soon as it is no longer
/// needed, as leaving lots of unused handles open can degrade performance.
/// </p><p>
/// Win32 MSI API:
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewfetch.asp">MsiViewFetch</a>
/// </p></remarks>
public Record Fetch()
{
int recordHandle;
uint ret = RemotableNativeMethods.MsiViewFetch((int)this.Handle, out recordHandle);
if (ret == (uint)NativeMethods.Error.NO_MORE_ITEMS)
{
return(null);
}
else if (ret != 0)
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
Record r = new Record((IntPtr)recordHandle, true, this);
r.IsFormatStringInvalid = true;
return(r);
}
/// <summary>
/// Gets a field value as a string.
/// </summary>
/// <param name="field">Specifies the field to retrieve.</param>
/// <returns>String value of the field, or an empty string if the field is null.</returns>
/// <exception cref="ArgumentOutOfRangeException">The field is less than 0 or greater than the
/// number of fields in the Record.</exception>
/// <remarks><p>
/// Win32 MSI API:
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msirecordgetstring.asp">MsiRecordGetString</a>
/// </p></remarks>
public string GetString(int field)
{
this.CheckRange(field);
StringBuilder buf = new StringBuilder(String.Empty);
uint bufSize = 0;
uint ret = RemotableNativeMethods.MsiRecordGetString((int)this.Handle, (uint)field, buf, ref bufSize);
if (ret == (uint)NativeMethods.Error.MORE_DATA)
{
buf.Capacity = (int)++bufSize;
ret = RemotableNativeMethods.MsiRecordGetString((int)this.Handle, (uint)field, buf, ref bufSize);
}
if (ret != 0)
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
return(buf.ToString());
}
/// <summary>
/// Generates an advertise script. The method enables the installer to write to a
/// script the registry and shortcut information used to assign or publish a product.
/// </summary>
/// <param name="packagePath">Path to the package of the product being advertised</param>
/// <param name="scriptFilePath">path to script file to be created with the advertise information</param>
/// <param name="transforms">Semi-colon delimited list of transforms to be applied. This parameter may be null.</param>
/// <param name="locale">The language to use if the source supports multiple languages</param>
/// <exception cref="FileNotFoundException">the specified package file does not exist</exception>
/// <seealso cref="AdvertiseProduct"/>
/// <remarks><p>
/// Win32 MSI APIs:
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiadvertiseproduct.asp">MsiAdvertiseProduct</a>,
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiadvertiseproductex.asp">MsiAdvertiseProductEx</a>
/// </p></remarks>
public static void GenerateAdvertiseScript(string packagePath, string scriptFilePath, string transforms, int locale)
{
if (string.IsNullOrWhiteSpace(packagePath))
{
throw new ArgumentNullException("packagePath");
}
if (!File.Exists(packagePath))
{
throw new FileNotFoundException(null, packagePath);
}
uint ret = NativeMethods.MsiAdvertiseProduct(packagePath, scriptFilePath, transforms, (ushort)locale);
if (ret != 0)
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
}
public long GetCost(bool includeParents, bool includeChildren, InstallState installState)
{
const int MSICOSTTREE_CHILDREN = 1;
const int MSICOSTTREE_PARENTS = 2;
int cost;
uint ret = RemotableNativeMethods.MsiGetFeatureCost(
(int)this.session.Handle,
this.name,
(includeParents ? MSICOSTTREE_PARENTS : 0) | (includeChildren ? MSICOSTTREE_CHILDREN : 0),
(int)installState,
out cost);
if (ret != 0)
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
return(cost * 512L);
}
public bool Merge(Record record)
{
if (record == null)
{
throw new ArgumentNullException("record");
}
uint ret = RemotableNativeMethods.MsiViewModify((int)this.Handle, (int)ViewModifyMode.Merge, (int)record.Handle);
if (ret == (uint)NativeMethods.Error.FUNCTION_FAILED)
{
return(false);
}
else if (ret != 0)
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
return(true);
}
/// <summary>
/// Gets a View object representing the query specified by a SQL string.
/// </summary>
/// <param name="sqlFormat">SQL query string, which may contain format items</param>
/// <param name="args">Zero or more objects to format</param>
/// <returns>A View object representing the query specified by a SQL string</returns>
/// <exception cref="BadQuerySyntaxException">the SQL syntax is invalid</exception>
/// <exception cref="InvalidHandleException">the Database handle is invalid</exception>
/// <remarks><p>
/// The <paramref name="sqlFormat"/> parameter is formatted using <see cref="String.Format(string,object[])"/>.
/// </p><p>
/// The View object should be <see cref="InstallerHandle.Close"/>d after use.
/// It is best that the handle be closed manually as soon as it is no longer
/// needed, as leaving lots of unused handles open can degrade performance.
/// </p><p>
/// Win32 MSI API:
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msidatabaseopenview.asp">MsiDatabaseOpenView</a>
/// </p></remarks>
public View OpenView(string sqlFormat, params object[] args)
{
if (string.IsNullOrWhiteSpace(sqlFormat))
{
throw new ArgumentNullException("sqlFormat");
}
string sql = (args == null || args.Length == 0 ? sqlFormat :
String.Format(CultureInfo.InvariantCulture, sqlFormat, args));
int viewHandle;
uint ret = RemotableNativeMethods.MsiDatabaseOpenView((int)this.Handle, sql, out viewHandle);
if (ret != 0)
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
return(new View((IntPtr)viewHandle, sql, this));
}
public override int Read(byte[] buffer, int offset, int count)
{
if (count > 0)
{
byte[] readBuffer = (offset == 0 ? buffer : new byte[count]);
uint ucount = (uint)count;
uint ret = RemotableNativeMethods.MsiRecordReadStream((int)this.record.Handle, (uint)this.field, buffer, ref ucount);
if (ret != 0)
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
count = (int)ucount;
if (offset > 0)
{
Array.Copy(readBuffer, 0, buffer, offset, count);
}
this.position += count;
}
return(count);
}
/// <summary>
/// Executes a built-in action, custom action, or user-interface wizard action.
/// </summary>
/// <param name="action">Name of the action to execute. Case-sensitive.</param>
/// <param name="actionData">Optional data to be passed to a deferred custom action.</param>
/// <exception cref="InvalidHandleException">the Session handle is invalid</exception>
/// <exception cref="InstallCanceledException">the user exited the installation</exception>
/// <remarks><p>
/// The DoAction method executes the action that corresponds to the name supplied. If the
/// name is not recognized by the installer as a built-in action or as a custom action in
/// the CustomAction table, the name is passed to the user-interface handler object, which
/// can invoke a function or a dialog box. If a null action name is supplied, the installer
/// uses the upper-case value of the ACTION property as the action to perform. If no property
/// value is defined, the default action is performed, defined as "INSTALL".
/// </p><p>
/// Actions that update the system, such as the InstallFiles and WriteRegistryValues
/// actions, cannot be run by calling MsiDoAction. The exception to this rule is if DoAction
/// is called from a custom action that is scheduled in the InstallExecuteSequence table
/// between the InstallInitialize and InstallFinalize actions. Actions that do not update the
/// system, such as AppSearch or CostInitialize, can be called.
/// </p><p>
/// If the called action is a deferred, rollback, or commit custom action, then the supplied
/// <paramref name="actionData"/> will be available via the <see cref="CustomActionData"/>
/// property of that custom action's session.
/// </p><p>
/// Win32 MSI API:
/// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msidoaction.asp">MsiDoAction</a>
/// </p></remarks>
public void DoAction(string action, CustomActionData actionData)
{
if (string.IsNullOrWhiteSpace(action))
{
throw new ArgumentNullException("action");
}
this.ValidateSessionAccess();
if (actionData != null)
{
this[action] = actionData.ToString();
}
uint ret = RemotableNativeMethods.MsiDoAction((int)this.Handle, action);
if (ret != 0)
{
throw InstallerException.ExceptionFromReturnCode(ret);
}
}