protected override void InternalValidate()
{
TaskLogger.LogEnter();
base.InternalValidate();
this.CheckForDuplicateExistingDomain();
AcceptedDomain acceptedDomain = new AcceptedDomain();
acceptedDomain.Name = this.Name;
acceptedDomain.DomainName = new SmtpDomainWithSubdomains(this.DomainName, false);
acceptedDomain.DomainType = this.DomainType;
acceptedDomain.SetId(base.Session, this.DomainName.ToString());
acceptedDomain.OrganizationId = base.CurrentOrganizationId;
NewAcceptedDomain.ValidateDomainName(acceptedDomain, new Task.TaskErrorLoggingDelegate(this.WriteWrappedError));
if (!this.DomainOwnershipVerified && this.AuthenticationType == AuthenticationType.Federated)
{
bool flag = false;
AcceptedDomainIdParameter acceptedDomainIdParameter = AcceptedDomainIdParameter.Parse("*");
IEnumerable <AcceptedDomain> objects = acceptedDomainIdParameter.GetObjects <AcceptedDomain>(this.TenantCU.Id, base.Session);
foreach (AcceptedDomain acceptedDomain2 in objects)
{
SmtpDomainWithSubdomains smtpDomainWithSubdomains = new SmtpDomainWithSubdomains(acceptedDomain2.DomainName.Domain.ToString(), true);
if (smtpDomainWithSubdomains.Match(this.DomainName.ToString()) == acceptedDomain2.DomainName.Domain.Length)
{
flag = true;
break;
}
}
if (!flag)
{
base.WriteError(new OrganizationTaskException(Strings.ErrorTenantAdminsCanOnlyAddSubdomains(this.DomainName.ToString())), ErrorCategory.InvalidOperation, null);
}
}
TaskLogger.LogExit();
}
private void CheckForDuplicateExistingDomain()
{
AcceptedDomain acceptedDomain = OrganizationTaskHelper.GetAcceptedDomain(AcceptedDomainIdParameter.Parse(this.Name), base.Session, new Task.TaskErrorLoggingDelegate(base.WriteError), false);
if (acceptedDomain != null)
{
base.WriteError(new ManagementObjectAlreadyExistsException(Strings.ErrorAcceptedDomainExists(this.Name)), ErrorCategory.ResourceExists, null);
}
}
private void CalculateProperties()
{
AcceptedDomainIdParameter defaultDomain = this.DefaultDomain;
if (defaultDomain != null)
{
AcceptedDomain acceptedDomain = (AcceptedDomain)base.GetDataObject <AcceptedDomain>(defaultDomain, base.DataSession, this.RootId, new LocalizedString?(Strings.ErrorDefaultDomainNotFound(defaultDomain)), new LocalizedString?(Strings.ErrorDefaultDomainNotUnique(defaultDomain)));
this.DataObject.DefaultDomain = acceptedDomain.Id;
}
}
private void GetDomains(string target, List <MailFilterListReport> values)
{
AcceptedDomainIdParameter acceptedDomainIdParameter = AcceptedDomainIdParameter.Parse("*");
foreach (AcceptedDomain acceptedDomain in acceptedDomainIdParameter.GetObjects <AcceptedDomain>(null, base.ConfigSession))
{
values.Add(new MailFilterListReport
{
Organization = base.Organization.ToString(),
SelectionTarget = target,
Display = acceptedDomain.Name,
Value = acceptedDomain.Name
});
}
}
private void CleanupSecondaryDomain()
{
AcceptedDomain acceptedDomain = OrganizationTaskHelper.GetAcceptedDomain(AcceptedDomainIdParameter.Parse(this.Name), base.Session, new Task.TaskErrorLoggingDelegate(base.WriteError), false);
if (acceptedDomain != null)
{
try
{
base.Session.Delete(acceptedDomain);
}
catch (Exception ex)
{
this.WriteWarning(Strings.ErrorNonActiveOrganizationFound(ex.ToString()));
}
}
}
internal void ValidateEmailAddress(PropertyInfo property, object task, IConfigDataProvider configSession, CmdletValidator.EmailAddress addressType, CmdletValidator.WildcardValidationOptions wildcardOptions, CmdletValidator.EmailAcceptedDomainOptions domainOptions = CmdletValidator.EmailAcceptedDomainOptions.SkipVerify)
{
IList <string> list;
if (this.TryGetValues <string>(property, task, out list))
{
LocalizedString message = (addressType == CmdletValidator.EmailAddress.Sender) ? Strings.InvalidSenderAddress : Strings.InvalidRecipientAddress;
IEnumerable <string> source = new string[0];
if (domainOptions == CmdletValidator.EmailAcceptedDomainOptions.Verify)
{
AcceptedDomainIdParameter acceptedDomainIdParameter = AcceptedDomainIdParameter.Parse("*");
source = from domain in acceptedDomainIdParameter.GetObjects <AcceptedDomain>(null, configSession)
select domain.DomainName.Domain.ToLower();
}
foreach (string address in list)
{
bool flag2;
bool flag = Schema.Utilities.ValidateEmailAddress(address, out flag2);
if (flag && flag2)
{
flag &= (wildcardOptions == CmdletValidator.WildcardValidationOptions.Allow);
if (flag && list.Count > 1)
{
message = ((addressType == CmdletValidator.EmailAddress.Sender) ? Strings.CannotCombineWildcardSenderAddress : Strings.CannotCombineWildcardRecipientAddress);
flag = false;
}
}
if (flag && domainOptions == CmdletValidator.EmailAcceptedDomainOptions.Verify)
{
SmtpAddress smtpAddress = new SmtpAddress(address);
if (!source.Contains(smtpAddress.Domain, StringComparer.InvariantCultureIgnoreCase))
{
flag = false;
message = Strings.EmailAddressNotInAcceptedDomain(address);
}
}
if (!flag)
{
if (this.errorMessageId == null)
{
throw new InvalidExpressionException(message);
}
this.ThrowError(property);
}
}
}
}
internal void ValidateDomain(PropertyInfo property, object task, IConfigDataProvider configSession)
{
IList <Fqdn> list;
if (this.TryGetValues <Fqdn>(property, task, out list) && list.Count > 0)
{
if (configSession == null)
{
throw new NullReferenceException("ValidateDomain requires an IConfigDataProvider");
}
AcceptedDomainIdParameter acceptedDomainIdParameter = AcceptedDomainIdParameter.Parse("*");
HashSet <string> acceptedDomains = new HashSet <string>(from domain in acceptedDomainIdParameter.GetObjects <AcceptedDomain>(null, configSession)
select domain.DomainName.Domain.ToLower());
if (!list.All((Fqdn domain) => acceptedDomains.Contains(domain.Domain.ToLower())))
{
this.ThrowError(property);
}
}
}
internal static void ValidateAssociatedAcceptedDomains(MultiValuedProperty <AcceptedDomainIdParameter> domainIdParameters, IConfigDataProvider dataSession, TenantInboundConnector dataObject, ObjectId rootId, Task task, Func <IIdentityParameter, IConfigDataProvider, ObjectId, LocalizedString?, LocalizedString?, IConfigurable> acceptedDomainsGetter)
{
if (domainIdParameters != null)
{
NewInboundConnector.ValidateCentralizedMailControlAndAssociatedAcceptedDomainsRestriction(dataSession, dataObject, task);
dataObject.AssociatedAcceptedDomains.Clear();
using (MultiValuedProperty <AcceptedDomainIdParameter> .Enumerator enumerator = domainIdParameters.GetEnumerator())
{
while (enumerator.MoveNext())
{
AcceptedDomainIdParameter acceptedDomainIdParameter = enumerator.Current;
AcceptedDomain acceptedDomain = (AcceptedDomain)acceptedDomainsGetter(acceptedDomainIdParameter, dataSession, rootId, new LocalizedString?(Strings.ErrorDefaultDomainNotFound(acceptedDomainIdParameter)), new LocalizedString?(Strings.ErrorDefaultDomainNotUnique(acceptedDomainIdParameter)));
dataObject.AssociatedAcceptedDomains.Add(acceptedDomain.Id);
}
return;
}
}
dataObject.AssociatedAcceptedDomains.Clear();
}
protected override void InternalValidate()
{
base.InternalValidate();
if (base.HasErrors)
{
return;
}
string message;
if (!NewReceiveConnector.ValidataName(this.DataObject.Name, out message))
{
base.WriteError(new ArgumentException(message), ErrorCategory.InvalidArgument, null);
}
if (base.Fields.IsModified("DefaultDomain"))
{
AcceptedDomainIdParameter defaultDomain = this.DefaultDomain;
if (defaultDomain != null)
{
AcceptedDomain acceptedDomain = (AcceptedDomain)base.GetDataObject <AcceptedDomain>(defaultDomain, base.DataSession, this.RootId, new LocalizedString?(Strings.ErrorDefaultDomainNotFound(defaultDomain)), new LocalizedString?(Strings.ErrorDefaultDomainNotUnique(defaultDomain)));
this.DataObject.DefaultDomain = acceptedDomain.Id;
}
else
{
this.DataObject.DefaultDomain = null;
}
}
LocalizedException exception;
if (!ReceiveConnectorNoMappingConflictCondition.Verify(this.DataObject, base.DataSession as IConfigurationSession, out exception))
{
base.WriteError(exception, ErrorCategory.InvalidOperation, this.DataObject);
}
if (!this.serverObject.IsEdgeServer && (this.DataObject.AuthMechanism & AuthMechanisms.ExchangeServer) != AuthMechanisms.None && !ReceiveConnectorFqdnCondition.Verify(this.DataObject, this.serverObject, out exception))
{
base.WriteError(exception, ErrorCategory.InvalidOperation, this.DataObject);
}
if (this.DataObject.AdvertiseClientSettings && (this.DataObject.PermissionGroups & PermissionGroups.ExchangeUsers) != PermissionGroups.ExchangeUsers)
{
base.WriteError(new AdvertiseClientSettingsWithoutExchangeUsersPermissionGroupsException(), ErrorCategory.InvalidOperation, this.DataObject);
}
}
internal static AcceptedDomain GetAcceptedDomain(AcceptedDomainIdParameter acceptedDomainId, IConfigurationSession adSession, Task.TaskErrorLoggingDelegate errorLogger, bool reportError)
{
AcceptedDomain result = null;
IEnumerable <AcceptedDomain> objects = acceptedDomainId.GetObjects <AcceptedDomain>(null, adSession);
using (IEnumerator <AcceptedDomain> enumerator = objects.GetEnumerator())
{
if (enumerator.MoveNext())
{
result = enumerator.Current;
if (reportError && enumerator.MoveNext())
{
errorLogger(new ManagementObjectAmbiguousException(Strings.ErrorSecondaryDomainNotUnique(acceptedDomainId.ToString())), ErrorCategory.InvalidArgument, null);
}
}
else if (reportError)
{
errorLogger(new ManagementObjectNotFoundException(Strings.ErrorSecondaryDomainNotFound(acceptedDomainId.ToString())), ErrorCategory.InvalidArgument, null);
}
}
return(result);
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
if (this.TenantCU.OrganizationStatus == OrganizationStatus.PendingAcceptedDomainAddition || this.TenantCU.OrganizationStatus == OrganizationStatus.PendingAcceptedDomainRemoval)
{
OrganizationTaskHelper.SetOrganizationStatus(base.Session, this.TenantCU, OrganizationStatus.Active);
}
try
{
base.InternalProcessRecord();
}
catch (Exception)
{
this.CleanupSecondaryDomain();
throw;
}
if (!base.HasErrors)
{
AcceptedDomain acceptedDomain = OrganizationTaskHelper.GetAcceptedDomain(AcceptedDomainIdParameter.Parse(this.Name), base.Session, new Task.TaskErrorLoggingDelegate(base.WriteError), true);
base.WriteObject(acceptedDomain);
}
else
{
this.CleanupSecondaryDomain();
}
TaskLogger.LogExit();
}
