internal static AddInController GetAddInController(Object addIn) { if (addIn == null) { throw new ArgumentNullException("addIn"); } System.Diagnostics.Contracts.Contract.EndContractBlock(); AddInControllerImpl controllerImpl = FindController(addIn, false); //return new wrapper if (controllerImpl != null) { // Try and increase the ref count on the addin. If we fail, perhaps // because the user already called Dispose() on the HVA, that's OK. Still allow // them to use the AddInController to examine the AddInToken ContractHandle handle = null; try { handle = new ContractHandle(controllerImpl._contract); } catch (Exception) {} return(new AddInController(controllerImpl, addIn, handle)); } throw new ArgumentException(Res.ControllerNotFound); }
internal AddInController(AddInControllerImpl impl, Object hostViewOfAddIn, ContractHandle contractHandle) { System.Diagnostics.Contracts.Contract.Requires(impl != null); _impl = impl; _hostViewOfAddIn = hostViewOfAddIn; _contractHandle = contractHandle; }
internal AddInController(AddInControllerImpl impl, Object hostViewOfAddIn, ContractHandle contractHandle) { System.Diagnostics.Contracts.Contract.Requires(impl != null); _impl = impl; _hostViewOfAddIn = hostViewOfAddIn; _contractHandle = contractHandle; }
// Find the controller given the HAV (addIn), optionally also removing it. // This code also removes any stale HAVControllerPairs that it finds, as // may happen when a HAV is garbage collected. private static AddInControllerImpl FindController(Object addIn, bool remove) { System.Diagnostics.Contracts.Contract.Requires(addIn != null); lock (_havLock) { HAVControllerPair current = _havList; HAVControllerPair last = null; while (current != null) { Object o = current._HAV.Target; if (o == null) { // this one has been GC'd. Clean up the WR if (last == null) { _havList = current._next; continue; } else { last._next = current._next; current = current._next; continue; } } else { if (addIn.Equals(o)) { AddInControllerImpl value = current._controller; if (remove) { if (last == null) { _havList = current._next; } else { last._next = current._next; } } return(value); } } last = current; current = current._next; } } return(null); }
private static T Activate <T>(AddInToken token, PermissionSet permissionSet, String appDomainName) { // Make a copy of the permission set to prevent the permissions from being modified after we demand permissionSet = permissionSet.Copy(); // // Breaking security fix: (B#499362): Making a copy isn't sufficient protection if the // permission object comes from an untrusted source as the permission object itself // can interfere with the copy process. We simply can't safely pass an untrusted permission // down to CreateDomain(), so if there any untrusted permissions in the set, demand full trust before // allowing the operation to proceed. // if (!permissionSet.IsUnrestricted()) { foreach (Object permission in permissionSet) { Assembly a = permission.GetType().Assembly; if (!a.GlobalAssemblyCache) { new PermissionSet(PermissionState.Unrestricted).Demand(); break; } } } // Don't let them create an appdomain that elevates privileges permissionSet.Demand(); AppDomain domain = null; try { domain = CreateDomain(token, permissionSet, appDomainName); AddInEnvironment environment = new AddInEnvironment(domain, true); AddInControllerImpl controller = new AddInControllerImpl(environment, true, token); return(ActivateInAppDomain <T>(token, domain, controller, true)); } catch { // Don't leak the domain. if (domain != null) { try { Utils.UnloadAppDomain(domain); } catch (AppDomainUnloadedException) {} } throw; } }
internal static T Activate <T>(AddInToken token, AppDomain target) { if (token == null) { throw new ArgumentNullException("token"); } if (target == null) { throw new ArgumentNullException("target"); } System.Diagnostics.Contracts.Contract.EndContractBlock(); AddInEnvironment environment = new AddInEnvironment(target); AddInControllerImpl controller = new AddInControllerImpl(environment, false, token); return(ActivateInAppDomain <T>(token, target, controller, false)); }
// Activation in an existing appdomain, either in-process or out-of-process internal static T Activate <T>(AddInToken token, AddInEnvironment environment) { if (environment == null) { throw new ArgumentNullException("environment"); } System.Diagnostics.Contracts.Contract.EndContractBlock(); if (environment.Process.IsCurrentProcess) { AddInControllerImpl controller = new AddInControllerImpl(environment, false, token); return(ActivateInAppDomain <T>(token, environment.AppDomain, controller, false)); } else { return(ActivateOutOfProcess <T>(token, environment, false)); } }
// helper method // private static T ActivateOutOfProcess <T>(AddInToken token, AddInEnvironment environment, bool weOwn) { ActivationWorker worker; IContract contract = environment.AddInServerWorker.Activate(token, out worker); AddInControllerImpl controller = new AddInControllerImpl(environment, weOwn, token); controller.ActivationWorker = worker; T hav = AdaptToHost <T>(token, contract); if (weOwn) { environment.AddInServerWorker.SetAppDomainOwner(contract); } // Add this HAV and add-in controller to our list of currently // non-disposed add-ins. controller.AssociateWithHostAddinView(hav, contract); return(hav); }
// Takes a host add-in view (HAV) and maps that to an add-in controller. public static AddInController GetAddInController(Object addIn) { return(AddInControllerImpl.GetAddInController(addIn)); }
public HAVControllerPair(Object hav, AddInControllerImpl controller) { _HAV = new WeakReference(hav); _controller = controller; }
private static T ActivateInAppDomain <T>(AddInToken pipeline, AppDomain domain, AddInControllerImpl controller, bool weOwn) { ContractComponent contract = pipeline._contract; HostAdapter hostAdapter = pipeline._hostAdapter; bool usingHostAppDomain = domain == AppDomain.CurrentDomain; //begin direct connect code if (AddInToken.EnableDirectConnect && !weOwn && usingHostAppDomain) { Type havType = typeof(T); TypeInfo havTypeInfo = new TypeInfo(havType); if (pipeline._addinBase.CanDirectConnectTo(havTypeInfo)) { // Connect directly for best performance. // Assert permission to the specific Addin directory only. PermissionSet permissionSet = new PermissionSet(PermissionState.None); permissionSet.AddPermission(new FileIOPermission(FileIOPermissionAccess.Read | FileIOPermissionAccess.PathDiscovery, Path.GetDirectoryName(pipeline._addin.Location))); permissionSet.Assert(); Assembly addInAssembly = Assembly.LoadFrom(pipeline._addin.Location); // Type addinType = addInAssembly.GetType(pipeline._addin.TypeInfo.FullName, true); Object addIn = addinType.GetConstructor(new Type[0]).Invoke(new Object[0]); System.Diagnostics.Contracts.Contract.Assert(addIn != null, "Bypass couldn't create the add-in"); // remember the addin directly as the HAV. Set the contract to null. controller.AssociateWithHostAddinView(addIn, null); return((T)addIn); } } //end direct connect code // Use Activator.CreateInstance instead of AppDomain.CreateInstanceAndUnwrap // because Activator will do the appropriate security asserts in the // remote appdomain. Type t = typeof(ActivationWorker); Object[] args = new Object[] { pipeline }; ObjectHandle objHandle = Activator.CreateInstance(domain, t.Assembly.FullName, t.FullName, false, BindingFlags.Instance | BindingFlags.NonPublic, null, args, null, null); ActivationWorker activationWorker = (ActivationWorker)objHandle.Unwrap(); activationWorker.UsingHostAppDomain = usingHostAppDomain; System.AddIn.Contract.IContract addInContract = null; try { addInContract = activationWorker.Activate(); } catch (Exception ex) { CheckForDuplicateAssemblyProblems(pipeline, ex); throw; } if (weOwn) { domain.SetData(ContractHandle.s_appDomainOwner, addInContract); } controller.ActivationWorker = activationWorker; T hav = AdaptToHost <T>(pipeline, addInContract); controller.AssociateWithHostAddinView(hav, addInContract); return(hav); }
public HAVControllerPair(Object hav, AddInControllerImpl controller) { _HAV = new WeakReference(hav); _controller = controller; }