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 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
});
}
}
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 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);
}
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);
}
}
}