Exemplo n.º 1
0
        public static AdamInstance FindOne(DirectoryContext context, string partitionName)
        {
            // validate parameters (partitionName validated by the call to ConfigSet)
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }

            // contexttype should be ConfigurationSet
            if (context.ContextType != DirectoryContextType.ConfigurationSet)
            {
                throw new ArgumentException(SR.TargetShouldBeConfigSet, nameof(context));
            }

            if (partitionName == null)
            {
                throw new ArgumentNullException(nameof(partitionName));
            }

            if (partitionName.Length == 0)
            {
                throw new ArgumentException(SR.EmptyStringParameter, nameof(partitionName));
            }

            //  work with copy of the context
            context = new DirectoryContext(context);

            return(ConfigurationSet.FindOneAdamInstance(context, partitionName, null));
        }
Exemplo n.º 2
0
 public static AdamInstance FindOne(DirectoryContext context, string partitionName)
 {
     if (context != null)
     {
         if (context.ContextType == DirectoryContextType.ConfigurationSet)
         {
             if (partitionName != null)
             {
                 if (partitionName.Length != 0)
                 {
                     context = new DirectoryContext(context);
                     return(ConfigurationSet.FindOneAdamInstance(context, partitionName, null));
                 }
                 else
                 {
                     throw new ArgumentException(Res.GetString("EmptyStringParameter"), "partitionName");
                 }
             }
             else
             {
                 throw new ArgumentNullException("partitionName");
             }
         }
         else
         {
             throw new ArgumentException(Res.GetString("TargetShouldBeConfigSet"), "context");
         }
     }
     else
     {
         throw new ArgumentNullException("context");
     }
 }
Exemplo n.º 3
0
 internal static AdamInstance FindOneAdamInstance(string configSetName, DirectoryContext context, string partitionName, string siteName)
 {
     if (partitionName == null || partitionName.Length != 0)
     {
         if (siteName == null || siteName.Length != 0)
         {
             ArrayList replicaList = Utils.GetReplicaList(context, partitionName, siteName, false, true, false);
             if (replicaList.Count >= 1)
             {
                 return(ConfigurationSet.FindAliveAdamInstance(configSetName, context, replicaList));
             }
             else
             {
                 throw new ActiveDirectoryObjectNotFoundException(Res.GetString("ADAMInstanceNotFound"), typeof(AdamInstance), null);
             }
         }
         else
         {
             throw new ArgumentException(Res.GetString("EmptyStringParameter"), "siteName");
         }
     }
     else
     {
         throw new ArgumentException(Res.GetString("EmptyStringParameter"), "partitionName");
     }
 }
Exemplo n.º 4
0
 public AdamInstanceCollection FindAllAdamInstances(string partitionName, string siteName)
 {
     this.CheckIfDisposed();
     if (siteName != null)
     {
         return(ConfigurationSet.FindAdamInstances(this.context, partitionName, siteName));
     }
     else
     {
         throw new ArgumentNullException("siteName");
     }
 }
Exemplo n.º 5
0
 public AdamInstance FindAdamInstance(string partitionName)
 {
     this.CheckIfDisposed();
     if (partitionName != null)
     {
         return(ConfigurationSet.FindOneAdamInstance(this.Name, this.context, partitionName, null));
     }
     else
     {
         throw new ArgumentNullException("partitionName");
     }
 }
 public DirectoryServer FindDirectoryServer(bool forceRediscovery)
 {
     base.CheckIfDisposed();
     if (this.appType == ApplicationPartitionType.ADApplicationPartition)
     {
         return(this.FindDirectoryServerInternal(null, forceRediscovery));
     }
     if (!this.committed)
     {
         throw new InvalidOperationException(Res.GetString("CannotPerformOperationOnUncommittedObject"));
     }
     return(ConfigurationSet.FindOneAdamInstance(base.context, base.Name, null));
 }
Exemplo n.º 7
0
        internal string GetServerName()
        {
            if (this.serverName == null)
            {
                DirectoryContextType directoryContextType = this.contextType;
                switch (directoryContextType)
                {
                case DirectoryContextType.Domain:
                case DirectoryContextType.Forest:
                {
                    if (this.name == null || this.contextType == DirectoryContextType.Forest && this.isCurrentForest())
                    {
                        this.serverName = DirectoryContext.GetLoggedOnDomain();
                        break;
                    }
                    else
                    {
                        this.serverName = DirectoryContext.GetDnsDomainName(this.name);
                        break;
                    }
                }

                case DirectoryContextType.DirectoryServer:
                {
                    this.serverName = this.name;
                    break;
                }

                case DirectoryContextType.ConfigurationSet:
                {
                    AdamInstance adamInstance = ConfigurationSet.FindAnyAdamInstance(this);
                    try
                    {
                        this.serverName = adamInstance.Name;
                        break;
                    }
                    finally
                    {
                        adamInstance.Dispose();
                    }
                }

                case DirectoryContextType.ApplicationPartition:
                {
                    this.serverName = this.name;
                    break;
                }
                }
            }
            return(this.serverName);
        }
        public ReadOnlyDirectoryServerCollection FindAllDirectoryServers()
        {
            base.CheckIfDisposed();
            if (this.appType == ApplicationPartitionType.ADApplicationPartition)
            {
                return(this.FindAllDirectoryServersInternal(null));
            }
            if (!this.committed)
            {
                throw new InvalidOperationException(Res.GetString("CannotPerformOperationOnUncommittedObject"));
            }
            ReadOnlyDirectoryServerCollection servers = new ReadOnlyDirectoryServerCollection();

            servers.AddRange(ConfigurationSet.FindAdamInstances(base.context, base.Name, null));
            return(servers);
        }
 public DirectoryServer FindDirectoryServer(string siteName)
 {
     base.CheckIfDisposed();
     if (siteName == null)
     {
         throw new ArgumentNullException("siteName");
     }
     if (this.appType == ApplicationPartitionType.ADApplicationPartition)
     {
         return(this.FindDirectoryServerInternal(siteName, false));
     }
     if (!this.committed)
     {
         throw new InvalidOperationException(Res.GetString("CannotPerformOperationOnUncommittedObject"));
     }
     return(ConfigurationSet.FindOneAdamInstance(base.context, base.Name, siteName));
 }
Exemplo n.º 10
0
        public static AdamInstanceCollection FindAll(DirectoryContext context, string partitionName)
        {
            AdamInstanceCollection adamInstanceCollection;

            if (context != null)
            {
                if (context.ContextType == DirectoryContextType.ConfigurationSet)
                {
                    if (partitionName != null)
                    {
                        if (partitionName.Length != 0)
                        {
                            context = new DirectoryContext(context);
                            try
                            {
                                adamInstanceCollection = ConfigurationSet.FindAdamInstances(context, partitionName, null);
                            }
                            catch (ActiveDirectoryObjectNotFoundException activeDirectoryObjectNotFoundException)
                            {
                                adamInstanceCollection = new AdamInstanceCollection(new ArrayList());
                            }
                            return(adamInstanceCollection);
                        }
                        else
                        {
                            throw new ArgumentException(Res.GetString("EmptyStringParameter"), "partitionName");
                        }
                    }
                    else
                    {
                        throw new ArgumentNullException("partitionName");
                    }
                }
                else
                {
                    throw new ArgumentException(Res.GetString("TargetShouldBeConfigSet"), "context");
                }
            }
            else
            {
                throw new ArgumentNullException("context");
            }
        }
Exemplo n.º 11
0
        public static AdamInstanceCollection FindAll(DirectoryContext context, string partitionName)
        {
            AdamInstanceCollection adamInstanceCollection = null;

            // validate parameters (partitionName validated by the call to ConfigSet)
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }

            // contexttype should be ConfigurationSet
            if (context.ContextType != DirectoryContextType.ConfigurationSet)
            {
                throw new ArgumentException(SR.TargetShouldBeConfigSet, nameof(context));
            }

            if (partitionName == null)
            {
                throw new ArgumentNullException(nameof(partitionName));
            }

            if (partitionName.Length == 0)
            {
                throw new ArgumentException(SR.EmptyStringParameter, nameof(partitionName));
            }

            //  work with copy of the context
            context = new DirectoryContext(context);

            try
            {
                adamInstanceCollection = ConfigurationSet.FindAdamInstances(context, partitionName, null);
            }
            catch (ActiveDirectoryObjectNotFoundException)
            {
                // this is the case where  we could not find an ADAM instance in that config set (return empty collection)
                adamInstanceCollection = new AdamInstanceCollection(new ArrayList());
            }

            return(adamInstanceCollection);
        }
        internal string GetServerName()
        {
            if (this.serverName == null)
            {
                switch (this.contextType)
                {
                case DirectoryContextType.Domain:
                case DirectoryContextType.Forest:
                    goto Label_004A;

                case DirectoryContextType.DirectoryServer:
                    this.serverName = this.name;
                    break;

                case DirectoryContextType.ConfigurationSet:
                    using (AdamInstance instance = ConfigurationSet.FindAnyAdamInstance(this))
                    {
                        this.serverName = instance.Name;
                        break;
                    }
                    goto Label_004A;

                case DirectoryContextType.ApplicationPartition:
                    this.serverName = this.name;
                    break;
                }
            }
            goto Label_009D;
Label_004A:
            if ((this.name == null) || ((this.contextType == DirectoryContextType.Forest) && this.isCurrentForest()))
            {
                this.serverName = GetLoggedOnDomain();
            }
            else
            {
                this.serverName = GetDnsDomainName(this.name);
            }
Label_009D:
            return(this.serverName);
        }
Exemplo n.º 13
0
 internal static AdamInstance FindOneAdamInstance(DirectoryContext context, string partitionName, string siteName)
 {
     return(ConfigurationSet.FindOneAdamInstance(null, context, partitionName, siteName));
 }
Exemplo n.º 14
0
 public AdamInstance FindAdamInstance()
 {
     this.CheckIfDisposed();
     return(ConfigurationSet.FindOneAdamInstance(this.Name, this.context, null, null));
 }
Exemplo n.º 15
0
 public AdamInstanceCollection FindAllAdamInstances()
 {
     this.CheckIfDisposed();
     return(ConfigurationSet.FindAdamInstances(this.context, null, null));
 }
Exemplo n.º 16
0
 internal static AdamInstance FindAnyAdamInstance(DirectoryContext context)
 {
     if (context.ContextType == DirectoryContextType.ConfigurationSet)
     {
         DirectoryEntry searchRootEntry = ConfigurationSet.GetSearchRootEntry(Forest.GetCurrentForest());
         ArrayList      arrayLists      = new ArrayList();
         try
         {
             try
             {
                 StringBuilder stringBuilder = new StringBuilder(15);
                 stringBuilder.Append("(&(");
                 stringBuilder.Append(PropertyManager.ObjectCategory);
                 stringBuilder.Append("=serviceConnectionPoint)");
                 stringBuilder.Append("(");
                 stringBuilder.Append(PropertyManager.Keywords);
                 stringBuilder.Append("=1.2.840.113556.1.4.1851)(");
                 stringBuilder.Append(PropertyManager.Keywords);
                 stringBuilder.Append("=");
                 stringBuilder.Append(Utils.GetEscapedFilterValue(context.Name));
                 stringBuilder.Append("))");
                 string   str = stringBuilder.ToString();
                 string[] serviceBindingInformation = new string[1];
                 serviceBindingInformation[0] = PropertyManager.ServiceBindingInformation;
                 ADSearcher             aDSearcher = new ADSearcher(searchRootEntry, str, serviceBindingInformation, SearchScope.Subtree, false, false);
                 SearchResultCollection searchResultCollections = aDSearcher.FindAll();
                 try
                 {
                     foreach (SearchResult item in searchResultCollections)
                     {
                         string      str1       = "ldap://";
                         IEnumerator enumerator = item.Properties[PropertyManager.ServiceBindingInformation].GetEnumerator();
                         try
                         {
                             while (enumerator.MoveNext())
                             {
                                 string str2 = item.ToString();
                                 if (str2.Length <= str1.Length || string.Compare(str2.Substring(0, str1.Length), str1, StringComparison.OrdinalIgnoreCase) != 0)
                                 {
                                     continue;
                                 }
                                 arrayLists.Add(str2.Substring(str1.Length));
                             }
                         }
                         finally
                         {
                             IDisposable disposable = enumerator as IDisposable;
                             if (disposable != null)
                             {
                                 disposable.Dispose();
                             }
                         }
                     }
                 }
                 finally
                 {
                     searchResultCollections.Dispose();
                 }
             }
             catch (COMException cOMException1)
             {
                 COMException cOMException = cOMException1;
                 throw ExceptionHelper.GetExceptionFromCOMException(context, cOMException);
             }
         }
         finally
         {
             searchRootEntry.Dispose();
         }
         return(ConfigurationSet.FindAliveAdamInstance(null, context, arrayLists));
     }
     else
     {
         DirectoryEntryManager directoryEntryManager = new DirectoryEntryManager(context);
         DirectoryEntry        cachedDirectoryEntry  = directoryEntryManager.GetCachedDirectoryEntry(WellKnownDN.RootDSE);
         if (Utils.CheckCapability(cachedDirectoryEntry, Capability.ActiveDirectoryApplicationMode))
         {
             string propertyValue = (string)PropertyManager.GetPropertyValue(context, cachedDirectoryEntry, PropertyManager.DnsHostName);
             return(new AdamInstance(context, propertyValue, directoryEntryManager));
         }
         else
         {
             directoryEntryManager.RemoveIfExists(directoryEntryManager.ExpandWellKnownDN(WellKnownDN.RootDSE));
             throw new ArgumentException(Res.GetString("TargetShouldBeServerORConfigSet"), "context");
         }
     }
 }
Exemplo n.º 17
0
        internal string GetServerName()
        {
            if (serverName == null)
            {
                switch (_contextType)
                {
                case DirectoryContextType.ConfigurationSet:
                {
                    AdamInstance adamInst = ConfigurationSet.FindAnyAdamInstance(this);
                    try
                    {
                        serverName = adamInst.Name;
                    }
                    finally
                    {
                        adamInst.Dispose();
                    }
                    break;
                }

                case DirectoryContextType.Domain:
                case DirectoryContextType.Forest:
                {
                    //
                    // if the target is not specified OR
                    // if the forest name was explicitly specified and the forest is the same as the current forest
                    // we want to find a DC in the current domain
                    //
                    if ((_name == null) || ((_contextType == DirectoryContextType.Forest) && (isCurrentForest())))
                    {
                        serverName = GetLoggedOnDomain();
                    }
                    else
                    {
                        serverName = GetDnsDomainName(_name);
                    }
                    break;
                }

                case DirectoryContextType.ApplicationPartition:
                {
                    // if this is an appNC the target should not be null
                    Debug.Assert(_name != null);

                    serverName = _name;
                    break;
                }

                case DirectoryContextType.DirectoryServer:
                {
                    // this should not happen (We should have checks for this earlier itself)
                    Debug.Assert(_name != null);
                    serverName = _name;
                    break;
                }

                default:
                {
                    Debug.Fail("DirectoryContext::GetServerName - Unknown contextType");
                    break;
                }
                }
            }

            return(serverName);
        }
        public static ApplicationPartition FindByName(DirectoryContext context, string distinguishedName)
        {
            DirectoryEntryManager directoryEntryMgr = null;
            DirectoryContext      context2          = null;

            if (context == null)
            {
                throw new ArgumentNullException("context");
            }
            if ((context.Name == null) && !context.isRootDomain())
            {
                throw new ArgumentException(Res.GetString("ContextNotAssociatedWithDomain"), "context");
            }
            if (((context.Name != null) && !context.isRootDomain()) && (!context.isADAMConfigSet() && !context.isServer()))
            {
                throw new ArgumentException(Res.GetString("NotADOrADAM"), "context");
            }
            if (distinguishedName == null)
            {
                throw new ArgumentNullException("distinguishedName");
            }
            if (distinguishedName.Length == 0)
            {
                throw new ArgumentException(Res.GetString("EmptyStringParameter"), "distinguishedName");
            }
            if (!Utils.IsValidDNFormat(distinguishedName))
            {
                throw new ArgumentException(Res.GetString("InvalidDNFormat"), "distinguishedName");
            }
            context           = new DirectoryContext(context);
            directoryEntryMgr = new DirectoryEntryManager(context);
            DirectoryEntry searchRoot = null;

            try
            {
                searchRoot = DirectoryEntryManager.GetDirectoryEntry(context, directoryEntryMgr.ExpandWellKnownDN(WellKnownDN.PartitionsContainer));
            }
            catch (COMException exception)
            {
                throw ExceptionHelper.GetExceptionFromCOMException(context, exception);
            }
            catch (ActiveDirectoryObjectNotFoundException)
            {
                throw new ActiveDirectoryOperationException(Res.GetString("ADAMInstanceNotFoundInConfigSet", new object[] { context.Name }));
            }
            StringBuilder builder = new StringBuilder(15);

            builder.Append("(&(");
            builder.Append(PropertyManager.ObjectCategory);
            builder.Append("=crossRef)(");
            builder.Append(PropertyManager.SystemFlags);
            builder.Append(":1.2.840.113556.1.4.804:=");
            builder.Append(1);
            builder.Append(")(!(");
            builder.Append(PropertyManager.SystemFlags);
            builder.Append(":1.2.840.113556.1.4.803:=");
            builder.Append(2);
            builder.Append("))(");
            builder.Append(PropertyManager.NCName);
            builder.Append("=");
            builder.Append(Utils.GetEscapedFilterValue(distinguishedName));
            builder.Append("))");
            string filter = builder.ToString();

            string[]     propertiesToLoad = new string[] { PropertyManager.DnsRoot, PropertyManager.NCName };
            ADSearcher   searcher         = new ADSearcher(searchRoot, filter, propertiesToLoad, SearchScope.OneLevel, false, false);
            SearchResult res = null;

            try
            {
                res = searcher.FindOne();
            }
            catch (COMException exception2)
            {
                if (exception2.ErrorCode == -2147016656)
                {
                    throw new ActiveDirectoryObjectNotFoundException(Res.GetString("AppNCNotFound"), typeof(ApplicationPartition), distinguishedName);
                }
                throw ExceptionHelper.GetExceptionFromCOMException(context, exception2);
            }
            finally
            {
                searchRoot.Dispose();
            }
            if (res == null)
            {
                throw new ActiveDirectoryObjectNotFoundException(Res.GetString("AppNCNotFound"), typeof(ApplicationPartition), distinguishedName);
            }
            string domainName = null;

            try
            {
                domainName = (res.Properties[PropertyManager.DnsRoot].Count > 0) ? ((string)res.Properties[PropertyManager.DnsRoot][0]) : null;
            }
            catch (COMException exception3)
            {
                throw ExceptionHelper.GetExceptionFromCOMException(context, exception3);
            }
            ApplicationPartitionType applicationPartitionType = GetApplicationPartitionType(context);

            if (context.ContextType != DirectoryContextType.DirectoryServer)
            {
                if (applicationPartitionType == ApplicationPartitionType.ADApplicationPartition)
                {
                    DomainControllerInfo info;
                    int errorCode = 0;
                    errorCode = Locator.DsGetDcNameWrapper(null, domainName, null, 0x8000L, out info);
                    if (errorCode == 0x54b)
                    {
                        throw new ActiveDirectoryObjectNotFoundException(Res.GetString("AppNCNotFound"), typeof(ApplicationPartition), distinguishedName);
                    }
                    if (errorCode != 0)
                    {
                        throw ExceptionHelper.GetExceptionFromErrorCode(errorCode);
                    }
                    context2 = Utils.GetNewDirectoryContext(info.DomainControllerName.Substring(2), DirectoryContextType.DirectoryServer, context);
                }
                else
                {
                    context2 = Utils.GetNewDirectoryContext(ConfigurationSet.FindOneAdamInstance(context.Name, context, distinguishedName, null).Name, DirectoryContextType.DirectoryServer, context);
                }
                goto Label_03FC;
            }
            bool flag                        = false;
            DistinguishedName dn             = new DistinguishedName(distinguishedName);
            DirectoryEntry    directoryEntry = DirectoryEntryManager.GetDirectoryEntry(context, WellKnownDN.RootDSE);

            try
            {
                foreach (string str3 in directoryEntry.Properties[PropertyManager.NamingContexts])
                {
                    DistinguishedName name2 = new DistinguishedName(str3);
                    if (name2.Equals(dn))
                    {
                        flag = true;
                        goto Label_0352;
                    }
                }
            }
            catch (COMException exception4)
            {
                throw ExceptionHelper.GetExceptionFromCOMException(context, exception4);
            }
            finally
            {
                directoryEntry.Dispose();
            }
Label_0352:
            if (!flag)
            {
                throw new ActiveDirectoryObjectNotFoundException(Res.GetString("AppNCNotFound"), typeof(ApplicationPartition), distinguishedName);
            }
            context2 = context;
Label_03FC:
            return(new ApplicationPartition(context2, (string)PropertyManager.GetSearchResultPropertyValue(res, PropertyManager.NCName), domainName, applicationPartitionType, directoryEntryMgr));
        }