コード例 #1
0
        public static int InvokeCustomAction(int sessionHandle, string entryPoint,
            IntPtr remotingDelegatePtr)
        {
            Session session = null;
            string assemblyName, className, methodName;
            MethodInfo method;

            try
            {
                MsiRemoteInvoke remotingDelegate = (MsiRemoteInvoke)
                    Marshal.GetDelegateForFunctionPointer(
                        remotingDelegatePtr, typeof(MsiRemoteInvoke));
                RemotableNativeMethods.RemotingDelegate = remotingDelegate;

                sessionHandle = RemotableNativeMethods.MakeRemoteHandle(sessionHandle);
                session = new Session((IntPtr) sessionHandle, false);
                if (string.IsNullOrWhiteSpace(entryPoint))
                {
                    throw new ArgumentNullException("entryPoint");
                }

                if (!CustomActionProxy.FindEntryPoint(
                    session,
                    entryPoint,
                    out assemblyName,
                    out className,
                    out methodName))
                {
                    return (int) ActionResult.Failure;
                }
                session.Log("Calling custom action {0}!{1}.{2}", assemblyName, className, methodName);

                method = CustomActionProxy.GetCustomActionMethod(
                    session,
                    assemblyName,
                    className,
                    methodName);
                if (method == null)
                {
                    return (int) ActionResult.Failure;
                }
            }
            catch (Exception ex)
            {
                if (session != null)
                {
                    try
                    {
                        session.Log("Exception while loading custom action:");
                        session.Log(ex.ToString());
                    }
                    catch (Exception) { }
                }
                return (int) ActionResult.Failure;
            }

            try
            {
                // Set the current directory to the location of the extracted files.
                Environment.CurrentDirectory =
                    Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

                object[] args = new object[] { session };
                if (DebugBreakEnabled(new string[] { entryPoint, methodName }))
                {
                    string message = String.Format(CultureInfo.InvariantCulture,
                        "To debug your custom action, attach to process ID {0} (0x{0:x}) and click OK; otherwise, click Cancel to fail the custom action.",
                        System.Diagnostics.Process.GetCurrentProcess().Id
                        );

                    MessageResult button = NativeMethods.MessageBox(
                        IntPtr.Zero,
                        message,
                        "Custom Action Breakpoint",
                        (int)MessageButtons.OKCancel | (int)MessageIcon.Asterisk | (int)(MessageBoxStyles.TopMost | MessageBoxStyles.ServiceNotification)
                        );

                    if (MessageResult.Cancel == button)
                    {
                        return (int)ActionResult.UserExit;
                    }
                }

                ActionResult result = (ActionResult) method.Invoke(null, args);
                session.Close();
                return (int) result;
            }
            catch (InstallCanceledException)
            {
                return (int) ActionResult.UserExit;
            }
            catch (Exception ex)
            {
                session.Log("Exception thrown by custom action:");
                session.Log(ex.ToString());
                return (int) ActionResult.Failure;
            }
        }
コード例 #2
0
        private static MethodInfo GetCustomActionMethod(
            Session session,
            string assemblyName,
            string className,
            string methodName)
        {
            Assembly customActionAssembly;
            Type customActionClass = null;
            Exception caughtEx = null;
            try
            {
                customActionAssembly = AppDomain.CurrentDomain.Load(assemblyName);
                customActionClass = customActionAssembly.GetType(className, true, true);
            }
            catch (IOException ex) { caughtEx = ex; }
            catch (BadImageFormatException ex) { caughtEx = ex; }
            catch (TypeLoadException ex) { caughtEx = ex; }
            catch (ReflectionTypeLoadException ex) { caughtEx = ex; }
            catch (SecurityException ex) { caughtEx = ex; }
            if (caughtEx != null)
            {
                session.Log("Error: could not load custom action class " + className + " from assembly: " + assemblyName);
                session.Log(caughtEx.ToString());
                return null;
            }

            MethodInfo[] methods = customActionClass.GetMethods(
                BindingFlags.Public | BindingFlags.Static);
            foreach (MethodInfo method in methods)
            {
                if (method.Name == methodName &&
                    CustomActionProxy.MethodHasCustomActionSignature(method))
                {
                    return method;
                }
            }
            session.Log("Error: custom action method \"" + methodName +
                "\" is missing or has the wrong signature.");
            return null;
        }
コード例 #3
0
ファイル: EmbeddedUIProxy.cs プロジェクト: vairam-svs/oneget
        public static int Initialize(int sessionHandle, string uiClass, int internalUILevel)
        {
            Session session = null;

            try
            {
                session = new Session((IntPtr) sessionHandle, false);

                if (string.IsNullOrWhiteSpace(uiClass))
                {
                    throw new ArgumentNullException("uiClass");
                }

                EmbeddedUIProxy.uiInstance = EmbeddedUIProxy.InstantiateUI(session, uiClass);
            }
            catch (Exception ex)
            {
                if (session != null)
                {
                    try
                    {
                        session.Log("Exception while loading embedded UI:");
                        session.Log(ex.ToString());
                    }
                    catch (Exception)
                    {
                    }
                }
            }

            if (EmbeddedUIProxy.uiInstance == null)
            {
                return (int) ActionResult.Failure;
            }

            try
            {
                string resourcePath = Path.GetDirectoryName(EmbeddedUIProxy.uiInstance.GetType().Assembly.Location);
                InstallUIOptions uiOptions = (InstallUIOptions) internalUILevel;
                if (EmbeddedUIProxy.DebugBreakEnabled("Initialize"))
                {
                    System.Diagnostics.Debugger.Launch();
                }

                if (EmbeddedUIProxy.uiInstance.Initialize(session, resourcePath, ref uiOptions))
                {
                    // The embedded UI initialized and the installation should continue
                    // with internal UI reset according to options.
                    return ((int) uiOptions) << 16;
                }
                else
                {
                    // The embedded UI did not initialize but the installation should still continue
                    // with internal UI reset according to options.
                    return (int) uiOptions;
                }
            }
            catch (InstallCanceledException)
            {
                // The installation was canceled by the user.
                return (int) ActionResult.UserExit;
            }
            catch (Exception ex)
            {
                // An unhandled exception causes the installation to fail immediately.
                session.Log("Exception thrown by embedded UI initialization:");
                session.Log(ex.ToString());
                return (int) ActionResult.Failure;
            }
        }
コード例 #4
0
        private static bool FindEntryPoint(
            Session session,
            string entryPoint,
            out string assemblyName,
            out string className,
            out string methodName)
        {
            assemblyName = null;
            className = null;
            methodName = null;

            string fullEntryPoint;
            if (entryPoint.IndexOf('!') > 0)
            {
                fullEntryPoint = entryPoint;
            }
            else
            {
                IDictionary config;
                try
                {
                    config = (IDictionary) ConfigurationManager.GetSection("customActions");
                }
                catch (ConfigurationException cex)
                {
                    session.Log("Error: missing or invalid customActions config section.");
                    session.Log(cex.ToString());
                    return false;
                }
                fullEntryPoint = (string) config[entryPoint];
                if (fullEntryPoint == null)
                {
                    session.Log(
                        "Error: custom action entry point '{0}' not found " +
                        "in customActions config section.",
                        entryPoint);
                    return false;
                }
            }

            int assemblySplit = fullEntryPoint.IndexOf('!');
            int methodSplit = fullEntryPoint.LastIndexOf('.');
            if (assemblySplit < 0 || methodSplit < 0 || methodSplit < assemblySplit)
            {
                session.Log("Error: invalid custom action entry point:" + entryPoint);
                return false;
            }

            assemblyName = fullEntryPoint.Substring(0, assemblySplit);
            className = fullEntryPoint.Substring(assemblySplit + 1, methodSplit - assemblySplit - 1);
            methodName = fullEntryPoint.Substring(methodSplit + 1);
            return true;
        }
コード例 #5
0
ファイル: EmbeddedUIProxy.cs プロジェクト: vairam-svs/oneget
        private static IEmbeddedUI InstantiateUI(Session session, string uiClass)
        {
            int assemblySplit = uiClass.IndexOf('!');
            if (assemblySplit < 0)
            {
                session.Log("Error: invalid embedded UI assembly and class:" + uiClass);
                return null;
            }

            string assemblyName = uiClass.Substring(0, assemblySplit);
            EmbeddedUIProxy.uiClass = uiClass.Substring(assemblySplit + 1);

            Assembly uiAssembly;
            try
            {
                uiAssembly = AppDomain.CurrentDomain.Load(assemblyName);

                // This calls out to CustomActionProxy.DebugBreakEnabled() directly instead
                // of calling EmbeddedUIProxy.DebugBreakEnabled() because we don't compose a
                // class.method name for this breakpoint.
                if (CustomActionProxy.DebugBreakEnabled(new string[] { "EmbeddedUI" }))
                {
                    System.Diagnostics.Debugger.Launch();
                }

                return (IEmbeddedUI) uiAssembly.CreateInstance(EmbeddedUIProxy.uiClass);
            }
            catch (Exception ex)
            {
                session.Log("Error: could not load embedded UI class " + EmbeddedUIProxy.uiClass + " from assembly: " + assemblyName);
                session.Log(ex.ToString());
                return null;
            }
        }