public void AddRange(DirectoryAttributeModification[] attributes) { if (attributes != null) { DirectoryAttributeModification[] directoryAttributeModificationArray = attributes; int num = 0; while (num < (int)directoryAttributeModificationArray.Length) { DirectoryAttributeModification directoryAttributeModification = directoryAttributeModificationArray[num]; if (directoryAttributeModification != null) { num++; } else { throw new ArgumentException(Res.GetString("NullDirectoryAttributeCollection")); } } base.InnerList.AddRange(attributes); return; } else { throw new ArgumentNullException("attributes"); } }
public ModifyRequest(string distinguishedName, DirectoryAttributeOperation operation, string attributeName, params object[] values) : this() { // Store off the distinguished name _dn = distinguishedName; // validate the attributeName if (attributeName == null) { throw new ArgumentNullException("attributeName"); } DirectoryAttributeModification mod = new DirectoryAttributeModification(); mod.Operation = operation; mod.Name = attributeName; if (values != null) { for (int i = 0; i < values.Length; i++) { mod.Add(values[i]); } } _attributeModificationList.Add(mod); }
public void Insert(int index, DirectoryAttributeModification value) { if (value == null) { throw new ArgumentException(Res.GetString("NullDirectoryAttributeCollection")); } base.List.Insert(index, value); }
public int Add(DirectoryAttributeModification attribute) { if (attribute == null) { throw new ArgumentException(Res.GetString("NullDirectoryAttributeCollection")); } return base.List.Add(attribute); }
public int Add(DirectoryAttributeModification attribute) { if (attribute == null) { throw new ArgumentException(Res.GetString("NullDirectoryAttributeCollection")); } return(base.List.Add(attribute)); }
static DirectoryAttributeModification ToAttr (DirectoryAttributeOperation operation, string attributeName, params object [] values) { var a = new DirectoryAttributeModification (); a.Name = attributeName; a.Operation = operation; a.AddRange (values); return a; }
public void Insert(int index, DirectoryAttributeModification value) { if (value == null) { throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, SR.NullDirectoryAttributeCollection)); } List.Insert(index, value); }
public int Add(DirectoryAttributeModification attribute) { if (attribute == null) { throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, SR.NullDirectoryAttributeCollection)); } return(List.Add(attribute)); }
static DirectoryAttributeModification ToAttr(DirectoryAttributeOperation operation, string attributeName, params object [] values) { var a = new DirectoryAttributeModification(); a.Name = attributeName; a.Operation = operation; a.AddRange(values); return(a); }
public static ModifyRequest GetModifyPasswordRequest(ILdapUser user, string newPassword) { var modifyUserPassword = new DirectoryAttributeModification { Operation = DirectoryAttributeOperation.Replace, Name = "userPassword" }; modifyUserPassword.Add(newPassword); return new ModifyRequest(user.GetUserDn(), modifyUserPassword); }
public void ModifyPasswordRequest() { ModifyRequest req = LdapRequestBuilder.GetModifyPasswordRequest(_testUser, "new pwd"); Assert.AreEqual(UserDn, req.DistinguishedName); var attributeModification = new DirectoryAttributeModification { Operation = DirectoryAttributeOperation.Replace, Name = "userPassword", }; attributeModification.Add("new pwd"); CollectionAssert.AreEqual(req.Modifications[0], attributeModification); }
public void AddRange(DirectoryAttributeModification[] attributes) { if (attributes == null) { throw new ArgumentNullException("attributes"); } DirectoryAttributeModification[] modificationArray = attributes; for (int i = 0; i < modificationArray.Length; i++) { if (modificationArray[i] == null) { throw new ArgumentException(Res.GetString("NullDirectoryAttributeCollection")); } } base.InnerList.AddRange(attributes); }
public void ModifyRequest() { ModifyRequest req = LdapRequestBuilder.GetModifyRequest(_testUser, DirectoryAttributeOperation.Replace, "description", "Test Description 2"); Assert.AreEqual(UserDn, req.DistinguishedName); var attributeModification = new DirectoryAttributeModification { Operation = DirectoryAttributeOperation.Replace, Name = "description", }; attributeModification.Add("Test Description 2"); CollectionAssert.AreEqual(req.Modifications[0], attributeModification); }
public static bool ChangePassword(LdapConnection connection, string userDN, string oldPassword, string newPassword, bool dryRun = false) { // Create change password request DirectoryAttributeModification deleteMod = new DirectoryAttributeModification(); deleteMod.Name = "unicodePwd"; deleteMod.Add(Encoding.Unicode.GetBytes("\"" + oldPassword + "\"")); deleteMod.Operation = DirectoryAttributeOperation.Delete; DirectoryAttributeModification addMod = new DirectoryAttributeModification(); addMod.Name = "unicodePwd"; addMod.Add(Encoding.Unicode.GetBytes("\"" + newPassword + "\"")); addMod.Operation = DirectoryAttributeOperation.Add; ModifyRequest request = new ModifyRequest(userDN, deleteMod, addMod); try { if (!dryRun) { DirectoryResponse response = connection.SendRequest(request); return response.ResultCode == 0; } else { return true; } } catch (DirectoryOperationException ex) { if (ex.Response.ErrorMessage.StartsWith("0000052D")) { throw new Exception("Unable to update the password. The value provided for the new password does not meet the length, complexity, or history requirements of the domain."); } // TODO: Convert to DirectoryOperationException and use better match to give the dsHeuristics exception else if (ex.Message == "The object does not exist") { throw new Exception("User not allowed to change own password because of missing permission, set dsHeuristics to 0000000001001 on CN=Directory Service,CN=Windows NT,CN=Services,CN=Configuration,CN=..."); } else { throw; } } }
public ModifyRequest(string distinguishedName, DirectoryAttributeOperation operation, string attributeName, params object[] values) : this() { this.dn = distinguishedName; if (attributeName == null) { throw new ArgumentNullException("attributeName"); } DirectoryAttributeModification attribute = new DirectoryAttributeModification { Operation = operation, Name = attributeName }; if (values != null) { for (int i = 0; i < values.Length; i++) { attribute.Add(values[i]); } } this.attributeModificationList.Add(attribute); }
public ModifyRequest(string distinguishedName, DirectoryAttributeOperation operation, string attributeName, object[] values) : this() { this.dn = distinguishedName; if (attributeName != null) { DirectoryAttributeModification directoryAttributeModification = new DirectoryAttributeModification(); directoryAttributeModification.Operation = operation; directoryAttributeModification.Name = attributeName; if (values != null) { for (int i = 0; i < (int)values.Length; i++) { directoryAttributeModification.Add(values[i]); } } this.attributeModificationList.Add(directoryAttributeModification); return; } else { throw new ArgumentNullException("attributeName"); } }
public bool Contains (DirectoryAttributeModification value) { return List.Contains (value); }
public int Add (DirectoryAttributeModification attribute) { return List.Add (attribute); }
public void AddRange (DirectoryAttributeModification [] attributes) { foreach (var a in attributes) List.Add (a); }
private ResultCode ModifyUserInGroup(string userName, string groupName, DirectoryAttributeOperation operation) { if (!this.UserExist(userName)) return ResultCode.NoSuchObject; AdamUser user = this.GetUser(userName); if ((user.Groups.Contains(groupName) && operation == DirectoryAttributeOperation.Add)) return ResultCode.EntryAlreadyExists; else if ((!user.Groups.Contains(groupName) && operation == DirectoryAttributeOperation.Delete)) return ResultCode.NoSuchAttribute; string filter = string.Format("(&(objectClass=Group)(distinguishedName=CN={0},{1}))", groupName, this.GroupsDistinguishedName); this.OpenConnection(); SearchRequest srchRequestGroup = new SearchRequest(this.GroupsDistinguishedName, filter, SearchScope.Subtree); SearchResponse srchResponseGroup = (SearchResponse)this._adamConnection.SendRequest(srchRequestGroup); this.CloseConnection(); SearchResultEntry srchEntryGrp = srchResponseGroup.Entries[0]; string groupDN = srchEntryGrp.DistinguishedName; DirectoryAttributeModification addMod = new DirectoryAttributeModification(); addMod.Name = "member"; addMod.Add(user.DistinguishedName); addMod.Operation = operation; ModifyRequest modRequestAddUser = new ModifyRequest(groupDN, addMod); this.OpenConnection(); DirectoryResponse modResponseAdduser = this._adamConnection.SendRequest(modRequestAddUser); this.CloseConnection(); return modResponseAdduser.ResultCode; }
public bool SetUserAttribute(string uname, string attribute, string value) { string userDN = this.GetUserDN(uname); try { DirectoryAttributeModification mod = new DirectoryAttributeModification { Name = attribute, Operation = DirectoryAttributeOperation.Replace }; mod.Add(value); ModifyRequest req = new ModifyRequest(userDN); req.Modifications.Add(mod); m_conn.SendRequest(req); } catch (Exception e) { m_logger.FatalFormat("can't add attribute:{0} because of error:{1}", attribute, e.Message); return false; } if (attribute.ToLower().Equals("sambapwdlastset")) { Dictionary<string, List<string>> SearchResult = GetUserAttribValue(userDN, "(objectClass=*)", SearchScope.Subtree, new string[] { "shadowMax", "sambaPwdMustChange" }); if (SearchResult.ContainsKey("shadowmax") && SearchResult.ContainsKey("sambapwdmustchange")) { int shadowMax = 0; try { shadowMax = Convert.ToInt32(SearchResult["shadowmax"].First()); } catch (Exception e) { m_logger.FatalFormat("SetUserAttribute: Unable to convert return from GetUserAttribValue to int {0}", e.Message); return false; } if (shadowMax > 0) { TimeMethod time = TimeMethod.methods[Methods.Timestamps]; string t = time.time(new TimeSpan(shadowMax, 0, 0, 0)); if (!t.Equals("0")) if (!SetUserAttribute(uname, "sambaPwdMustChange", t)) return false; } } } return true; }
public void Insert (int index, DirectoryAttributeModification value) { List.Insert (index, value); }
/// <summary> /// On a new/uncommitted entry, check for any in-queue Add / Replace operations on 'propName' /// and remove 'value' if present. On a regular existing entry, queue a deletion of the /// specified value. /// </summary> /// <param name="propName"></param> /// <param name="value"></param> public void RemoveAttrValue(string attrName, string value) { CheckForDeletion(); string propName = attrName.ToLowerInvariant(); if (this.IsNewEntry) { if (_changes.ContainsKey(propName)) { DirectoryAttributeModification dam = _changes[propName]; if (dam.Contains(value)) dam.Remove(value); } } else { string key = propName + "*d"; if (_changes.ContainsKey(key)) { DirectoryAttributeModification dam = _changes[key]; if (!dam.Contains(value)) dam.Add(value); } else { DirectoryAttributeModification dam = new DirectoryAttributeModification(); dam.Operation = DirectoryAttributeOperation.Delete; dam.Name = propName; dam.Add(value); _changes[key] = dam; } } }
public void Remove(DirectoryAttributeModification value) { List.Remove(value); }
/// <summary> /// Replace the values of 'propName' with 'values'. If there is already an in-flight Replace request on /// 'propName', this method will add to its values. /// </summary> /// <param name="propName"></param> /// <param name="values"></param> public void SetAttr(string attrName, object[] values) { CheckForDeletion(); attrName = attrName.ToLowerInvariant(); DirectoryAttributeModification dam; if (_changes.ContainsKey(attrName)) { dam = _changes[attrName]; if (dam.Operation != DirectoryAttributeOperation.Replace) { if (this.ConflictMode == ConflictModes.Error) { throw new IncompatibleMutationException(String.Format( "Change buffer already contains a request to modify {0} as {1}", attrName, dam.Operation)); } else { logger.Info("Overriding {0} request on attr {1} with Replace", dam.Operation, attrName); dam = new DirectoryAttributeModification(); dam.Name = attrName; dam.Operation = DirectoryAttributeOperation.Replace; _changes[attrName] = dam; } } } else { logger.Debug("Preparing replacement operation on attr {0}", attrName); dam = new DirectoryAttributeModification(); dam.Name = attrName; dam.Operation = DirectoryAttributeOperation.Replace; _changes[attrName] = dam; } foreach (object o in values) { if (!dam.Contains(o)) { if (o is byte[]) { dam.Add((byte[])o); } else if (o is string) { dam.Add((string)o); } else if (o is Uri) { dam.Add((Uri)o); } else { throw new ArgumentException("No support for type " + o.GetType().FullName, "values"); } logger.Debug("Added value to collection {0} of {1}", attrName, o); } else { logger.Debug("Collection {0} already contains value {1}", attrName, o); } } }
public int IndexOf(DirectoryAttributeModification value) { return(List.IndexOf(value)); }
public void Insert(int index, DirectoryAttributeModification value) { List.Insert(index, value); }
public bool Contains(DirectoryAttributeModification value) { return(List.Contains(value)); }
public int Add(DirectoryAttributeModification attribute) { return(List.Add(attribute)); }
public static void Serialize(XmlDictionaryWriter writer, DirectoryAttributeModification attribute) { ChangeOperation changeOperation = ChangeOperation.None; DirectoryAttributeOperation operation = attribute.Operation; switch (operation) { case DirectoryAttributeOperation.Add: { changeOperation = ChangeOperation.Add; break; } case DirectoryAttributeOperation.Delete: { changeOperation = ChangeOperation.Delete; break; } case DirectoryAttributeOperation.Replace: { changeOperation = ChangeOperation.Replace; break; } } AttributeTypeAndValueSerializer.InternalSerialize(writer, changeOperation, AttributeNs.LookupNs(attribute.Name, SyntheticAttributeOperation.Write), attribute.Name, attribute); }
public void CopyTo (DirectoryAttributeModification [] array, int index) { List.CopyTo (array, index); }
public static void Serialize(XmlDictionaryWriter writer, ChangeOperation ChangeOperation, DirectoryAttributeModification attribute) { AttributeTypeAndValueSerializer.InternalSerialize(writer, ChangeOperation, AttributeNs.LookupNs(attribute.Name, SyntheticAttributeOperation.Write), attribute.Name, attribute); }
public int IndexOf (DirectoryAttributeModification value) { return List.IndexOf (value); }
public void AppendAttrValue(string attrName, string value) { CheckForDeletion(); string propName = attrName.ToLowerInvariant(); DirectoryAttributeModification dam; if (_changes.ContainsKey(propName)) { dam = _changes[propName]; if (this.ConflictMode == ConflictModes.Error && dam.Operation != DirectoryAttributeOperation.Add) { throw new IncompatibleMutationException( String.Format("Can't process a request to {0} and append on attr {1} - indeterminate results", dam.Operation, propName)); } else { logger.Info("Request on attr {0} is {1}, but appending value {2} anyway", propName, dam.Operation, value); if (dam.Contains("")) { logger.Info("Removing empty-replacement value on {0}", propName); dam.Remove(""); } if (!dam.Contains(value)) dam.Add(value); } } else { dam = new DirectoryAttributeModification(); dam.Name = propName; dam.Operation = DirectoryAttributeOperation.Add; dam.Add(value); _changes[propName] = dam; } }
public void Remove (DirectoryAttributeModification value) { List.Remove (value); }
/// <summary> /// Establecer una nueva password para un usuario /// </summary> /// <param name="UserLogin">Login del usuario</param> /// <param name="newPassword">Nueva contraseña</param> /// <returns></returns> public ResultCode SetPassword(string UserLogin, string newPassword) { if (!this.UserExist(UserLogin)) return ResultCode.NoSuchObject; this.OpenConnection(); DirectoryAttributeModification modOperation = new DirectoryAttributeModification(); modOperation.Name = "unicodePwd"; modOperation.Add(GetPasswordData(newPassword)); modOperation.Operation = DirectoryAttributeOperation.Replace; string userDN = string.Format("CN={0},{1}", UserLogin, this._usersDistinguishedName); ModifyRequest request = new ModifyRequest(userDN, modOperation); DirectoryResponse response = this._adamConnection.SendRequest(request); this.CloseConnection(); return response.ResultCode; }
/// <summary> /// Crear un nuevo usuario en el ADAM /// </summary> /// <param name="loginName">Nombre de Login</param> /// <param name="fullName">Nombre y Apellido del usuario</param> /// <param name="password">Contraseña</param> /// <returns></returns> public ResultCode CreateUser(string loginName, string fullName, string password) { if (this.UserExist(loginName)) return ResultCode.EntryAlreadyExists; this.OpenConnection(); string dirClasstype = "user"; string userDN = string.Format("CN={0},{1}", loginName, this._usersDistinguishedName); AddRequest addNewUserRequest = new AddRequest(userDN, dirClasstype); AddResponse response = (AddResponse)this._adamConnection.SendRequest(addNewUserRequest); if (response.ResultCode != ResultCode.Success) return response.ResultCode; DirectoryAttributeModification attFullName = new DirectoryAttributeModification(); attFullName.Name = "givenName"; attFullName.Operation = DirectoryAttributeOperation.Add; attFullName.Add(fullName); DirectoryAttributeModification attPassword = new DirectoryAttributeModification(); attPassword.Name = "unicodePwd"; attPassword.Add(GetPasswordData(password)); attPassword.Operation = DirectoryAttributeOperation.Add; DirectoryAttributeModification attDisableAccount = new DirectoryAttributeModification(); attDisableAccount.Name = "msDS-UserAccountDisabled"; attDisableAccount.Add("FALSE"); attDisableAccount.Operation = DirectoryAttributeOperation.Replace; ModifyRequest modRequest = new ModifyRequest(userDN, attFullName, attPassword, attDisableAccount); ModifyResponse modResponse = (ModifyResponse)this._adamConnection.SendRequest(modRequest); if (modResponse.ResultCode != ResultCode.Success) return modResponse.ResultCode; this.CloseConnection(); return modResponse.ResultCode; }
public static bool SetPassword(LdapConnection connection, string userDN, string newPassword, bool dryRun = false) { DirectoryAttributeModification addMod = new DirectoryAttributeModification(); addMod.Name = "unicodePwd"; addMod.Add(Encoding.Unicode.GetBytes("\"" + newPassword + "\"")); addMod.Operation = DirectoryAttributeOperation.Replace; ModifyRequest request = new ModifyRequest(userDN, addMod); try { if (!dryRun) { DirectoryResponse response = connection.SendRequest(request); return response.ResultCode == 0; } else { return true; } } catch (DirectoryOperationException ex) { if (ex.Response.ErrorMessage.StartsWith("0000052D")) { throw new Exception("Unable to update the password. The value provided for the new password does not meet the length, complexity, or history requirements of the domain."); } else { throw; } } }
/// <summary> /// Replace all values of 'attrName' with the empty string. /// </summary> /// <param name="propName">The name of the property / attribute to clear</param> public void ClearAttr(string attrName) { CheckForDeletion(); attrName = attrName.ToLowerInvariant(); if (this.GetAttrValueCount(attrName) > 0) { DirectoryAttributeModification dam; if (_changes.ContainsKey(attrName)) { dam = _changes[attrName]; if (dam.Operation == DirectoryAttributeOperation.Replace) { if (dam.Count == 0) { logger.Debug("Already contains request to set {0} with Replace/Clear", attrName); return; } } if (this.ConflictMode == ConflictModes.Error) { throw new IncompatibleMutationException(String.Format( "Change buffer already contains a non-blank request to modify attr {0} as {1}", attrName, dam.Operation)); } else { logger.Info("Overriding non-blank {0} request on attr {1} with Replace/Clear", dam.Operation, attrName); dam = new DirectoryAttributeModification() { Name = attrName, Operation = DirectoryAttributeOperation.Replace }; dam.Clear(); _changes[attrName] = dam; /* dam = new DirectoryAttributeModification() { Name = propName, Operation = DirectoryAttributeOperation.Delete }; _changes[propName] = dam; */ if (_changes.ContainsKey(attrName + "*d")) { logger.Warn("Removing useless single-value deletion on attr {0}", attrName); _changes.Remove(attrName + "*d"); } } } else { dam = new DirectoryAttributeModification() { Name = attrName, Operation = DirectoryAttributeOperation.Replace }; dam.Clear(); _changes[attrName] = dam; logger.Debug("Set Replace/Clear on attr {0}", attrName); if (_changes.ContainsKey(attrName + "*d")) { logger.Warn("Removing useless single-value deletion on attr {0}"); _changes.Remove(attrName + "*d"); } } } }
public void SetPassword(string uname, string value) { string userDN = this.GetUserDN(uname); DirectoryAttributeModification mod = new DirectoryAttributeModification { Name = Settings.Store.LDAPPasswordAttribute, Operation = DirectoryAttributeOperation.Replace }; mod.Add(value); ModifyRequest req = new ModifyRequest(userDN); req.Modifications.Add(mod); m_conn.SendRequest(req); }