/// <summary> /// Initializes the Entry specific properties e.g entry DN etc. /// </summary> void InitEntry() { LdapUrl lUrl = new LdapUrl (ADsPath); string dn = lUrl.getDN(); if (dn != null ) { if (String.Compare (dn,"rootDSE",true) == 0) InitToRootDse (lUrl.Host,lUrl.Port); else { DN userDn = new DN (dn); String[] lRdn = userDn.explodeDN(false); _Name = (string)lRdn[0]; _Parent = new DirectoryEntry(conn); _Parent.Path = GetLdapUrlString (lUrl.Host,lUrl.Port,userDn.Parent.ToString ()); } } else { _Name=lUrl.Host+":"+lUrl.Port; _Parent = new DirectoryEntry(conn); _Parent.Path = "Ldap:"; } }
/// <summary> Construct the ReferralInfo class /// /// </summary> /// <param name="lc">The DirectoryEntry opened to process this referral /// /// </param> /// <param name="refUrl">The URL string associated with this connection /// </param> public ReferralInfo(LdapConnection lc, System.String[] refList, LdapUrl refUrl) { conn = lc; referralUrl = refUrl; referralList = refList; return ; }
/// <summary> Construct the ReferralInfo class /// /// </summary> /// <param name="lc">The DirectoryEntry opened to process this referral /// /// </param> /// <param name="refUrl">The URL string associated with this connection /// </param> public ReferralInfo(LdapConnection lc, System.String[] refList, LdapUrl refUrl) { conn = lc; referralUrl = refUrl; referralList = refList; return; }
private void InitBlock() { _conn = new LdapConnection(); LdapUrl lUrl=new LdapUrl(SearchRoot.Path); _Host=lUrl.Host; _Port=lUrl.Port; _conn.Connect(_Host,_Port); _conn.Bind(SearchRoot.Username,SearchRoot.Password); }
private void InitBlock() { _conn = new LdapConnection(); LdapUrl lUrl=new LdapUrl(SearchRoot.ADsPath); _Host=lUrl.Host; _Port=lUrl.Port; _conn.Connect(_Host,_Port); _conn.Bind(SearchRoot.Username,SearchRoot.Password,(Novell.Directory.Ldap.AuthenticationTypes)SearchRoot.AuthenticationType); }
/// <summary> Initializes the Connection and other properties. /// /// </summary> private void InitBlock() { try { LdapUrl lUrl=new LdapUrl(_Bpath); _Conn = new LdapConnection(); _Conn.Connect(lUrl.Host,lUrl.Port); _Conn.Bind(_Buser,_Bpass); } catch(LdapException ex) { throw ex; } catch(Exception e) { throw e; } }
/// <summary> Initializes the Connection and other properties. /// /// </summary> private void InitBlock() { try { _conn= new LdapConnection (); LdapUrl lUrl = new LdapUrl (ADsPath); _conn.Connect(lUrl.Host,lUrl.Port); _conn.Bind(Username,Password, (Novell.Directory.Ldap.AuthenticationTypes)AuthenticationType); } catch(LdapException ex) { throw ex; } catch(Exception e) { throw e; } }
internal static string GetLdapUrlString(string host, int port, string dn) { LdapUrl lUrl; if (port == LdapConnection.DEFAULT_PORT) lUrl = new LdapUrl (host,0,dn); else lUrl = new LdapUrl (host,port,dn); return lUrl.ToString(); }
/// <summary> Construct the ReferralInfo class /// /// </summary> /// <param name="lc">The DirectoryEntry opened to process this referral /// /// </param> /// <param name="refUrl">The URL string associated with this connection /// </param> public ReferralInfo(LdapConnection lc, string[] refList, LdapUrl refUrl) { conn = lc; referralUrl = refUrl; referralList = refList; }
/* * Ldap URL search */ /// <summary> Synchronously performs the search specified by the Ldap URL, returning /// an enumerable LdapSearchResults object. /// /// </summary> /// <param name="toGet">The Ldap URL specifying the entry to read. /// /// </param> /// <exception> LdapException A general exception which includes an error /// message and an Ldap error code. /// </exception> public static LdapSearchResults Search(LdapUrl toGet) { // Get a clone of default search constraints, method alters batchSize return Search(toGet, null); }
/// <summary> /// Searches the directory store at the specified path to see whether /// an entry exists /// </summary> /// <param name="path"> /// The path at which to search the directory store. /// </param> /// <returns> /// true if an entry exists in the directory store at the specified /// path; otherwise, false. /// </returns> public static bool Exists(string path) { LdapConnection aconn=new LdapConnection(); LdapUrl lurl=new LdapUrl(path); aconn.Connect(lurl.Host,lurl.Port); aconn.Bind("",""); if(CheckEntry(aconn,path)) return true; else return false; }
/// <summary> /// Checks whether the entry with the specified Relative distinguised name /// exists or not. /// </summary> /// <param name="rdn"> Relative distinguished name of the entry</param> /// <returns>DirectoryEntry object of Entry if entry exists, /// Null if entry doesn't exist </returns> private DirectoryEntry CheckEntry(string rdn) { string Ofdn=null; DirectoryEntry cEntry=null; Ofdn=rdn+","+Basedn; string[] attrs={"objectClass"}; try { LdapSearchResults lsc= Conn.Search( Ofdn, LdapConnection.SCOPE_BASE, "objectClass=*", attrs, false); while(lsc.hasMore()) { LdapEntry nextEntry = null; try { nextEntry = lsc.next(); cEntry = new DirectoryEntry(Conn); LdapUrl Burl=new LdapUrl(_Bpath); LdapUrl curl=new LdapUrl(Burl.Host,Burl.Port,Ofdn); cEntry.Path=curl.ToString(); } catch(LdapException e) { // Exception is thrown, go for next entry throw e; } break; } } catch(LdapException le) { if(le.ResultCode == LdapException.NO_SUCH_OBJECT) { return null; } else { throw le; } } catch(Exception e) { throw e; } return cEntry; }
/// <summary> /// Deletes a child DirectoryEntry from this collection /// </summary> /// <param name="entry">The DirectoryEntry to delete</param> public void Remove( DirectoryEntry entry ) { LdapUrl Burl=new LdapUrl(_Bpath); string eFDN = entry.Name + "," + Burl.getDN(); Conn.Delete( eFDN); }
/// <summary> Creates a request to create a new entry in the container. /// /// </summary> /// <param name="name"> RDN of the entry to be created /// </param> /// <param name="schemaClassName"> StructuralClassName of the entry to be /// created. /// </param> public DirectoryEntry Add( string name,string schemaClassName) { DirectoryEntry ent=new DirectoryEntry(Conn); LdapUrl Burl=new LdapUrl(_Bpath); string eFdn=name+","+Burl.getDN(); LdapUrl curl=new LdapUrl(Burl.Host,Burl.Port,eFdn); ent.Path=curl.ToString(); ent.Nflag = true; return ent; }
public IEnumerator GetEnumerator() { m_oValues= new ArrayList(); string[] attrs={"objectClass"}; LdapSearchResults lsc= Conn.Search( Basedn, LdapConnection.SCOPE_ONE, "objectClass=*", attrs, false); LdapUrl Burl=new LdapUrl(_Bpath); string host=Burl.Host; int port=Burl.Port; while (lsc.hasMore()) { LdapEntry nextEntry = null; try { nextEntry = lsc.next(); } catch(LdapException e) { // Exception is thrown, go for next entry continue; } DirectoryEntry dEntry=new DirectoryEntry(Conn); string eFdn=nextEntry.DN; LdapUrl curl=new LdapUrl(host,port,eFdn); dEntry.Path=curl.ToString(); m_oValues.Add((DirectoryEntry) dEntry); } return m_oValues.GetEnumerator(); }
private void InitToRootDse(string host,int port) { if ( host == null ) host = DefaultHost; if ( port < 0 ) port = DefaultPort; LdapUrl rootPath = new LdapUrl (host,port,String.Empty); string [] attrs = new string [] {"+","*"}; DirectoryEntry rootEntry = new DirectoryEntry (rootPath.ToString (),this.Username,this.Password,this.AuthenticationType); DirectorySearcher searcher = new DirectorySearcher (rootEntry,null,attrs,SearchScope.Base); SearchResult result = searcher.FindOne (); // copy properties from search result PropertyCollection pcoll = new PropertyCollection (); foreach (string propertyName in result.Properties.PropertyNames) { System.Collections.IEnumerator enumerator = result.Properties [propertyName].GetEnumerator (); if (enumerator != null) while (enumerator.MoveNext ()) if (String.Compare (propertyName,"ADsPath",true) != 0) pcoll [propertyName].Add (enumerator.Current); } this.SetProperties (pcoll); this._Name = "rootDSE"; }
/// <summary> /// Checks whether the entry exists in the Ldap directory or not /// </summary> /// <param name="lconn"> /// Connection used to communicate with directory /// </param> /// <param name="epath"> /// path of the entry /// </param> /// <returns> /// true of the entry exists in the Ldap directory /// false if entry doesn't exists /// </returns> private static bool CheckEntry(LdapConnection lconn, string epath) { LdapUrl lUrl=new LdapUrl(epath); string eDn=lUrl.getDN(); if(eDn==null) { eDn = String.Empty; } // rootDSE is a "virtual" entry that always exists else if (String.Compare (eDn,"rootDSE",true) == 0) return true; string[] attrs={"objectClass"}; try { LdapSearchResults lsc=lconn.Search( eDn, LdapConnection.SCOPE_BASE, "objectClass=*", attrs, false); while(lsc.hasMore()) { LdapEntry nextEntry = null; try { nextEntry = lsc.next(); } catch(LdapException e) { // Exception is thrown, go for next entry throw e; } break; } } catch(LdapException le) { if(le.ResultCode == LdapException.NO_SUCH_OBJECT) { return false; } else { throw le; } } catch(Exception e) { throw e; } return true; }
/// <summary> Initializes the Connection and other properties. /// /// </summary> private void InitBlock() { try { _conn= new LdapConnection (); LdapUrl lUrl=new LdapUrl (Path); _conn.Connect(lUrl.Host,lUrl.Port); _conn.Bind(Username,Password); } catch(LdapException ex) { throw ex; } catch(Exception e) { throw e; } }
/// <summary> Synchronously reads the entry specified by the Ldap URL, using the /// specified constraints. /// /// When this method is called, a new connection is created /// automatically, using the host and port specified in the URL. After /// finding the entry, the method closes the connection (in other words, /// it disconnects from the Ldap server). /// /// If the URL specifies a filter and scope, they are not used. Of the /// information specified in the URL, this method only uses the Ldap host /// name and port number, the base distinguished name (DN), and the list /// of attributes to return. /// /// </summary> /// <returns> The entry specified by the base DN. /// /// </returns> /// <param name="toGet"> Ldap URL specifying the entry to read. /// /// </param> /// <param name="cons"> Constraints specific to the operation. /// /// </param> /// <exception> LdapException if the object was not found /// </exception> public static LdapEntry Read(LdapUrl toGet, LdapSearchConstraints cons) { LdapConnection lconn = new LdapConnection(); lconn.Connect(toGet.Host, toGet.Port); LdapEntry toReturn = lconn.Read(toGet.getDN(), toGet.AttributeArray, cons); lconn.Disconnect(); return toReturn; }
/// <summary> /// Initializes the Entry specific properties e.g entry DN etc. /// </summary> void InitEntry() { LdapUrl lUrl=new LdapUrl (Path); if(lUrl.getDN()!=null) { DN userDn = new DN(lUrl.getDN()); String[] lRdn = userDn.explodeDN(false); _Name = (string)lRdn[0]; _Parent = new DirectoryEntry(conn); LdapUrl cUrl=new LdapUrl(lUrl.Host,lUrl.Port,userDn.Parent.ToString()); _Parent.Path=cUrl.ToString(); } else { _Name=lUrl.Host+":"+lUrl.Port; _Parent = new DirectoryEntry(conn); _Parent.Path = "Ldap:"; } }
/// <summary> Builds a new request replacing dn, scope, and filter where approprate /// /// </summary> /// <param name="msg">the original LdapMessage to build the new request from /// /// </param> /// <param name="url">the referral url /// /// </param> /// <returns> a new LdapMessage with appropriate information replaced /// /// </returns> /// <exception> LdapException A general exception which includes an error /// message and an Ldap error code. /// </exception> private LdapMessage rebuildRequest(LdapMessage msg, LdapUrl url, bool reference) { System.String dn = url.getDN(); // new base System.String filter = null; switch (msg.Type) { case LdapMessage.SEARCH_REQUEST: if (reference) { filter = url.Filter; } break; // We are allowed to get a referral for the following case LdapMessage.ADD_REQUEST: case LdapMessage.BIND_REQUEST: case LdapMessage.COMPARE_REQUEST: case LdapMessage.DEL_REQUEST: case LdapMessage.EXTENDED_REQUEST: case LdapMessage.MODIFY_RDN_REQUEST: case LdapMessage.MODIFY_REQUEST: break; // The following return no response case LdapMessage.ABANDON_REQUEST: case LdapMessage.UNBIND_REQUEST: default: throw new LdapLocalException(ExceptionMessages.IMPROPER_REFERRAL, new System.Object[]{msg.Type}, LdapException.LOCAL_ERROR); } return msg.Clone(dn, filter, reference); }
/// <summary> get an LdapConnection object so that we can follow a referral. /// This function is never called if cons.getReferralFollowing() returns /// false. /// /// </summary> /// <param name="referrals">the array of referral strings /// /// /// </param> /// <returns> The referralInfo object /// /// </returns> /// <exception> LdapReferralException A general exception which includes /// an error message and an Ldap error code. /// </exception> private ReferralInfo getReferralConnection(System.String[] referrals) { ReferralInfo refInfo = null; System.Exception ex = null; LdapConnection rconn = null; LdapReferralHandler rh = defSearchCons.getReferralHandler(); int i = 0; // Check if we use LdapRebind to get authentication credentials if ((rh == null) || (rh is LdapAuthHandler)) { for (i = 0; i < referrals.Length; i++) { // dn, pw are null in the default case (anonymous bind) System.String dn = null; sbyte[] pw = null; try { rconn = new LdapConnection(); rconn.Constraints = defSearchCons; LdapUrl url = new LdapUrl(referrals[i]); rconn.Connect(url.Host, url.Port); if (rh != null) { if (rh is LdapAuthHandler) { // Get application supplied dn and pw LdapAuthProvider ap = ((LdapAuthHandler) rh).getAuthProvider(url.Host, url.Port); dn = ap.DN; pw = ap.Password; } } rconn.Bind(Ldap_V3, dn, pw); ex = null; refInfo = new ReferralInfo(rconn, referrals, url); // Indicate this connection created to follow referral rconn.Connection.ActiveReferral = refInfo; break; } catch (System.Exception lex) { if (rconn != null) { try { rconn.Disconnect(); rconn = null; ex = lex; } catch (LdapException e) { ; // ignore } } } } } // Check if application gets connection and does bind else { // rh instanceof LdapBind try { rconn = ((LdapBindHandler) rh).Bind(referrals, this); if (rconn == null) { LdapReferralException rex = new LdapReferralException(ExceptionMessages.REFERRAL_ERROR); rex.setReferrals(referrals); throw rex; } // Figure out which Url belongs to the connection for (int idx = 0; idx < referrals.Length; idx++) { try { LdapUrl url = new LdapUrl(referrals[idx]); if (url.Host.ToUpper().Equals(rconn.Host.ToUpper()) && (url.Port == rconn.Port)) { refInfo = new ReferralInfo(rconn, referrals, url); break; } } catch (System.Exception e) { ; // ignore } } if (refInfo == null) { // Could not match LdapBind.bind() connecction with URL list ex = new LdapLocalException(ExceptionMessages.REFERRAL_BIND_MATCH, LdapException.CONNECT_ERROR); } } catch (System.Exception lex) { rconn = null; ex = lex; } } if (ex != null) { // Could not connect to any server, throw an exception LdapException ldapex; if (ex is LdapReferralException) { throw (LdapReferralException) ex; } else if (ex is LdapException) { ldapex = (LdapException) ex; } else { ldapex = new LdapLocalException(ExceptionMessages.SERVER_CONNECT_ERROR, new System.Object[]{conn.Host}, LdapException.CONNECT_ERROR, ex); } // Error attempting to follow a referral LdapReferralException rex = new LdapReferralException(ExceptionMessages.REFERRAL_ERROR, ldapex); rex.setReferrals(referrals); // Use last URL string for the failed referral rex.FailedReferral = referrals[referrals.Length - 1]; throw rex; } // We now have an authenticated connection // to be used to follow the referral. return refInfo; }
/// <summary> Creates a request to create a new entry in the container. /// /// </summary> /// <param name="name"> RDN of the entry to be created /// </param> /// <param name="schemaClassName"> StructuralClassName of the entry to be /// created. /// </param> public DirectoryEntry Add( string name,string schemaClassName) { DirectoryEntry ent=new DirectoryEntry(Conn); LdapUrl Burl=new LdapUrl(_Bpath); string baseDn = Burl.getDN(); string eFdn=((baseDn != null && baseDn.Length != 0) ? (name + "," + baseDn) : name); LdapUrl curl=new LdapUrl(Burl.Host,Burl.Port,eFdn); ent.Path=curl.ToString(); ent.Nflag = true; return ent; }
/* * Ldap URL search */ /// <summary> Synchronously perfoms the search specified by the Ldap URL, using /// the specified search constraints (such as the maximum number of /// entries to find or the maximum time to wait for search results). /// /// When this method is called, a new connection is created /// automatically, using the host and port specified in the URL. After /// all search results have been received from the server, the method /// closes the connection (in other words, it disconnects from the Ldap /// server). /// /// As part of the search constraints, a choice can be made as to whether /// to have the results delivered all at once or in smaller batches. If /// the results are to be delivered in smaller batches, each iteration /// blocks only until the next batch of results is returned. /// /// /// </summary> /// <param name="toGet"> Ldap URL specifying the entry to read. /// /// </param> /// <param name="cons"> The constraints specific to the search. /// /// </param> /// <exception> LdapException A general exception which includes an error /// message and an Ldap error code. /// </exception> public static LdapSearchResults Search(LdapUrl toGet, LdapSearchConstraints cons) { LdapConnection lconn = new LdapConnection(); lconn.Connect(toGet.Host, toGet.Port); if (cons == null) { // This is a clone, so we already have our own copy cons = lconn.SearchConstraints; } else { // get our own copy of user's constraints because we modify it cons = (LdapSearchConstraints) cons.Clone(); } cons.BatchSize = 0; // Must wait until all results arrive LdapSearchResults toReturn = lconn.Search(toGet.getDN(), toGet.Scope, toGet.Filter, toGet.AttributeArray, false, cons); lconn.Disconnect(); return toReturn; }