public LdapUser(DirectoryEntry adentry, String userName, LdapSettings ldapSettings)
{
userid = new LdapAttribute("userid", userName);
DirectorySearcher ds = new DirectorySearcher(adentry);
ds.Filter = "(&(sAMAccountName=" + userName + "))";
SearchResult result = ds.FindOne();
DirectoryEntry ent = null;
if (result != null)
{
ent = result.GetDirectoryEntry();
}
if (ent != null)
{
if (ent.Properties["cn"].Value != null)
{
commonname = new LdapAttribute("commonname", ent.Properties["cn"].Value.ToString());
}
else
{
commonname = new LdapAttribute("commonname", userName);
}
if (ent.Properties["mail"].Value != null)
{
email = new LdapAttribute("email", ent.Properties["mail"].Value.ToString());
}
else
{
email = new LdapAttribute("email", userName + "@" + ldapSettings.Domain);
}
}
}
public static void doCleanup(LdapConnection conn, System.String userdn, System.String groupdn)
{
// since we have modified the user's attributes and failed to
// modify the group's attribute, we need to delete the modified
// user's attribute values.
// modifications for user
LdapModification[] modUser = new LdapModification[2];
// Delete the groupdn from the user's attributes
LdapAttribute membership = new LdapAttribute("groupMembership", groupdn);
modUser[0] = new LdapModification(LdapModification.DELETE, membership);
LdapAttribute security = new LdapAttribute("securityEquals", groupdn);
modUser[1] = new LdapModification(LdapModification.DELETE, security);
try
{
// Modify the user's attributes
conn.Modify(userdn, modUser);
System.Console.Out.WriteLine("Deleted the modified user's attribute values.");
}
catch (LdapException e)
{
System.Console.Out.WriteLine("Could not delete modified user's attributes: " + e.LdapErrorMessage);
}
catch(Exception e)
{
Console.WriteLine("Error:" + e.Message);
return;
}
return ;
}
public URLData(LdapAttribute enclosingInstance, sbyte[] data, int length)
{
InitBlock(enclosingInstance);
this.length = length;
this.data = data;
return ;
}
public static void Main(System.String[] args)
{
if (args.Length != 5)
{
System.Console.Out.WriteLine("Usage: mono VerifyPassword <host name>" + " <login dn> <password> <object dn>\n" + " <test password>");
System.Console.Out.WriteLine("Example: mono VerifyPassword Acme.com " + "\"cn=Admin,o=Acme\" secret\n" + " \"cn=JSmith,ou=Sales,o=Acme\" testPassword");
System.Environment.Exit(0);
}
int ldapPort = LdapConnection.DEFAULT_PORT;
int ldapVersion = LdapConnection.Ldap_V3;
System.String ldapHost = args[0];
System.String loginDN = args[1];
System.String password = args[2];
System.String objectDN = args[3];
System.String testPassword = args[4];
LdapConnection conn = new LdapConnection();
try
{
// connect to the server
conn.Connect(ldapHost, ldapPort);
// authenticate to the server
conn.Bind(ldapVersion, loginDN, password);
LdapAttribute attr = new LdapAttribute("userPassword", testPassword);
bool correct = conn.Compare(objectDN, attr);
System.Console.Out.WriteLine(correct?"The password is correct.":"The password is incorrect.\n");
// disconnect with the server
conn.Disconnect();
}
catch (LdapException e)
{
if (e.ResultCode == LdapException.NO_SUCH_OBJECT)
{
System.Console.Error.WriteLine("Error: No such entry");
}
else if (e.ResultCode == LdapException.NO_SUCH_ATTRIBUTE)
{
System.Console.Error.WriteLine("Error: No such attribute");
}
else
{
System.Console.Error.WriteLine("Error: " + e.ToString());
}
}
catch (System.IO.IOException e)
{
System.Console.Out.WriteLine("Error: " + e.ToString());
}
System.Environment.Exit(0);
}
static void Main(string[] args)
{
if ( args.Length != 5)
{
Console.WriteLine("Usage: mono ModifyEntry <host name> <ldap port> <login dn>" + " <password> <Modify dn>");
Console.WriteLine("Example: mono ModifyEntry Acme.com 389" + " \"cn=admin,o=Acme\"" + " secret \"cn=ksmith,o=Acme\"");
return;
}
string ldapHost = args[0];
int ldapPort = System.Convert.ToInt32(args[1]);
String loginDN = args[2];
String password = args[3];
String dn = args[4];
try
{
Console.WriteLine("Connecting to:" + ldapHost);
LdapConnection conn= new LdapConnection();
ArrayList modList = new ArrayList();
String desc = "This object belongs to test user";
// Add a new value to the description attribute
LdapAttribute attribute = new LdapAttribute( "description", desc);
modList.Add( new LdapModification(LdapModification.ADD, attribute));
String email = "*****@*****.**";
attribute = new LdapAttribute( "mail", email);
modList.Add( new LdapModification(LdapModification.REPLACE, attribute));
LdapModification[] mods = new LdapModification[modList.Count];
mods = (LdapModification[])modList.ToArray(typeof(LdapModification));
conn.Connect(ldapHost,ldapPort);
conn.Bind(loginDN,password);
conn.Modify(dn,mods);
Console.WriteLine(" Entry: " + dn + "Modified Successfully");
conn.Disconnect();
}
catch(LdapException e)
{
Console.WriteLine("Error:" + e.LdapErrorMessage);
return;
}
catch(Exception e)
{
Console.WriteLine("Error:" + e.Message);
return;
}
}
static void Main(string[] args)
{
if ( args.Length != 5)
{
Console.WriteLine("Usage: mono ModifyPass <host name> <ldap port> <login dn>" + " <old password> <new password>");
Console.WriteLine("Example: mono ModifyPass Acme.com 389" + " \"cn=tjhon,o=Acme\"" + " secret \"newpass\"");
return;
}
string ldapHost = args[0];
int ldapPort = System.Convert.ToInt32(args[1]);
String loginDN = args[2];
String opassword = args[3];
String npassword = args[4];
try
{
LdapConnection conn= new LdapConnection();
Console.WriteLine("Connecting to:" + ldapHost);
conn.Connect(ldapHost,ldapPort);
conn.Bind(loginDN,opassword);
LdapModification[] modifications = new LdapModification[2];
LdapAttribute deletePassword = new LdapAttribute("userPassword", opassword);
modifications[0] = new LdapModification(LdapModification.DELETE, deletePassword);
LdapAttribute addPassword = new LdapAttribute("userPassword", npassword);
modifications[1] = new LdapModification(LdapModification.ADD, addPassword);
conn.Modify(loginDN, modifications);
System.Console.Out.WriteLine("Your password has been modified.");
conn.Disconnect();
}
catch(LdapException e)
{
Console.WriteLine("Error:" + e.LdapErrorMessage);
return;
}
catch(Exception e)
{
Console.WriteLine("Error:" + e.Message);
return;
}
}
private System.Object[] values = null; // Array of byte[] attribute values
#endregion Fields
#region Constructors
/// <summary> Constructs an attribute with copies of all values of the input
/// attribute.
///
/// </summary>
/// <param name="attr"> An LdapAttribute to use as a template.
///
/// @throws IllegalArgumentException if attr is null
/// </param>
public LdapAttribute(LdapAttribute attr)
{
if (attr == null)
{
throw new System.ArgumentException("LdapAttribute class cannot be null");
}
// Do a deep copy of the LdapAttribute template
this.name = attr.name;
this.baseName = attr.baseName;
if (null != attr.subTypes)
{
this.subTypes = new System.String[attr.subTypes.Length];
Array.Copy((System.Array) attr.subTypes, 0, (System.Array) this.subTypes, 0, this.subTypes.Length);
}
// OK to just copy attributes, as the app only sees a deep copy of them
if (null != attr.values)
{
this.values = new System.Object[attr.values.Length];
Array.Copy((System.Array) attr.values, 0, (System.Array) this.values, 0, this.values.Length);
}
return ;
}
/// <summary> Asynchronously compares an attribute value with one in the directory,
/// using the specified queue and contraints.
///
/// Please note that a successful completion of this command results in
/// one of two status codes: LdapException.COMPARE_TRUE if the entry
/// has the value, and LdapException.COMPARE_FALSE if the entry
/// does not have the value or the attribute.
///
/// </summary>
/// <param name="dn"> The distinguished name of the entry containing an
/// attribute to compare.
///
/// </param>
/// <param name="attr"> An attribute to compare.
///
/// </param>
/// <param name="queue"> Handler for messages returned from a server in
/// response to this request. If it is null, a
/// queue object is created internally.
///
/// </param>
/// <param name="cons"> Constraints specific to the operation.
///
/// </param>
/// <exception> LdapException A general exception which includes an error
/// message and an Ldap error code.
///
/// </exception>
/// <seealso cref="LdapException.COMPARE_TRUE">
/// </seealso>
/// <seealso cref="LdapException.COMPARE_FALSE">
/// </seealso>
public virtual LdapResponseQueue Compare(System.String dn, LdapAttribute attr, LdapResponseQueue queue, LdapConstraints cons)
{
if (attr.size() != 1)
{
throw new System.ArgumentException("compare: Exactly one value " + "must be present in the LdapAttribute");
}
if ((System.Object) dn == null)
{
// Invalid parameter
throw new System.ArgumentException("compare: DN cannot be null");
}
if (cons == null)
cons = defSearchCons;
LdapMessage msg = new LdapCompareRequest(dn, attr.Name, attr.ByteValue, cons.getControls());
return SendRequestToServer(msg, cons.TimeLimit, queue, null);
}
/// <summary>
/// Synchronously checks to see if an entry contains an attribute with a
/// specified value, using the specified constraints.
///
/// </summary>
/// <param name="dn"> The distinguished name of the entry to use in the
/// comparison.
///
/// </param>
/// <param name="attr"> The attribute to compare against the entry. The
/// method checks to see if the entry has an
/// attribute with the same name and value as this
/// attribute.
///
/// </param>
/// <param name="cons"> Constraints specific to the operation.
///
/// </param>
/// <returns> True if the entry has the value,
/// and false if the entry does not
/// have the value or the attribute.
///
/// </returns>
/// <exception> LdapException A general exception which includes an error
/// message and an Ldap error code.
/// </exception>
public virtual bool Compare(System.String dn, LdapAttribute attr, LdapConstraints cons)
{
bool ret = false;
LdapResponseQueue queue = Compare(dn, attr, null, cons);
LdapResponse res = (LdapResponse) queue.getResponse();
// Set local copy of responseControls synchronously - if there were any
lock (responseCtlSemaphore)
{
responseCtls = res.Controls;
}
if (res.ResultCode == LdapException.COMPARE_TRUE)
{
ret = true;
}
else if (res.ResultCode == LdapException.COMPARE_FALSE)
{
ret = false;
}
else
{
chkResultCode(queue, cons, res);
}
return ret;
}
private void CommitEntry()
{
PropertyCollection properties = GetProperties(false);
if(!Nflag)
{
System.Collections.ArrayList modList = new System.Collections.ArrayList();
foreach (string attribute in properties.PropertyNames)
{
LdapAttribute attr=null;
if (properties [attribute].Mbit)
{
switch (properties [attribute].Count) {
case 0:
attr = new LdapAttribute (attribute, new string [0]);
modList.Add (new LdapModification (LdapModification.DELETE, attr));
break;
case 1:
string val = (string) properties [attribute].Value;
attr = new LdapAttribute (attribute, val);
modList.Add (new LdapModification (LdapModification.REPLACE, attr));
break;
default:
object [] vals = (object [])properties [attribute].Value;
string [] aStrVals = new string [properties [attribute].Count];
Array.Copy (vals, 0, aStrVals, 0, properties [attribute].Count);
attr = new LdapAttribute (attribute, aStrVals);
modList.Add (new LdapModification (LdapModification.REPLACE, attr));
break;
}
properties [attribute].Mbit=false;
}
}
if (modList.Count > 0) {
LdapModification[] mods = new LdapModification[modList.Count];
Type mtype = typeof (LdapModification);
mods = (LdapModification[])modList.ToArray(mtype);
ModEntry(mods);
}
}
else
{
LdapAttributeSet attributeSet = new LdapAttributeSet();
foreach (string attribute in properties.PropertyNames)
{
if (properties [attribute].Count == 1)
{
string val = (string) properties [attribute].Value;
attributeSet.Add(new LdapAttribute(attribute, val));
}
else
{
object[] vals = (object []) properties [attribute].Value;
string[] aStrVals = new string [properties [attribute].Count];
Array.Copy (vals,0,aStrVals,0,properties [attribute].Count);
attributeSet.Add( new LdapAttribute( attribute , aStrVals));
}
}
LdapEntry newEntry = new LdapEntry( Fdn, attributeSet );
conn.Add( newEntry );
Nflag = false;
}
}
private static bool AttrEquals(LdapAttribute attr, ATTRNAME name)
{
if (attr.Name.ToUpper().Equals(name.ToString()))
return true;
return false;
}
public void OnOkClicked(object o, EventArgs args)
{
Connection conn = GetCurrentConnection ();
LdapEntry[] sr = conn.Data.Search (conn.DirectoryRoot, searchEntry.Text);
foreach (object[] row in modListStore) {
string _action = (string) row[0];
string _name = (string) row[1];
string _value = (string) row[2];
LdapAttribute a = new LdapAttribute (_name, _value);
LdapModification m = null;
switch (_action.ToLower()) {
case "add":
m = new LdapModification (LdapModification.ADD, a);
break;
case "delete":
m = new LdapModification (LdapModification.DELETE, a);
break;
case "replace":
m = new LdapModification (LdapModification.REPLACE, a);
break;
default:
break;
}
if (m != null)
_modList.Add (m);
}
foreach (LdapEntry e in sr) {
Util.ModifyEntry (conn, e.DN, _modList.ToArray());
}
massEditDialog.HideAll ();
}
public static void Main( String[] args )
{
if (args.Length != 6)
{
Console.Error.WriteLine(
"Usage: mono ModifyACL <host name> <port number> <login dn>"
+ " <password> \n <entry dn> <trustee dn>");
Console.Error.WriteLine(
"Example: mono ModifyACL Acme.com 389 \"cn=Admin,o=Acme\""
+ " secret \n \"cn=test,ou=Sales,o=Acme\" "
+ "\"cn=trustee,o=Acme\"");
Environment.Exit(1);
}
int privileges = 0;
int ldapVersion = LdapConnection.Ldap_V3;
int ldapPort = System.Convert.ToInt32(args[1]);
String ldapHost = args[0];
String loginDN = args[2];
String password = args[3];
String entryDN = args[4];
String trusteeDN = args[5];
LdapConnection lc = new LdapConnection();
// encode ACL value
privileges |= System.Convert.ToInt32(LdapDSConstants.LDAP_DS_ENTRY_BROWSE);
privileges |= System.Convert.ToInt32(LdapDSConstants.LDAP_DS_ENTRY_ADD);
privileges |= System.Convert.ToInt32(LdapDSConstants.LDAP_DS_ENTRY_DELETE);
String aclValue = System.Convert.ToString(privileges)+ "#" + "entry" + "#"
+ trusteeDN + "#" + "[Entry Rights]";
try
{
// connect to the server
lc.Connect( ldapHost, ldapPort );
// bind to the server
lc.Bind(ldapVersion, loginDN, password);
// modify entryDN's ACL attribute
Console.WriteLine( " Entry DN: " + entryDN );
Console.WriteLine( " Trustee DN: " + trusteeDN );
Console.WriteLine( " Modifying entryDN's ACL value...");
LdapAttribute acl = new LdapAttribute( "acl", aclValue);
lc.Modify( entryDN, new LdapModification(LdapModification.ADD, acl));
Console.WriteLine(" Modified ACL values to grant trusteeDN the"
+ "\n 'read', 'write', and 'delete' entry rights.\n");
// display entryDN's ACL values
findACLValues(lc, entryDN);
// remove the Modified entryDN's ACL value
Console.WriteLine( "\n Removing the modified ACL value..." );
lc.Modify( entryDN, new LdapModification(LdapModification.DELETE,acl));
Console.WriteLine( " Removed modified ACL value." );
lc.Disconnect();
}
catch( LdapException e )
{
if ( e.ResultCode == LdapException.NO_SUCH_OBJECT )
Console.Error.WriteLine( "Error: ModifyACL.java, No such entry" );
else if ( e.ResultCode == LdapException.INSUFFICIENT_ACCESS_RIGHTS )
Console.Error.WriteLine("Error: ModifyACL.java, Insufficient rights");
else if ( e.ResultCode == LdapException.ATTRIBUTE_OR_VALUE_EXISTS )
Console.Error.WriteLine("Error: ModifyACL.java, Attribute or value "
+ "exists");
else
{
Console.WriteLine( "Error: ModifyACL.java, " + e.ToString() );
}
Environment.Exit(1);
}
catch( Exception e )
{
Console.WriteLine( "Error: " + e.ToString() );
}
Environment.Exit(0);
}
/// <summary> Returns <code>true</code> if this set contains an attribute of the same name
/// as the specified attribute.
///
/// </summary>
/// <param name="attr"> Object of type <code>LdapAttribute</code>
///
/// </param>
/// <returns> true if this set contains the specified attribute
///
/// @throws ClassCastException occurs the specified Object
/// is not of type LdapAttribute.
/// </returns>
public override bool Contains(object attr)
{
LdapAttribute attribute = (LdapAttribute)attr;
return(map.ContainsKey(attribute.Name.ToUpper()));
}
public UrlData(LdapAttribute enclosingInstance, byte[] data, int length)
{
EnclosingInstance = enclosingInstance;
_length = length;
_data = data;
}
/// <summary> Specifies a modification to be made to an attribute.
///
/// </summary>
/// <param name="op"> The type of modification to make, which can be
/// one of the following:
/// <ul>
/// <li>LdapModification.ADD - The value should be added to
/// the attribute</li>
///
/// <li>LdapModification.DELETE - The value should be removed
/// from the attribute </li>
///
/// <li>LdapModification.REPLACE - The value should replace all
/// existing values of the
/// attribute </li>
/// </ul>
/// </param>
/// <param name="attr"> The attribute to modify.
///
/// </param>
public LdapModification(int op, LdapAttribute attr)
{
this.op = op;
this.attr = attr;
return;
}
public URLData(LdapAttribute enclosingInstance, sbyte[] data, int length)
{
InitBlock(enclosingInstance);
this.length = length;
this.data = data;
}
private void InitBlock(LdapAttribute enclosingInstance)
{
this.enclosingInstance = enclosingInstance;
}
private void CommitEntry()
{
if(!Nflag)
{
System.Collections.ArrayList modList = new System.Collections.ArrayList();
System.Collections.IDictionaryEnumerator id = Properties.GetEnumerator();
while(id.MoveNext())
{
string attribute=(string)id.Key;
LdapAttribute attr=null;
if(Properties[attribute].Mbit)
{
if(Properties[attribute].Count==1)
{
String val = (String)Properties[attribute].Value;
attr = new LdapAttribute( attribute , val);
}
else
{
Object[] vals=(Object [])Properties[attribute].Value;
String[] aStrVals= new String[Properties[attribute].Count];
Array.Copy(vals,0,aStrVals,0,Properties[attribute].Count);
attr = new LdapAttribute( attribute , aStrVals);
}
modList.Add( new LdapModification(LdapModification.REPLACE, attr));
Properties[attribute].Mbit=false;
}
}
if (modList.Count > 0) {
LdapModification[] mods = new LdapModification[modList.Count];
Type mtype=Type.GetType("System.DirectoryServices.LdapModification");
mods = (LdapModification[])modList.ToArray(typeof(LdapModification));
ModEntry(mods);
}
}
else
{
LdapAttributeSet attributeSet = new LdapAttributeSet();
System.Collections.IDictionaryEnumerator id = Properties.GetEnumerator();
while(id.MoveNext())
{
string attribute=(string)id.Key;
if(Properties[attribute].Count==1)
{
String val = (String)Properties[attribute].Value;
attributeSet.Add(new LdapAttribute(attribute, val));
}
else
{
Object[] vals=(Object [])Properties[attribute].Value;
String[] aStrVals= new String[Properties[attribute].Count];
Array.Copy(vals,0,aStrVals,0,Properties[attribute].Count);
attributeSet.Add( new LdapAttribute( attribute , aStrVals));
}
}
LdapEntry newEntry = new LdapEntry( Fdn, attributeSet );
conn.Add( newEntry );
Nflag = false;
}
}
/// <summary>Copy a directory entry
/// </summary>
/// <param name="oldDN">Distinguished name of the entry to copy</param>
/// <param name="newRDN">New name for entry</param>
/// <param name="parentDN">Parent name</param>
public void Copy(string oldDN, string newRDN, string parentDN)
{
string newDN = string.Format ("{0},{1}", newRDN, parentDN);
LdapEntry[] entry = Search (oldDN, LdapConnection.SCOPE_BASE, "objectclass=*", null);
if (!(entry.Length > 0))
return;
LdapEntry oldEntry = entry[0];
LdapAttributeSet attributeSet = new LdapAttributeSet();
foreach (LdapAttribute attr in oldEntry.getAttributeSet()) {
LdapAttribute newAttr = new LdapAttribute (attr);
attributeSet.Add (newAttr);
}
LdapEntry le = new LdapEntry (newDN, attributeSet);
conn.Add (le);
}
/// <summary>
/// Compares current values in eDirectory with the values of the object that is to be written to eDirectory
/// The results are returned as an LdapModifications array
/// </summary>
/// <param name="newApp">
/// A <see cref="LDAPZFDApp"/>
/// </param>
/// <param name="oldApp">
/// A <see cref="LDAPZFDApp"/>
/// </param>
/// <returns>
/// A <see cref="LdapModification[]"/>
/// </returns>
internal static ArrayList BuildZFDAppModifications(LDAPZFDApp newApp, LDAPZFDApp oldApp)
{
LdapAttribute attribute;
ArrayList modList = new ArrayList();
/* If associations list do not match, replace */
if (newApp.getZENAppAssociations().SequenceEqual(oldApp.getZENAppAssociations()) == false) {
Logger.Debug("Current Associations and modified Associations do not match {0}", newApp.getDN());
attribute = new LdapAttribute( "appAssociations", newApp.getZENAppAssociations().ToArray());
modList.Add( new LdapModification(LdapModification.REPLACE, attribute)); //Add to the list of mods
}
return modList;
}
public static bool _AddUserToGroup(LdapConnection conn, System.String userdn, System.String groupdn)
{
// modifications for group and user
LdapModification[] modGroup = new LdapModification[2];
LdapModification[] modUser = new LdapModification[2];
// Add modifications to modUser
LdapAttribute membership = new LdapAttribute("groupMembership", groupdn);
modUser[0] = new LdapModification(LdapModification.ADD, membership);
LdapAttribute security = new LdapAttribute("securityEquals", groupdn);
modUser[1] = new LdapModification(LdapModification.ADD, security);
// Add modifications to modGroup
LdapAttribute member = new LdapAttribute("uniqueMember", userdn);
modGroup[0] = new LdapModification(LdapModification.ADD, member);
LdapAttribute equivalent = new LdapAttribute("equivalentToMe", userdn);
modGroup[1] = new LdapModification(LdapModification.ADD, equivalent);
try
{
// Modify the user's attributes
conn.Modify(userdn, modUser);
System.Console.Out.WriteLine("Modified the user's attribute.");
}
catch (LdapException e)
{
System.Console.Out.WriteLine("Failed to modify user's attributes: " + e.LdapErrorMessage);
return false;
}
try
{
// Modify the group's attributes
conn.Modify(groupdn, modGroup);
System.Console.Out.WriteLine("Modified the group's attribute.");
}
catch (LdapException e)
{
System.Console.Out.WriteLine("Failed to modify group's attributes: " + e.LdapErrorMessage);
doCleanup(conn, userdn, groupdn);
return false;
}
catch(Exception e)
{
Console.WriteLine("Error:" + e.Message);
return false;
}
return true;
}
void ChangePassword(LdapEntry entry, PasswordDialog pd)
{
List<LdapModification> mods = new List<LdapModification> ();
LdapAttribute la;
LdapModification lm;
la = new LdapAttribute ("userPassword", pd.UnixPassword);
lm = new LdapModification (LdapModification.REPLACE, la);
mods.Add (lm);
if (Util.CheckSamba (entry)) {
la = new LdapAttribute ("sambaLMPassword", pd.LMPassword);
lm = new LdapModification (LdapModification.REPLACE, la);
mods.Add (lm);
la = new LdapAttribute ("sambaNTPassword", pd.NTPassword);
lm = new LdapModification (LdapModification.REPLACE, la);
mods.Add (lm);
}
Util.ModifyEntry (conn, entry.DN, mods.ToArray());
}
public void OnAddGroupClicked(object o, EventArgs args)
{
List<string> tmp = new List<string> ();
foreach (KeyValuePair<string, LdapEntry> kvp in _allGroups) {
if (kvp.Key == primaryGroupLabel.Text || _memberOfGroups.ContainsKey (kvp.Key))
continue;
tmp.Add (kvp.Key);
}
SelectGroupsDialog sgd = new SelectGroupsDialog (tmp.ToArray ());
foreach (string name in sgd.SelectedGroupNames) {
_memberOfStore.AppendValues (name);
if (!_memberOfGroups.ContainsKey (name))
_memberOfGroups.Add (name, "memberUid");
LdapAttribute attr = new LdapAttribute ("memberUid", conn.Data.GetAttributeValueFromEntry (currentEntry, "uid"));
LdapModification lm = new LdapModification (LdapModification.ADD, attr);
_modsGroup.Add (name, lm);
updateGroupMembership ();
_modsGroup.Clear ();
}
}
private void InitBlock(LdapAttribute enclosingInstance)
{
this.enclosingInstance = enclosingInstance;
}
public void OnRemoveGroupClicked(object o, EventArgs args)
{
TreeModel model;
TreeIter iter;
TreePath[] tp = memberOfTreeview.Selection.GetSelectedRows (out model);
for (int i = tp.Length; i > 0; i--) {
_memberOfStore.GetIter (out iter, tp[(i - 1)]);
string name = (string) _memberOfStore.GetValue (iter, 0);
_memberOfStore.Remove (ref iter);
if (_memberOfGroups.ContainsKey (name))
_memberOfGroups.Remove (name);
LdapAttribute attr = new LdapAttribute ("memberUid", conn.Data.GetAttributeValueFromEntry (currentEntry, "uid"));
LdapModification lm = new LdapModification (LdapModification.DELETE, attr);
_modsGroup.Add (name, lm);
updateGroupMembership ();
_modsGroup.Clear ();
}
}
public static void Main( String[] args )
{
if (args.Length != 4)
{
Console.Error.WriteLine("Usage: mono CompareAttrs <host name> <login dn> "
+ "<password> <compare dn> ");
Console.Error.WriteLine("Example: mono CompareAttrs Acme.com \"cn=Admin,"
+ "o=Acme\" secret\n \"cn=JSmith,ou=Sales,o=Acme\"");
Environment.Exit(1);
}
int ldapPort = LdapConnection.DEFAULT_PORT;
int ldapVersion = LdapConnection.Ldap_V3;
bool compareResults = false;
String ldapHost = args[0];
String loginDN = args[1];
String password = args[2];
String dn = args[3];
LdapConnection lc = new LdapConnection();
LdapAttribute attr = null;
try
{
// connect to the server
lc.Connect( ldapHost, ldapPort );
// authenticate to the server
lc.Bind( ldapVersion, loginDN, password );
attr =new LdapAttribute( "objectclass", "inetOrgPerson" );
System.Collections.IEnumerator allValues = attr.StringValues;
allValues.MoveNext();
// Compare the value of the objectclass attribute.
if ( compareResults == lc.Compare(dn, attr))
Console.WriteLine("\t" + (String)allValues.Current
+ " is contained in the " + attr.Name + " attribute." );
else
Console.WriteLine("\t" + (String)allValues.Current
+ " is not contained in the " + attr.Name + " attribute." );
attr = new LdapAttribute( "sn", "Bunny" );
allValues = attr.StringValues;
allValues.MoveNext();
// Compare the value of the sn attribute.
if ( compareResults == lc.Compare(dn, attr))
Console.WriteLine("\t" + (String)allValues.Current
+ " is contained in the " + attr.Name + " attribute." );
else
Console.WriteLine("\t" + (String)allValues.Current
+ " is not contained in the " + attr.Name + " attribute." );
// disconnect with the server
lc.Disconnect();
}
catch( LdapException e )
{
Console.WriteLine( "Error: " + e.ToString() );
}
catch( Exception e )
{
Console.WriteLine( "Error: " + e.ToString() );
}
Environment.Exit(0);
}
static bool IsAttributeEmpty(LdapAttribute attribute)
{
if (attribute == null)
return true;
if (attribute.size() == 0)
return true;
if (attribute.StringValue == null || attribute.StringValue == "")
return true;
return false;
}
//*************************************************************************
// compare methods
//*************************************************************************
/// <summary>
/// Synchronously checks to see if an entry contains an attribute
/// with a specified value.
///
/// </summary>
/// <param name="dn"> The distinguished name of the entry to use in the
/// comparison.
///
/// </param>
/// <param name="attr"> The attribute to compare against the entry. The
/// method checks to see if the entry has an
/// attribute with the same name and value as this
/// attribute.
///
/// </param>
/// <returns> True if the entry has the value,
/// and false if the entry does not
/// have the value or the attribute.
///
/// </returns>
/// <exception> LdapException A general exception which includes an error
/// message and an Ldap error code.
/// </exception>
public virtual bool Compare(System.String dn, LdapAttribute attr)
{
return Compare(dn, attr, defSearchCons);
}
public void Run(LdapEntry lhs, LdapEntry rhs)
{
Log.Debug ("Starting LdapEntryAnalyzer");
if (lhs.CompareTo (rhs) != 0) {
Log.Debug ("Entry DNs don't match\nlhs: {0}\nrhs: {1}", lhs.DN, rhs.DN);
return;
}
LdapAttributeSet las = lhs.getAttributeSet ();
foreach (LdapAttribute la in las) {
LdapAttribute rla = rhs.getAttribute (la.Name);
if (rla == null){
Log.Debug ("Delete attribute {0} from {1}", la.Name, lhs.DN);
LdapAttribute a = new LdapAttribute (la.Name);
LdapModification m = new LdapModification (LdapModification.DELETE, a);
mods.Add (m);
} else {
if (rla.StringValueArray.Length > 1) {
Log.Debug ("Replacing attribute {0} with multiple values", la.Name);
LdapAttribute a = new LdapAttribute (la.Name, rla.StringValueArray);
LdapModification m = new LdapModification (LdapModification.REPLACE, a);
mods.Add (m);
} else if (la.StringValue != rla.StringValue) {
LdapAttribute newattr;
LdapModification lm;
if (rla.StringValue == "" || rla.StringValue == null) {
Log.Debug ("Delete attribute {0} from {1}", la.Name, lhs.DN);
newattr = new LdapAttribute (la.Name);
lm = new LdapModification (LdapModification.DELETE, newattr);
} else {
Log.Debug ("Replace attribute {0} value from {1} to {2} ", la.Name, la.StringValue, rla.StringValue);
newattr = new LdapAttribute (la.Name, rla.StringValue);
lm = new LdapModification (LdapModification.REPLACE, newattr);
}
mods.Add (lm);
}
}
}
LdapAttributeSet rlas = rhs.getAttributeSet ();
foreach (LdapAttribute la in rlas) {
LdapAttribute lla = lhs.getAttribute (la.Name);
if (lla == null && la.StringValue != string.Empty) {
Log.Debug ("Add attribute {0} value [{1}] to {2}", la.Name, la.StringValue, lhs.DN);
LdapAttribute a = new LdapAttribute (la.Name, la.StringValue);
LdapModification m = new LdapModification (LdapModification.ADD, a);
mods.Add (m);
}
}
Log.Debug ("End LdapEntryAnalyzer");
}
/// <summary> Asynchronously compares an attribute value with one in the directory,
/// using the specified queue.
///
/// Please note that a successful completion of this command results in
/// one of two status codes: LdapException.COMPARE_TRUE if the entry
/// has the value, and LdapException.COMPARE_FALSE if the entry
/// does not have the value or the attribute.
///
/// </summary>
/// <param name="dn"> The distinguished name of the entry containing an
/// attribute to compare.
///
/// </param>
/// <param name="attr"> An attribute to compare.
///
/// </param>
/// <param name="queue"> The queue for messages returned from a server in
/// response to this request. If it is null, a
/// queue object is created internally.
///
/// </param>
/// <exception> LdapException A general exception which includes an error
/// message and an Ldap error code.
///
/// </exception>
/// <seealso cref="LdapException.COMPARE_TRUE">
/// </seealso>
/// <seealso cref="LdapException.COMPARE_FALSE">
/// </seealso>
public virtual LdapResponseQueue Compare(System.String dn, LdapAttribute attr, LdapResponseQueue queue)
{
return Compare(dn, attr, queue, defSearchCons);
}
/// <summary> Specifies a modification to be made to an attribute.
///
/// </summary>
/// <param name="op"> The type of modification to make, which can be
/// one of the following:
/// <ul>
/// <li>LdapModification.ADD - The value should be added to
/// the attribute</li>
///
/// <li>LdapModification.DELETE - The value should be removed
/// from the attribute </li>
///
/// <li>LdapModification.REPLACE - The value should replace all
/// existing values of the
/// attribute </li>
/// </ul>
/// </param>
/// <param name="attr"> The attribute to modify.
///
/// </param>
public LdapModification(int op, LdapAttribute attr)
{
this.op = op;
this.attr = attr;
return ;
}
public String ConvNull2Blank(LdapAttribute str)
{
if (str == null)
return " ";
else
return str.StringValue;
}
public void OnOkClicked(object o, EventArgs args)
{
string dn = String.Format ("{0},{1}", rdnEntry.Text, browseButton.Label);
LdapAttributeSet lset = new LdapAttributeSet ();
foreach (object[] row in attrListStore) {
string n = (string) row[0];
string v = (string) row[1];
if (n == null || v == null || v == "")
continue;
if (n.ToLower() == "objectclass") {
if (objAttr == null)
objAttr = new LdapAttribute (n, v);
else
objAttr.addValue (v);
} else {
LdapAttribute attr = new LdapAttribute (n, v);
lset.Add (attr);
}
}
lset.Add (objAttr);
LdapEntry entry = new LdapEntry (dn, lset);
if (!Util.AddEntry (conn, entry))
errorOccured = true;
else
errorOccured = false;
}
//public LdapUser(LdapSettings ldapSettings, String userName)
//{
// // in some cases with Active Directory
// // we can't actually retrieve ldap entries
// // we really just need to create a mojoportal user
// // from the ldap user so if we can't read it, just create an ldap user
// // with the properties we do have
// // Active Directory allows us to bind a connection for authentication
// // even if we can't query for entries
// email = new LdapAttribute("email", userName + "@" + ldapSettings.Domain);
// commonname = new LdapAttribute("commonname", userName);
// userid = new LdapAttribute("userid", userName);
//}
public LdapUser(LdapEntry entry)
{
dn = entry.DN;
LdapAttributeSet las = entry.getAttributeSet();
foreach(LdapAttribute a in las)
{
switch(a.Name)
{
case "mail":
this.email = a;
break;
case "cn":
this.commonname = a;
break;
case "userPassword":
this.password = a;
break;
case "uidNumber":
this.uidNumber = a;
break;
case "uid":
this.userid = a;
break;
case "sAMAccountName":
this.userid = a;
break;
case "givenName":
this.firstName = a.StringValue;
break;
case "sn":
this.lastName = a.StringValue;
break;
}
}
}
/// <summary> Constructs an LdapSchema object from attributes of an LdapEntry.
/// The object is empty if the entry parameter contains no schema
/// attributes. The recognized schema attributes are the following:
/// <pre><code>
/// "attributeTypes", "objectClasses", "ldapSyntaxes",
/// "nameForms", "dITContentRules", "dITStructureRules",
/// "matchingRules","matchingRuleUse"
/// </code></pre>
/// </summary>
/// <param name="ent"> An LdapEntry containing schema information.
/// </param>
public LdapSchema(LdapEntry ent) : base(ent.DN, ent.getAttributeSet())
{
InitBlock();
//reset all definitions
for (int i = 0; i < schemaTypeNames.Length; i++)
{
idTable[i] = new System.Collections.Hashtable();
nameTable[i] = new System.Collections.Hashtable();
}
System.Collections.IEnumerator itr = base.getAttributeSet().GetEnumerator();
while (itr.MoveNext())
{
LdapAttribute attr = (LdapAttribute)itr.Current;
System.String value_Renamed, attrName = attr.Name;
System.Collections.IEnumerator enumString = attr.StringValues;
if (attrName.ToUpper().Equals(schemaTypeNames[OBJECT_CLASS].ToUpper()))
{
LdapObjectClassSchema classSchema;
while (enumString.MoveNext())
{
value_Renamed = ((System.String)enumString.Current);
try
{
classSchema = new LdapObjectClassSchema(value_Renamed);
}
catch (System.Exception e)
{
continue; //Error parsing: do not add this definition
}
addElement(OBJECT_CLASS, classSchema);
}
}
else if (attrName.ToUpper().Equals(schemaTypeNames[ATTRIBUTE].ToUpper()))
{
LdapAttributeSchema attrSchema;
while (enumString.MoveNext())
{
value_Renamed = ((System.String)enumString.Current);
try
{
attrSchema = new LdapAttributeSchema(value_Renamed);
}
catch (System.Exception e)
{
continue; //Error parsing: do not add this definition
}
addElement(ATTRIBUTE, attrSchema);
}
}
else if (attrName.ToUpper().Equals(schemaTypeNames[SYNTAX].ToUpper()))
{
LdapSyntaxSchema syntaxSchema;
while (enumString.MoveNext())
{
value_Renamed = ((System.String)enumString.Current);
syntaxSchema = new LdapSyntaxSchema(value_Renamed);
addElement(SYNTAX, syntaxSchema);
}
}
else if (attrName.ToUpper().Equals(schemaTypeNames[MATCHING].ToUpper()))
{
LdapMatchingRuleSchema matchingRuleSchema;
while (enumString.MoveNext())
{
value_Renamed = ((System.String)enumString.Current);
matchingRuleSchema = new LdapMatchingRuleSchema(value_Renamed, null);
addElement(MATCHING, matchingRuleSchema);
}
}
else if (attrName.ToUpper().Equals(schemaTypeNames[MATCHING_USE].ToUpper()))
{
LdapMatchingRuleUseSchema matchingRuleUseSchema;
while (enumString.MoveNext())
{
value_Renamed = ((System.String)enumString.Current);
matchingRuleUseSchema = new LdapMatchingRuleUseSchema(value_Renamed);
addElement(MATCHING_USE, matchingRuleUseSchema);
}
}
else if (attrName.ToUpper().Equals(schemaTypeNames[DITCONTENT].ToUpper()))
{
LdapDITContentRuleSchema dITContentRuleSchema;
while (enumString.MoveNext())
{
value_Renamed = ((System.String)enumString.Current);
dITContentRuleSchema = new LdapDITContentRuleSchema(value_Renamed);
addElement(DITCONTENT, dITContentRuleSchema);
}
}
else if (attrName.ToUpper().Equals(schemaTypeNames[DITSTRUCTURE].ToUpper()))
{
LdapDITStructureRuleSchema dITStructureRuleSchema;
while (enumString.MoveNext())
{
value_Renamed = ((System.String)enumString.Current);
dITStructureRuleSchema = new LdapDITStructureRuleSchema(value_Renamed);
addElement(DITSTRUCTURE, dITStructureRuleSchema);
}
}
else if (attrName.ToUpper().Equals(schemaTypeNames[NAME_FORM].ToUpper()))
{
LdapNameFormSchema nameFormSchema;
while (enumString.MoveNext())
{
value_Renamed = ((System.String)enumString.Current);
nameFormSchema = new LdapNameFormSchema(value_Renamed);
addElement(NAME_FORM, nameFormSchema);
}
}
//All non schema attributes are ignored.
continue;
}
}