public override bool IsEqual(object instance, object value, out DirectoryAttributeModification modification)
{
var propertyValue = GetValue(instance) as ICollection <byte[]>;
var bytes = value as ICollection <byte[]>;
if ((propertyValue == null || propertyValue.Count == 0) && (bytes == null || bytes.Count == 0))
{
modification = null;
return(true);
}
if (propertyValue == null || bytes == null || bytes.Count != propertyValue.Count)
{
modification = GetDirectoryAttributeModification(instance);
return(false);
}
var propertyEnum = propertyValue.GetEnumerator();
var bytesEnum = bytes.GetEnumerator();
while (propertyEnum.MoveNext() && bytesEnum.MoveNext())
{
if (propertyEnum.Current.SequenceEqual(bytesEnum.Current))
{
continue;
}
modification = GetDirectoryAttributeModification(instance);
return(false);
}
modification = null;
return(true);
}
public override bool IsEqual(object instance, object value, out DirectoryAttributeModification modification)
{
var propertyValue = GetValue(instance) as string[];
var strings = value as string[];
if ((propertyValue == null || propertyValue.Length == 0) && (strings == null || strings.Length == 0))
{
modification = null;
return(true);
}
if (propertyValue == null || strings == null || strings.Length != propertyValue.Length)
{
modification = GetDirectoryAttributeModification(instance);
return(false);
}
if (!strings.SequenceEqual(propertyValue))
{
modification = GetDirectoryAttributeModification(instance);
return(false);
}
modification = null;
return(true);
}
protected void SetAttribute(DirectoryAttributeModificationCollection modifications, string name, string property, string value)
{
if (!Changes.ContainsKey(property))
{
return;
}
DirectoryAttributeModification m = new DirectoryAttributeModification();
m.Add(value);
m.Name = name;
switch (Changes[property])
{
case ChangeType.Add:
m.Operation = DirectoryAttributeOperation.Add;
break;
case ChangeType.Remove:
m.Operation = DirectoryAttributeOperation.Delete;
break;
case ChangeType.Modify:
m.Operation = DirectoryAttributeOperation.Replace;
break;
}
modifications.Add(m);
}
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 static void AddModificationIfDataChanged <T>(
this ICollection <DirectoryAttributeModification> modifications,
string attributeName,
T updatedEntity,
T oldEntity,
Func <T, string> getValueFunc = null)
where T : class
{
var updatedValue = GetValueAsNullIfEmpty(updatedEntity, getValueFunc);
var oldValue = GetValueAsNullIfEmpty(oldEntity, getValueFunc);
if (updatedValue == oldValue)
{
return;
}
var hasOldValue = !string.IsNullOrEmpty(oldValue);
var hasUpdatedValue = !string.IsNullOrEmpty(updatedValue);
var modification = new DirectoryAttributeModification {
Name = attributeName
};
if (hasUpdatedValue)
{
modification.Operation = DirectoryAttributeOperation.Replace;
modification.Add(updatedValue);
}
else if (hasOldValue)
{
modification.Operation = DirectoryAttributeOperation.Delete;
}
modifications.Add(modification);
}
internal DirectoryResponse SetBacklinkAttribute(string linkedDN, string backLinkDN, string attributeName)
{
var linked = GetObjectByDn(linkedDN, attributeName);
IEnumerable <string> values = new List <string>();
if (linked.Properties.TryGetValue(attributeName, out var _values))
{
values = _values as IEnumerable <string>;
}
if (!values.Contains(backLinkDN))
{
var modifyMemebrOfRequest = new ModifyRequest();
modifyMemebrOfRequest.DistinguishedName = linkedDN;
var memberMod = new DirectoryAttributeModification();
memberMod.Name = attributeName;
memberMod.Operation = DirectoryAttributeOperation.Add;
memberMod.Add(backLinkDN);
modifyMemebrOfRequest.Modifications.Add(memberMod);
return(Connect().SendRequest(modifyMemebrOfRequest));
}
return(null);
}
public void UpdateListAttribute(string key, string attributeName, string value, DirectoryAttributeOperation operation)
{
using (LdapConnection conn = GetConnection())
{
SearchResultEntry entry = Load(key, conn);
if (entry == null)
{
return;
}
DirectoryAttributeModification mod = new DirectoryAttributeModification();
mod.Name = attributeName;
mod.Operation = DirectoryAttributeOperation.Replace;
mod.AddRange(entry.Attributes[attributeName].GetValues(typeof(string)));
if (operation == DirectoryAttributeOperation.Add)
{
mod.Add(value);
}
else
{
for (int i = 0; i < mod.Count; i++)
{
if (mod[i].ToString().Equals(value, StringComparison.InvariantCultureIgnoreCase))
{
mod.RemoveAt(i);
break;
}
}
}
ModifyRequest mr = new ModifyRequest(key, mod);
conn.SendRequest(mr);
}
}
public override bool IsEqual(object instance, object value, out DirectoryAttributeModification modification)
{
var propertyValue = GetValue(instance) as ICollection <SecurityIdentifier>;
var identifiers = value as ICollection <SecurityIdentifier>;
if ((propertyValue == null || propertyValue.Count == 0) && (identifiers == null || identifiers.Count == 0))
{
modification = null;
return(true);
}
if (propertyValue == null || identifiers == null || identifiers.Count != propertyValue.Count)
{
modification = GetDirectoryAttributeModification(instance);
return(false);
}
if (!identifiers.SequenceEqual(propertyValue))
{
modification = GetDirectoryAttributeModification(instance);
return(false);
}
modification = null;
return(true);
}
public void ChangePassword(
string userDN,
string oldPassword,
string newPassword
)
{
DirectoryAttributeModification deleteMod =
new DirectoryAttributeModification();
deleteMod.Name = "unicodePwd";
deleteMod.Add(GetPasswordData(oldPassword));
deleteMod.Operation = DirectoryAttributeOperation.Delete;
DirectoryAttributeModification addMod =
new DirectoryAttributeModification();
addMod.Name = "unicodePwd";
addMod.Add(GetPasswordData(newPassword));
addMod.Operation = DirectoryAttributeOperation.Add;
ModifyRequest request = new ModifyRequest(
userDN,
deleteMod,
addMod
);
DirectoryResponse response = _connection.SendRequest(request);
}
public virtual void SetAttributeValues(Guid objectGuid, IEnumerable <KeyValuePair <string, List <byte[]> > > attributes)
{
if (this.connection == null)
{
throw new InvalidOperationException("AD connection has not been initialized");
}
ModifyRequest modifyRequest = new ModifyRequest();
modifyRequest.DistinguishedName = EhfADAdapter.CreateDNForObjectGuid(objectGuid);
foreach (KeyValuePair <string, List <byte[]> > keyValuePair in attributes)
{
DirectoryAttributeModification directoryAttributeModification = new DirectoryAttributeModification();
directoryAttributeModification.Operation = DirectoryAttributeOperation.Replace;
directoryAttributeModification.Name = keyValuePair.Key;
if (keyValuePair.Value != null && keyValuePair.Value.Count > 0)
{
foreach (byte[] value in keyValuePair.Value)
{
directoryAttributeModification.Add(value);
}
}
modifyRequest.Modifications.Add(directoryAttributeModification);
}
this.connection.SendRequest(modifyRequest);
}
public virtual void SetAttributeValues(Guid objectGuid, IEnumerable <KeyValuePair <string, object> > attributes)
{
if (this.connection == null)
{
throw new InvalidOperationException("AD connection has not been initialized");
}
ModifyRequest modifyRequest = new ModifyRequest();
modifyRequest.DistinguishedName = EhfADAdapter.CreateDNForObjectGuid(objectGuid);
foreach (KeyValuePair <string, object> keyValuePair in attributes)
{
DirectoryAttributeModification directoryAttributeModification = new DirectoryAttributeModification();
directoryAttributeModification.Operation = DirectoryAttributeOperation.Replace;
directoryAttributeModification.Name = keyValuePair.Key;
if (keyValuePair.Value != null)
{
string text = keyValuePair.Value as string;
if (text != null)
{
directoryAttributeModification.Add(text);
}
else
{
byte[] array = keyValuePair.Value as byte[];
if (array == null)
{
throw new ArgumentException("Value of the attribute should be of type String or Byte[]", "attributesAndValues");
}
directoryAttributeModification.Add(array);
}
}
modifyRequest.Modifications.Add(directoryAttributeModification);
}
this.connection.SendRequest(modifyRequest);
}
private ModifyRequest AddAttributeModifications(ExSearchResultEntry entry, SortedList <string, DirectoryAttribute> attributes, ModifyRequest modificationRequest)
{
DirectoryAttributeModification directoryAttributeModification = null;
foreach (KeyValuePair <string, DirectoryAttribute> keyValuePair in attributes)
{
directoryAttributeModification = new DirectoryAttributeModification();
directoryAttributeModification.Name = keyValuePair.Key;
directoryAttributeModification.Operation = DirectoryAttributeOperation.Replace;
foreach (object obj in keyValuePair.Value)
{
if (obj is byte[])
{
directoryAttributeModification.Add((byte[])obj);
}
else
{
directoryAttributeModification.Add((string)obj);
}
if (ExTraceGlobals.SynchronizationJobTracer.IsTraceEnabled(TraceType.DebugTrace))
{
this.TraceAttributeValue(keyValuePair.Value);
}
}
modificationRequest.Modifications.Add(directoryAttributeModification);
}
directoryAttributeModification = new DirectoryAttributeModification();
directoryAttributeModification.Name = "msExchEdgeSyncSourceGuid";
directoryAttributeModification.Operation = DirectoryAttributeOperation.Replace;
directoryAttributeModification.Add((byte[])entry.Attributes["objectGUID"][0]);
modificationRequest.Modifications.Add(directoryAttributeModification);
return(modificationRequest);
}
private void SetPassword(string username, string newPassword)
{
var distinguishedName = string.Format(@"CN={0},{1}", username, _config.DistinguishedName);
Logger.Info("Setting password for user: \"{0}\"", username);
Logger.Info("Distinguished name: \"{0}\"", distinguishedName);
// the 'unicodePWD' attribute is used to handle pwd handling requests
const string attribute = "unicodePwd";
if (!String.IsNullOrEmpty(newPassword))
{
// do we have a pwd to set -> set pwd
var directoryAttributeModificationReplace = new DirectoryAttributeModification
{
Name = attribute,
Operation = DirectoryAttributeOperation.Replace
};
directoryAttributeModificationReplace.Add(BuildBytePwd(newPassword));
var damList = new[] { directoryAttributeModificationReplace };
var modifyRequest = new ModifyRequest(distinguishedName, damList);
// Should we utilize pwd history on the pwd reset?
var value = BerConverter.Encode("{i}", new object[] { 0x1 });
var pwdHistory = new DirectoryControl(LdapServerPolicyHintsOid, value, false, true);
modifyRequest.Controls.Add(pwdHistory);
var response = _connection.SendRequest(modifyRequest);
// TODO: handle bad response.
}
}
public override bool IsEqual(object instance, object value, out DirectoryAttributeModification modification)
{
var propertyValue = GetValue(instance) as byte[][];
var bytes = value as byte[][];
if ((propertyValue == null || propertyValue.Length == 0) && (bytes == null || bytes.Length == 0))
{
modification = null;
return(true);
}
if (propertyValue == null || bytes == null || bytes.Length != propertyValue.Length)
{
modification = GetDirectoryAttributeModification(instance);
return(false);
}
if (bytes.Where((t, i) => !propertyValue[i].SequenceEqual(t)).Any())
{
modification = GetDirectoryAttributeModification(instance);
return(false);
}
modification = null;
return(true);
}
private void UpdateValueCollectionChanges(string attrName, ADPropertyValueCollection valueCollection, DirectoryAttributeModificationCollection mods)
{
DirectoryAttributeModification directoryAttributeModification;
if (valueCollection != null)
{
if (!valueCollection.TrackChanges)
{
directoryAttributeModification = this.CreateDirAttrModification(attrName, valueCollection, null);
mods.Add(directoryAttributeModification);
}
else
{
if (!valueCollection.IsValuesCleared)
{
if (valueCollection.ReplacedValues.Count <= 0)
{
if (valueCollection.DeletedValues.Count > 0)
{
directoryAttributeModification = this.CreateDirAttrModification(attrName, valueCollection.DeletedValues, null);
directoryAttributeModification.Operation = DirectoryAttributeOperation.Delete;
mods.Add(directoryAttributeModification);
}
if (valueCollection.AddedValues.Count > 0)
{
directoryAttributeModification = new DirectoryAttributeModification();
directoryAttributeModification.Operation = DirectoryAttributeOperation.Add;
this.CreateDirAttrModification(attrName, valueCollection.AddedValues, directoryAttributeModification);
mods.Add(directoryAttributeModification);
return;
}
}
else
{
directoryAttributeModification = this.CreateDirAttrModification(attrName, valueCollection.ReplacedValues, null);
mods.Add(directoryAttributeModification);
return;
}
}
else
{
directoryAttributeModification = new DirectoryAttributeModification();
directoryAttributeModification.Name = attrName;
directoryAttributeModification.Operation = DirectoryAttributeOperation.Delete;
mods.Add(directoryAttributeModification);
return;
}
}
return;
}
else
{
directoryAttributeModification = new DirectoryAttributeModification();
directoryAttributeModification.Name = attrName;
directoryAttributeModification.Operation = DirectoryAttributeOperation.Delete;
mods.Add(directoryAttributeModification);
return;
}
}
public void Operation_SetValid_GetReturnsExpected()
{
var modification = new DirectoryAttributeModification {
Operation = DirectoryAttributeOperation.Delete
};
Assert.Equal(DirectoryAttributeOperation.Delete, modification.Operation);
}
public void AddRange_NullObjectInValues_ThrowsArgumentException()
{
DirectoryAttributeModification[] attributes = new DirectoryAttributeModification[] { new DirectoryAttributeModification(), null, new DirectoryAttributeModification() };
var collection = new DirectoryAttributeModificationCollection();
AssertExtensions.Throws <ArgumentException>(null, () => collection.AddRange(attributes));
Assert.Equal(0, collection.Count);
}
public void Ctor_Default()
{
var modification = new DirectoryAttributeModification();
Assert.Empty(modification.Name);
Assert.Empty(modification);
Assert.Equal(DirectoryAttributeOperation.Replace, modification.Operation);
}
/// <summary>
/// Sets the value of the attribute.
/// </summary>
/// <param name="attribute">The name of the attribute.</param>
/// <param name="value">The value.</param>
public IDirectoryAttributes Set(string attribute, bool value)
{
var modification = new DirectoryAttributeModification {
Name = attribute, Operation = DirectoryAttributeOperation.Replace
};
modification.Add(value ? "TRUE" : "FALSE");
return(AddModification(modification));
}
private void AddValue(DirectoryAttributeModification mod, Guid v)
{
if (this.IsString)
{
mod.Add(v.ToString());
return;
}
mod.Add(v.ToByteArray());
}
/// <summary>
/// Sets the value of the attribute.
/// </summary>
/// <param name="attribute">The name of the attribute.</param>
/// <param name="value">The value.</param>
/// <param name="format">The format of the <paramref name="value"/>.</param>
public IDirectoryAttributes Set(string attribute, DateTime value, string format = ExtensionMethods.LdapFormat)
{
var modification = new DirectoryAttributeModification {
Name = attribute, Operation = DirectoryAttributeOperation.Replace
};
modification.Add(format == null ? value.ToFileTime().ToString() : value.FormatLdapDateTime(format));
return(AddModification(modification));
}
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 AddRange_ValidAttributes_AddsToCollection()
{
DirectoryAttributeModification[] attributes = new DirectoryAttributeModification[] { new DirectoryAttributeModification(), new DirectoryAttributeModification() };
var collection = new DirectoryAttributeModificationCollection();
collection.AddRange(attributes);
Assert.Equal(attributes, collection.Cast <DirectoryAttributeModification>());
}
public virtual bool IsEqual(object instance, object value, out DirectoryAttributeModification modification)
{
if (!Equals(GetValue(instance), value))
{
modification = GetDirectoryAttributeModification(instance);
return(false);
}
modification = null;
return(true);
}
public void Indexer_Set_GetReturnsExpected()
{
var attribute = new DirectoryAttributeModification {
"value"
};
var collection = new DirectoryAttributeModificationCollection {
new DirectoryAttributeModification()
};
collection[0] = attribute;
Assert.Equal(attribute, collection[0]);
}
public void Remove_Valid_Success()
{
var attribute = new DirectoryAttributeModification {
"value"
};
var collection = new DirectoryAttributeModificationCollection {
attribute
};
collection.Remove(attribute);
Assert.Empty(collection);
}
public override bool IsEqual(object instance, object value, out DirectoryAttributeModification modification)
{
if (_isNullable)
{
var propertyValue = GetValue(instance) as DateTime?[];
var dates = value as DateTime?[];
if ((propertyValue == null || propertyValue.Length == 0) && (dates == null || dates.Length == 0))
{
modification = null;
return(true);
}
if (propertyValue == null || dates == null || dates.Length != propertyValue.Length)
{
modification = GetDirectoryAttributeModification(instance);
return(false);
}
if (!dates.SequenceEqual(propertyValue))
{
modification = GetDirectoryAttributeModification(instance);
return(false);
}
modification = null;
return(true);
}
else
{
var propertyValue = GetValue(instance) as DateTime[];
var dates = value as DateTime[];
if ((propertyValue == null || propertyValue.Length == 0) && (dates == null || dates.Length == 0))
{
modification = null;
return(true);
}
if (propertyValue == null || dates == null || dates.Length != propertyValue.Length)
{
modification = GetDirectoryAttributeModification(instance);
return(false);
}
if (!dates.SequenceEqual(propertyValue))
{
modification = GetDirectoryAttributeModification(instance);
return(false);
}
modification = null;
return(true);
}
}
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 IndexOf_Valid_ReturnsExpected()
{
var attribute = new DirectoryAttributeModification {
"value"
};
var collection = new DirectoryAttributeModificationCollection {
attribute
};
Assert.Equal(0, collection.IndexOf(attribute));
Assert.Equal(-1, collection.IndexOf(new DirectoryAttributeModification()));
Assert.Equal(-1, collection.IndexOf(null));
}
public void Contains_Valid_ReturnsExpected()
{
var attribute = new DirectoryAttributeModification {
"value"
};
var collection = new DirectoryAttributeModificationCollection {
attribute
};
Assert.True(collection.Contains(attribute));
Assert.False(collection.Contains(new DirectoryAttributeModification()));
Assert.False(collection.Contains(null));
}
public int IndexOf(DirectoryAttributeModification value) {}
public bool Contains(DirectoryAttributeModification value) {}
public void CopyTo(DirectoryAttributeModification[] array, int index) {}
public ModifyRequest(string distinguishedName, DirectoryAttributeModification[] modifications) {}
public void Insert(int index, DirectoryAttributeModification value) {}
public void Remove(DirectoryAttributeModification value) {}
public void AddRange(DirectoryAttributeModification[] attributes) {}
// Methods
public int Add(DirectoryAttributeModification attribute) {}
