Exemplo n.º 1
0
        private bool ADDomainPreCommitFSRoutine(ADFactory <T> .DirectoryOperation operation, T instance, ADParameterSet parameters, ADObject directoryObj)
        {
            bool flag = false;

            if (operation == ADFactory <T> .DirectoryOperation.Update && base.PropertyHasChange(ADDomainFactory <T> .ADDomainPropertyMap.DomainMode.PropertyName, instance, parameters, operation))
            {
                ADDomainMode?singleValueProperty = base.GetSingleValueProperty <ADDomainMode?>(ADDomainFactory <T> .ADDomainPropertyMap.DomainMode.PropertyName, instance, parameters, operation);
                if (singleValueProperty.HasValue)
                {
                    ADDomainMode value = singleValueProperty.Value;
                    switch (value)
                    {
                    case ADDomainMode.Windows2000Domain:
                    {
                        Win32Exception win32Exception = new Win32Exception(50);
                        throw new NotSupportedException(win32Exception.Message);
                    }

                    case ADDomainMode.Windows2003InterimDomain:
                    {
                        if (base.CmdletSessionInfo.ADRootDSE.DomainFunctionality == ADDomainMode.Windows2000Domain && ADDomainFactory <T> .GetNTMixedDomainMode(base.CmdletSessionInfo) == 1)
                        {
                            break;
                        }
                        directoryObj["ntMixedDomain"].Value = 1;
                        flag = true;
                        break;
                    }

                    case ADDomainMode.Windows2003Domain:
                    {
                        bool flag1 = false;
                        if (base.CmdletSessionInfo.ADRootDSE.DomainFunctionality != ADDomainMode.Windows2000Domain)
                        {
                            if (base.CmdletSessionInfo.ADRootDSE.DomainFunctionality == ADDomainMode.Windows2003InterimDomain)
                            {
                                flag1 = true;
                            }
                        }
                        else
                        {
                            if (ADDomainFactory <T> .GetNTMixedDomainMode(base.CmdletSessionInfo) != 0)
                            {
                                flag1 = true;
                            }
                        }
                        if (!flag1)
                        {
                            break;
                        }
                        ADDomainFactory <T> .UpdateNTMixedDomainMode(base.CmdletSessionInfo, 0);

                        break;
                    }
                    }
                }
                else
                {
                    return(flag);
                }
            }
            return(flag);
        }
Exemplo n.º 2
0
        private bool ADTargetScopeEnumerationServerPreProcessTargetCSRoutine()
        {
            object        baseObject;
            ADSessionInfo sessionInfo = this.GetSessionInfo();
            string        item        = this._cmdletParameters["Server"] as string;

            object[] objArray = this._cmdletParameters["Target"] as object[];
            for (int i = 0; i < (int)objArray.Length; i++)
            {
                object obj = objArray[i];
                if (obj as PSObject == null)
                {
                    baseObject = obj;
                }
                else
                {
                    baseObject = ((PSObject)obj).BaseObject;
                }
                string   str      = baseObject as string;
                ADEntity aDEntity = baseObject as ADEntity;
                if (aDEntity == null)
                {
                    ADScopeType?nullable       = (ADScopeType?)(this._cmdletParameters["Scope"] as ADScopeType?);
                    ADScopeType valueOrDefault = nullable.GetValueOrDefault();
                    if (nullable.HasValue)
                    {
                        switch (valueOrDefault)
                        {
                        case ADScopeType.Server:
                        {
                            this.AddSessionsMatchingServerName(str);
                            break;
                        }

                        case ADScopeType.Domain:
                        {
                            if (item == null)
                            {
                                ADDiscoverableService[] aDDiscoverableServiceArray = new ADDiscoverableService[1];
                                aDDiscoverableServiceArray[0] = ADDiscoverableService.ADWS;
                                ADMinimumDirectoryServiceVersion?nullable1 = null;
                                ADEntity aDEntity1 = DomainControllerUtil.DiscoverDomainController(null, str, aDDiscoverableServiceArray, ADDiscoverDomainControllerOptions.ReturnDnsName, nullable1);
                                this.SetPipelinedSessionInfo(new ADSessionInfo(aDEntity1["HostName"].Value as string));
                            }
                            ADDomainFactory <ADDomain> aDDomainFactory = new ADDomainFactory <ADDomain>();
                            aDDomainFactory.SetCmdletSessionInfo(this.GetCmdletSessionInfo());
                            ADDomain extendedObjectFromIdentity = aDDomainFactory.GetExtendedObjectFromIdentity(new ADDomain(str), this.GetRootDSE().DefaultNamingContext);
                            this.AddSessionsFromDomain(extendedObjectFromIdentity);
                            if (item != null)
                            {
                                break;
                            }
                            this.SetPipelinedSessionInfo(sessionInfo);
                            break;
                        }

                        case ADScopeType.Forest:
                        {
                            if (item != null)
                            {
                                ADForestFactory <ADForest> aDForestFactory = new ADForestFactory <ADForest>();
                                aDForestFactory.SetCmdletSessionInfo(this.GetCmdletSessionInfo());
                                try
                                {
                                    aDForestFactory.GetDirectoryObjectFromIdentity(new ADForest(str), null);
                                }
                                catch (ADIdentityNotFoundException aDIdentityNotFoundException1)
                                {
                                    ADIdentityNotFoundException aDIdentityNotFoundException = aDIdentityNotFoundException1;
                                    base.WriteError(this.ConstructErrorRecord(aDIdentityNotFoundException));
                                    break;
                                }
                            }
                            else
                            {
                                ADDiscoverableService[] aDDiscoverableServiceArray1 = new ADDiscoverableService[1];
                                aDDiscoverableServiceArray1[0] = ADDiscoverableService.ADWS;
                                ADMinimumDirectoryServiceVersion?nullable2 = null;
                                ADEntity aDEntity2 = DomainControllerUtil.DiscoverDomainController(null, str, aDDiscoverableServiceArray1, ADDiscoverDomainControllerOptions.ReturnDnsName, nullable2);
                                this.SetPipelinedSessionInfo(new ADSessionInfo(aDEntity2["HostName"].Value as string));
                            }
                            this.AddSessionsFromConnectedForest();
                            if (item != null)
                            {
                                break;
                            }
                            this.SetPipelinedSessionInfo(sessionInfo);
                            break;
                        }

                        case ADScopeType.Site:
                        {
                            this.AddSessionsMatchingSiteName(str);
                            break;
                        }
                        }
                    }
                }
                else
                {
                    if (aDEntity.IsSearchResult)
                    {
                        this.SetPipelinedSessionInfo(aDEntity.SessionInfo);
                        if (aDEntity as ADForest == null)
                        {
                            if (aDEntity as ADDomain == null)
                            {
                                if (aDEntity as ADDirectoryServer == null)
                                {
                                    if (aDEntity as ADReplicationSite == null)
                                    {
                                        object[] type = new object[2];
                                        type[0] = aDEntity.GetType();
                                        type[1] = "Target";
                                        base.WriteErrorBuffered(this.ConstructErrorRecord(new ParameterBindingException(string.Format(CultureInfo.CurrentCulture, StringResources.UnsupportedParameterType, type))));
                                    }
                                    else
                                    {
                                        ADReplicationSite aDReplicationSite = (ADReplicationSite)aDEntity;
                                        this.AddSessionFromSiteDN(aDReplicationSite.DistinguishedName);
                                    }
                                }
                                else
                                {
                                    ADDirectoryServer aDDirectoryServer = (ADDirectoryServer)aDEntity;
                                    this._sessionPipe.AddLast(new ADSessionInfo(aDDirectoryServer["HostName"].Value as string));
                                }
                            }
                            else
                            {
                                ADDomain aDDomain = (ADDomain)aDEntity;
                                this.AddSessionsFromDomain(aDDomain);
                            }
                        }
                        else
                        {
                            this.AddSessionsFromConnectedForest();
                        }
                        this.SetPipelinedSessionInfo(sessionInfo);
                    }
                    else
                    {
                        base.WriteErrorBuffered(this.ConstructErrorRecord(new ArgumentException(string.Format(CultureInfo.CurrentCulture, StringResources.OnlySearchResultsSupported, new object[0]))));
                    }
                }
            }
            return(true);
        }
Exemplo n.º 3
0
        private bool ModifyADOptionalFeatureBaseProcessCSRoutine()
        {
            string distinguishedName;
            string str;
            string str1 = null;
            bool   flag;

            if (this._cmdletParameters.Contains("Identity"))
            {
                ADOptionalFeature      item = this._cmdletParameters["Identity"] as ADOptionalFeature;
                ADOptionalFeatureScope aDOptionalFeatureScope = (ADOptionalFeatureScope)this._cmdletParameters["Scope"];
                ADEntity aDEntity = this._cmdletParameters["Target"] as ADEntity;
                this.SetPipelinedSessionInfo(item.SessionInfo);
                CmdletSessionInfo cmdletSessionInfo = this.GetCmdletSessionInfo();
                this._factory.SetCmdletSessionInfo(cmdletSessionInfo);
                if (aDOptionalFeatureScope != ADOptionalFeatureScope.Domain)
                {
                    if (aDOptionalFeatureScope != ADOptionalFeatureScope.ForestOrConfigurationSet)
                    {
                        distinguishedName = null;
                    }
                    else
                    {
                        string    item1   = this._cmdletParameters["Server"] as string;
                        ADRootDSE rootDSE = this.GetRootDSE();
                        if (rootDSE.ServerType != ADServerType.ADDS)
                        {
                            cmdletSessionInfo = this.GetCmdletSessionInfo();
                            ADObjectFactory <ADObject> aDObjectFactory = new ADObjectFactory <ADObject>();
                            aDObjectFactory.SetCmdletSessionInfo(cmdletSessionInfo);
                            ADObject aDObject = new ADObject();
                            aDObject.Identity = aDEntity.Identity;
                            ADObject directoryObjectFromIdentity = aDObjectFactory.GetDirectoryObjectFromIdentity(aDObject, rootDSE.ConfigurationNamingContext, false);
                            string   str2 = X500Path.StripX500Whitespace(directoryObjectFromIdentity.DistinguishedName);
                            if (string.Compare(rootDSE.ConfigurationNamingContext, str2, StringComparison.InvariantCultureIgnoreCase) == 0)
                            {
                                distinguishedName = string.Concat("CN=Partitions,", directoryObjectFromIdentity.DistinguishedName);
                            }
                            else
                            {
                                object[] objArray = new object[1];
                                objArray[0] = aDEntity.Identity.ToString();
                                throw new ADIdentityNotFoundException(string.Format(CultureInfo.CurrentCulture, StringResources.ConfigSetNotFound, objArray));
                            }
                        }
                        else
                        {
                            ADRootDSE aDRootDSE = null;
                            if (item1 != null)
                            {
                                aDRootDSE = rootDSE;
                            }
                            if (aDEntity as ADForest == null)
                            {
                                str = ADDomainUtil.DiscoverDCFromIdentity <ADForest>(aDEntity.Identity, out str1);
                            }
                            else
                            {
                                str = ADDomainUtil.DiscoverDCFromIdentity <ADForest>(aDEntity, out str1);
                            }
                            if (str != null)
                            {
                                ADSessionInfo sessionInfo = this.GetSessionInfo();
                                sessionInfo.Server = str1;
                                this.SetPipelinedSessionInfo(sessionInfo);
                                if (aDRootDSE != null)
                                {
                                    ADRootDSE rootDSE1 = this.GetRootDSE();
                                    if (rootDSE1.RootDomainNamingContext == aDRootDSE.RootDomainNamingContext)
                                    {
                                        sessionInfo.Server = item1;
                                        this.SetPipelinedSessionInfo(sessionInfo);
                                    }
                                    else
                                    {
                                        throw new ADIdentityNotFoundException();
                                    }
                                }
                                base.TargetOperationMasterRole(ADOperationMasterRole.DomainNamingMaster);
                                cmdletSessionInfo = this.GetCmdletSessionInfo();
                                this._factory.SetCmdletSessionInfo(cmdletSessionInfo);
                                ADForestFactory <ADForest> aDForestFactory = new ADForestFactory <ADForest>();
                                aDForestFactory.SetCmdletSessionInfo(cmdletSessionInfo);
                                ADForest aDForest = new ADForest(str1);
                                ADObject directoryObjectFromIdentity1 = aDForestFactory.GetDirectoryObjectFromIdentity(aDForest, this.GetRootDSE().DefaultNamingContext, false);
                                distinguishedName = directoryObjectFromIdentity1.DistinguishedName;
                            }
                            else
                            {
                                object[] defaultNamingContext = new object[2];
                                defaultNamingContext[0] = aDEntity.Identity.ToString();
                                defaultNamingContext[1] = this.GetRootDSE().DefaultNamingContext;
                                throw new ADIdentityNotFoundException(string.Format(CultureInfo.CurrentCulture, StringResources.IdentityNotFound, defaultNamingContext));
                            }
                        }
                    }
                }
                else
                {
                    ADDomainFactory <ADDomain> aDDomainFactory = new ADDomainFactory <ADDomain>();
                    aDDomainFactory.SetCmdletSessionInfo(cmdletSessionInfo);
                    ADDomain aDDomain = new ADDomain();
                    if (aDEntity as ADObject == null)
                    {
                        aDDomain = new ADDomain(aDEntity.Identity as string);
                    }
                    else
                    {
                        aDDomain.Identity = aDEntity;
                    }
                    ADObject aDObject1 = aDDomainFactory.GetDirectoryObjectFromIdentity(aDDomain, this.GetRootDSE().DefaultNamingContext, false);
                    distinguishedName = aDObject1.DistinguishedName;
                }
                this.ValidateParameters();
                item = this._factory.GetExtendedObjectFromIdentity(item, this.GetDefaultPartitionPath(), null, false);
                Guid?  featureGUID = item.FeatureGUID;
                string str3        = featureGUID.ToString();
                if (this._action != ModifyADOptionalFeatureBase <P> .ModifyADOptionalFeatureAction.Enable)
                {
                    if (this._action != ModifyADOptionalFeatureBase <P> .ModifyADOptionalFeatureAction.Disable)
                    {
                        throw new NotImplementedException(this._action.ToString());
                    }
                    else
                    {
                        flag = false;
                    }
                }
                else
                {
                    if (!item.IsDisableable)
                    {
                        base.WriteWarning(string.Format(StringResources.EnablingIsIrreversible, item.Name, distinguishedName));
                    }
                    flag = true;
                }
                if (base.ShouldProcessOverride(item.Name, this._action.ToString()))
                {
                    using (ADTopologyManagement aDTopologyManagement = new ADTopologyManagement(cmdletSessionInfo.ADSessionInfo))
                    {
                        aDTopologyManagement.ChangeOptionalFeature(distinguishedName, flag, str3);
                    }
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
            else
            {
                object[] objArray1 = new object[1];
                objArray1[0] = "Identity,Instance";
                throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, StringResources.ParameterRequiredMultiple, objArray1));
            }
        }