internal static bool IsKB922817InstalledOnServer(string computerName, Task.TaskErrorLoggingDelegate errorHandler)
{
Exception ex = null;
bool result = false;
try
{
using (RegistryKey registryKey = RegistryUtil.OpenRemoteBaseKey(RegistryHive.LocalMachine, computerName))
{
using (RegistryKey registryKey2 = registryKey.OpenSubKey("Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\KB922817"))
{
result = (registryKey2 != null);
}
}
}
catch (SecurityException ex2)
{
ex = ex2;
}
catch (IOException ex3)
{
ex = ex3;
}
catch (UnauthorizedAccessException ex4)
{
ex = ex4;
}
if (ex != null)
{
errorHandler(new InvalidOperationException(Strings.ErrorAccessingRegistryRaisesException(computerName, ex.Message)), ErrorCategory.ReadError, null);
}
return(result);
}
internal static void UpdateServerLegdnForDatabaseSite(Task.TaskErrorLoggingDelegate writeErrorDelegate, Task.TaskVerboseLoggingDelegate writeVerboseDelegate, ITopologyConfigurationSession adSession, DatabaseCopy dbCopy)
{
ADObjectId hostServer = dbCopy.HostServer;
PropertyDefinition[] properties = new PropertyDefinition[]
{
ServerSchema.ServerSite
};
MiniServer miniServer = adSession.ReadMiniServer(hostServer, properties);
if (miniServer == null)
{
writeErrorDelegate(new ADServerNotFoundException(hostServer.ToString()), ErrorCategory.InvalidArgument, null);
}
IADToplogyConfigurationSession adSession2 = ADSessionFactory.CreateWrapper(adSession);
SimpleAdObjectLookup <IADClientAccessArray> findClientAccessArray = new SimpleAdObjectLookup <IADClientAccessArray>(adSession2);
SimpleMiniClientAccessServerOrArrayLookup findMiniClientAccessServer = new SimpleMiniClientAccessServerOrArrayLookup(adSession);
ADObjectId serverSite = miniServer.ServerSite;
LegacyDN legacyDN = ActiveManagerImplementation.FindClientAccessArrayOrServerFromSite(serverSite, miniServer.Id, findClientAccessArray, findMiniClientAccessServer, AdObjectLookupFlags.ReadThrough);
ADObjectId parent = dbCopy.Id.Parent;
Database database = adSession.Read <Database>(parent);
if (legacyDN != null)
{
LegacyDN databaseLegacyDNFromRcaLegacyDN = Database.GetDatabaseLegacyDNFromRcaLegacyDN(legacyDN, database.IsPublicFolderDatabase);
database.ExchangeLegacyDN = databaseLegacyDNFromRcaLegacyDN.ToString();
writeVerboseDelegate(Strings.UpdatingLegDnForDatabaseToServer(database.Name, legacyDN.ToString(), legacyDN.ToString()));
adSession.Save(database);
return;
}
ExTraceGlobals.CmdletsTracer.TraceDebug <ADObjectId>(0L, "Could not find a new CAS machines for site '{0}'. Leaving the database's legdn unchanged.", serverSite);
}
public static void ValidateStartAfterTime(DateTime startAfterUtc, Task.TaskErrorLoggingDelegate writeError, DateTime utcNow)
{
if (utcNow.AddDays(30.0) < startAfterUtc)
{
writeError(new MoveStartAfterDateRangeException(30), ErrorCategory.InvalidArgument, startAfterUtc);
}
}
internal void Validate(Task.TaskErrorLoggingDelegate writeError)
{
if ((this.Cmdlets == null || this.Cmdlets.Count == 0) && this.Parameters != null && this.Parameters.Count != 0)
{
writeError(new ArgumentException(Strings.AdminAuditLogSearchMissingCmdletsWhileParameterProvided), ErrorCategory.InvalidArgument, null);
}
}
internal static void ValidateUserName(string userName, Task.TaskErrorLoggingDelegate taskErrorLoggingDelegate)
{
if (string.IsNullOrEmpty(userName))
{
taskErrorLoggingDelegate(new InvalidOperationException(Strings.IncomingUserNameEmpty), ErrorCategory.InvalidData, null);
}
}
public static void FixAuthMetadataUrl(AuthServer authServer, Task.TaskErrorLoggingDelegate writeError)
{
if (authServer.Type == AuthServerType.ADFS)
{
Uri uri = null;
string authMetadataUrl = authServer.AuthMetadataUrl;
try
{
uri = new Uri(authServer.AuthMetadataUrl);
}
catch (ArgumentNullException)
{
writeError(new TaskException(Strings.ErrorInvalidMetadataUrl(authMetadataUrl)), ErrorCategory.InvalidArgument, null);
}
catch (UriFormatException)
{
writeError(new TaskException(Strings.ErrorInvalidMetadataUrl(authMetadataUrl)), ErrorCategory.InvalidArgument, null);
}
if ((uri.Scheme == Uri.UriSchemeHttps || uri.Scheme == Uri.UriSchemeHttp) && uri.AbsolutePath == "/")
{
authServer.AuthMetadataUrl = new UriBuilder(uri)
{
Path = "federationmetadata/2007-06/federationmetadata.xml"
}.ToString();
}
}
}
public static void CheckReplayServiceRunningOnNode(AmServerName nodeName, Task.TaskErrorLoggingDelegate writeError)
{
if (!DatabaseTasksHelper.IsServiceRunningOnNode("msexchangerepl", nodeName))
{
writeError(new ReplServiceNotRunningOnNodeException(nodeName.NetbiosName), ErrorCategory.InvalidOperation, null);
}
}
internal static void CheckDomainForRemoval(AcceptedDomain acceptedDomain, Task.TaskErrorLoggingDelegate writeError)
{
if (acceptedDomain.Default)
{
writeError(new CannotRemoveDefaultAcceptedDomainException(), ErrorCategory.InvalidOperation, acceptedDomain);
}
}
public static string EncryptSecretWithDKM(string secretInClearText, Task.TaskErrorLoggingDelegate writeError)
{
if (string.IsNullOrEmpty(secretInClearText))
{
throw new ArgumentNullException("secretInClearText");
}
if (writeError == null)
{
throw new ArgumentNullException("writeError");
}
ExchangeGroupKey exchangeGroupKey = new ExchangeGroupKey(null, "Microsoft Exchange DKM");
string result;
try
{
result = exchangeGroupKey.ClearStringToEncryptedString(secretInClearText);
}
catch (Exception ex)
{
if (ex is CryptographicException || ex is InvalidDataException || exchangeGroupKey.IsDkmException(ex))
{
writeError(ex, ErrorCategory.InvalidData, null);
}
throw;
}
return(result);
}
public static void ProcessRecord(Action action, Task.TaskErrorLoggingDelegate handleError, object identity)
{
try
{
action();
}
catch (OwaExtensionOperationException exception)
{
handleError(exception, ErrorCategory.InvalidOperation, identity);
}
catch (StorageTransientException exception2)
{
handleError(exception2, ErrorCategory.WriteError, null);
}
catch (StoragePermanentException exception3)
{
handleError(exception3, ErrorCategory.WriteError, null);
}
catch (XmlException exception4)
{
handleError(exception4, ErrorCategory.InvalidData, null);
}
catch (XPathException exception5)
{
handleError(exception5, ErrorCategory.InvalidData, null);
}
}
internal static void VerifyMailboxVersion(ADObject adObject, Task.TaskErrorLoggingDelegate writeErrorDelegate)
{
if (adObject.ExchangeVersion.IsOlderThan(ExchangeObjectVersion.Exchange2010))
{
writeErrorDelegate(new TaskException(Strings.ErrorMailboxVersionTooOld(adObject.Id.ToString())), ErrorCategory.ReadError, null);
}
}
public static void ValidateCompleteAfterTime(DateTime completeAfterUtc, Task.TaskErrorLoggingDelegate writeError, DateTime utcNow)
{
if (utcNow.AddDays(120.0) < completeAfterUtc)
{
writeError(new MoveCompleteAfterDateRangeException(120), ErrorCategory.InvalidArgument, completeAfterUtc);
}
}
internal static void CheckUserVersion(ADUser user, Task.TaskErrorLoggingDelegate writeError)
{
if (user.ExchangeVersion.IsOlderThan(ExchangeObjectVersion.Exchange2010))
{
writeError(new InvalidOperationException(Strings.ErrorCannotOpenLegacyMailbox(user.Identity.ToString())), ErrorCategory.InvalidOperation, user.Identity);
}
}
internal static void WriteRpcError(RpcException e, string server, Task.TaskErrorLoggingDelegate errorHandler)
{
LocalizedException exception;
ErrorCategory category;
ManageExchangeCertificate.ProcessRpcError(e, server, out exception, out category);
errorHandler(exception, category, null);
}
internal static void ValidateIncomingServerLength(string incomingServer, Task.TaskErrorLoggingDelegate taskErrorLoggingDelegate)
{
SyncUtilities.ThrowIfArgumentNullOrEmpty("incomingServer", incomingServer);
SyncUtilities.ThrowIfArgumentNull("taskErrorLoggingDelegate", taskErrorLoggingDelegate);
if (incomingServer.Length > SyncUtilities.MaximumFqdnLength)
{
taskErrorLoggingDelegate(new IncomingServerTooLongException(), ErrorCategory.InvalidArgument, null);
}
}
internal HaTaskOutputHelper(string taskName, Task.TaskErrorLoggingDelegate writeError, Task.TaskWarningLoggingDelegate writeWarning, Task.TaskVerboseLoggingDelegate writeVerbose, Task.TaskProgressLoggingDelegate writeProgress, int hashCode)
{
this.m_taskName = taskName;
this.m_writeError = writeError;
this.m_writeWarning = writeWarning;
this.m_writeVerbose = writeVerbose;
this.m_writeProgress = writeProgress;
this.m_hashCode = hashCode;
}
internal static void VerifyIsInScopes(ADObject adObject, ScopeSet scopeSet, Task.TaskErrorLoggingDelegate writeErrorDelegate)
{
ADScopeException ex;
if (!ADSession.TryVerifyIsWithinScopes(adObject, scopeSet.RecipientReadScope, scopeSet.RecipientWriteScopes, scopeSet.ExclusiveRecipientScopes, false, out ex))
{
writeErrorDelegate(new TaskException(Strings.ErrorCannotChangeObjectOutOfWriteScope(adObject.Identity.ToString(), (ex == null) ? string.Empty : ex.Message), ex), ErrorCategory.PermissionDenied, null);
}
}
internal void Validate(Task.TaskErrorLoggingDelegate writeError)
{
this.LogonTypes = new MultiValuedProperty <string>();
if (this.LogonTypesUserInput == null)
{
this.LogonTypes.Add("Admin");
this.LogonTypes.Add("Delegate");
if (this.ShowDetails)
{
this.LogonTypes.Add("Owner");
}
}
else
{
if (!this.ShowDetails && base.ExternalAccess != null && base.ExternalAccess.Value && this.LogonTypesUserInput.Count == 1 && (this.LogonTypesUserInput[0] & AuditScopes.Delegate) == AuditScopes.Delegate)
{
writeError(new ArgumentException(Strings.ErrorInvalidLogonType), ErrorCategory.InvalidArgument, null);
}
foreach (AuditScopes auditScopes in this.LogonTypesUserInput)
{
if ((auditScopes & AuditScopes.Admin) == AuditScopes.Admin)
{
this.LogonTypes.Add("Admin");
}
if ((auditScopes & AuditScopes.Delegate) == AuditScopes.Delegate)
{
this.LogonTypes.Add("Delegate");
}
if ((auditScopes & AuditScopes.Owner) == AuditScopes.Owner)
{
if (!this.ShowDetails)
{
writeError(new ArgumentException(Strings.ErrorInvalidMailboxAuditLogSearchCriteria), ErrorCategory.InvalidArgument, null);
}
else
{
this.LogonTypes.Add("Owner");
}
}
}
}
if (this.OperationsUserInput != null)
{
if (!this.LogonTypes.Contains("Owner") && this.OperationsUserInput.Contains(MailboxAuditOperations.MailboxLogin))
{
writeError(new ArgumentException(Strings.ErrorInvalidOperation), ErrorCategory.InvalidArgument, null);
}
foreach (MailboxAuditOperations mailboxAuditOperations in this.OperationsUserInput)
{
if (mailboxAuditOperations != MailboxAuditOperations.None)
{
this.Operations.Add(mailboxAuditOperations.ToString());
}
}
}
}
internal static void VerifyIsInScopes(ADObject adObject, ScopeSet scopeSet, Task.TaskErrorLoggingDelegate writeErrorDelegate)
{
try
{
ADSession.VerifyIsWithinScopes(adObject, scopeSet.RecipientReadScope, scopeSet.RecipientWriteScopes, scopeSet.ExclusiveRecipientScopes, false);
}
catch (ADScopeException)
{
writeErrorDelegate(new MailboxSearchScopeException(adObject.Id.ToString()), ErrorCategory.PermissionDenied, null);
}
}
public static void Validate(HybridConfiguration dataObject, bool hasErrors, Task.TaskErrorLoggingDelegate writeErrorFunc)
{
if (hasErrors)
{
return;
}
if (dataObject.MaximumSupportedExchangeObjectVersion.ExchangeBuild < dataObject.ExchangeVersion.ExchangeBuild)
{
writeErrorFunc(new InvalidObjectOperationException(HybridStrings.ErrorHybridConfigurationTooNew(dataObject.ExchangeVersion.ToString(), dataObject.MaximumSupportedExchangeObjectVersion.ToString())), ErrorCategory.InvalidArgument, null);
}
}
protected override void InternalProcessComplete()
{
base.InternalProcessComplete();
if (this.CertificateAuthentication)
{
T dataObject = this.DataObject;
dataObject.CertificateAuthentication = new bool?(true);
ADExchangeServiceVirtualDirectory virtualDirectory = this.DataObject;
Task.TaskErrorLoggingDelegate errorHandler = new Task.TaskErrorLoggingDelegate(base.WriteError);
T dataObject2 = this.DataObject;
ExchangeServiceVDirHelper.SetIisVirtualDirectoryAuthenticationMethods(virtualDirectory, errorHandler, Strings.ErrorUpdatingVDir(dataObject2.MetabasePath, string.Empty));
}
}
internal static void CheckServerDoesNotBelongToDifferentStampGroup(Task.TaskErrorLoggingDelegate writeError, IConfigDataProvider dataSession, Server server, string stampGroupName)
{
ADObjectId databaseAvailabilityGroup = server.DatabaseAvailabilityGroup;
if (databaseAvailabilityGroup != null)
{
StampGroup stampGroup = (StampGroup)dataSession.Read <StampGroup>(databaseAvailabilityGroup);
if (stampGroup != null && stampGroup.Name != stampGroupName)
{
writeError(new DagTaskServerMailboxServerIsInDifferentDagException(server.Name, stampGroup.Name), ErrorCategory.InvalidArgument, null);
}
}
}
internal static void ValidateParamString(string paramName, string value, Task.TaskErrorLoggingDelegate errorLogger, bool blockWildcards)
{
if (string.IsNullOrEmpty(paramName))
{
throw new ArgumentNullException("paramName");
}
if (string.IsNullOrEmpty(value))
{
throw new ArgumentNullException("value");
}
if (value.Contains("\"") || value.Contains("$") || (blockWildcards && value.Contains("*")))
{
errorLogger(new ArgumentException(Strings.ErrorInvalidCharactersInParameterValue(paramName, value, blockWildcards ? "{'\"', '$', '*'}" : "{'\"', '$'}")), ErrorCategory.InvalidArgument, null);
}
}
internal static void ValidateDomainName(AcceptedDomain domain, Task.TaskErrorLoggingDelegate errorWriter)
{
string domain2 = domain.DomainName.Domain;
DuplicateAcceptedDomainException ex = new DuplicateAcceptedDomainException(domain2);
ConflictingAcceptedDomainException conflictingAcceptedDomainException = new ConflictingAcceptedDomainException(domain2);
Exception ex2;
if (!ADAccountPartitionLocator.ValidateDomainName(domain, ex, conflictingAcceptedDomainException, out ex2))
{
ErrorCategory category = ErrorCategory.InvalidOperation;
if (ex2 == ex)
{
category = ErrorCategory.ResourceExists;
}
errorWriter(ex2, category, domain);
}
}
public SourceValidator(Task.TaskErrorLoggingDelegate writeErrorDelegate, Action <LocalizedString> writeWarningDelegate, Func <LocalizedString, bool> shouldContinueDelegate, ExecutionLog logger, string logTag, string tenantId, SourceValidator.Clients client)
{
if (client == SourceValidator.Clients.NewCompliancePolicy || client == SourceValidator.Clients.SetCompliancePolicy)
{
ArgumentValidator.ThrowIfNull("writeErrorDelegate", writeErrorDelegate);
ArgumentValidator.ThrowIfNull("writeWarningDelegate", writeWarningDelegate);
ArgumentValidator.ThrowIfNull("shouldContinueDelegate", shouldContinueDelegate);
}
this.writeErrorDelegate = writeErrorDelegate;
this.writeWarningDelegate = writeWarningDelegate;
this.shouldContinueDelegate = shouldContinueDelegate;
this.logger = logger;
this.logTag = logTag;
this.tenantId = tenantId;
this.client = client;
this.logCorrelationId = Guid.NewGuid().ToString();
}
protected override void InternalProcessRecord()
{
base.InternalProcessRecord();
base.InternalEnableLiveIdNegotiateAuxiliaryModule();
if (base.Fields["CertificateAuthentication"] != null)
{
T dataObject = this.DataObject;
dataObject.CertificateAuthentication = new bool?((bool)base.Fields["CertificateAuthentication"]);
ADExchangeServiceVirtualDirectory virtualDirectory = this.DataObject;
Task.TaskErrorLoggingDelegate errorHandler = new Task.TaskErrorLoggingDelegate(base.WriteError);
T dataObject2 = this.DataObject;
ExchangeServiceVDirHelper.SetIisVirtualDirectoryAuthenticationMethods(virtualDirectory, errorHandler, Strings.ErrorUpdatingVDir(dataObject2.MetabasePath, string.Empty));
T dataObject3 = this.DataObject;
ExchangeServiceVDirHelper.ConfigureAnonymousAuthentication(dataObject3.MetabasePath, false);
}
if (base.Fields["EnableCertificateHeaderAuthModule"] != null)
{
base.SetCertificateHeaderAuthenticationModule(this.EnableCertificateHeaderAuthModule, false);
}
}
internal static void UpdateMetabase(ADOabVirtualDirectory virtualDirectory, Task.TaskErrorLoggingDelegate handler)
{
try
{
DirectoryEntry directoryEntry2;
DirectoryEntry directoryEntry = directoryEntry2 = IisUtility.CreateIISDirectoryEntry(virtualDirectory.MetabasePath);
try
{
ArrayList arrayList = new ArrayList();
int num = (int)(IisUtility.GetIisPropertyValue("AccessSSLFlags", IisUtility.GetProperties(directoryEntry)) ?? 0);
if (virtualDirectory.RequireSSL)
{
num |= 8;
}
else
{
num &= -9;
num &= -257;
num &= -65;
}
arrayList.Add(new MetabaseProperty("AccessSSLFlags", num, true));
IisUtility.SetAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.Basic, virtualDirectory.BasicAuthentication);
IisUtility.SetAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.WindowsIntegrated, virtualDirectory.WindowsAuthentication);
IisUtility.SetProperties(directoryEntry, arrayList);
directoryEntry.CommitChanges();
IisUtility.CommitMetabaseChanges((virtualDirectory.Server == null) ? null : virtualDirectory.Server.ToString());
}
finally
{
if (directoryEntry2 != null)
{
((IDisposable)directoryEntry2).Dispose();
}
}
}
catch (COMException exception)
{
handler(exception, ErrorCategory.InvalidOperation, virtualDirectory.Identity);
}
}
private static void RunNetShProcess(string args, Task.TaskErrorLoggingDelegate errorHandler)
{
string text = null;
string text2 = null;
try
{
ProcessRunner.Run(ManageService.NetshExe, args, -1, null, out text, out text2);
}
catch (Win32Exception exception)
{
errorHandler(exception, ErrorCategory.InvalidOperation, null);
}
catch (System.TimeoutException exception2)
{
errorHandler(exception2, ErrorCategory.OperationTimeout, null);
}
catch (InvalidOperationException exception3)
{
errorHandler(exception3, ErrorCategory.InvalidOperation, null);
}
}
internal static void ValidateSwitches(DatabaseAvailabilityGroupNetwork net, Task.TaskErrorLoggingDelegate writeError)
{
if (net.IsModified(DatabaseAvailabilityGroupNetworkSchema.ReplicationEnabled) && net.IsModified(DatabaseAvailabilityGroupNetworkSchema.IgnoreNetwork))
{
if (net.IgnoreNetwork && net.ReplicationEnabled)
{
writeError(new DagNetworkInconsistentRoleException(), ErrorCategory.InvalidArgument, null);
return;
}
}
else
{
if (net.IsModified(DatabaseAvailabilityGroupNetworkSchema.ReplicationEnabled) && net.ReplicationEnabled)
{
net.IgnoreNetwork = false;
}
if (net.IsModified(DatabaseAvailabilityGroupNetworkSchema.IgnoreNetwork) && net.IgnoreNetwork)
{
net.ReplicationEnabled = false;
}
}
}
public static void CheckDatabaseCopyForCopyTask(Database database, Task.TaskErrorLoggingDelegate writeError, Server server, out DatabaseCopy databaseCopy, out DatabaseCopy[] databaseCopies)
{
databaseCopy = null;
databaseCopies = database.GetDatabaseCopies();
if (databaseCopies == null || databaseCopies.Length == 0)
{
writeError(new CopyConfigurationErrorException(Strings.ErrorCouldNotReadDatabaseCopy(database.Name)), ErrorCategory.ReadError, database.Identity);
}
else
{
foreach (DatabaseCopy databaseCopy2 in databaseCopies)
{
if (databaseCopy2.HostServer.ObjectGuid == server.Guid)
{
databaseCopy = databaseCopy2;
break;
}
}
}
if (databaseCopy == null && database.ReplicationType == ReplicationType.Remote)
{
writeError(new InvalidOperationException(Strings.ErrorDbCopyNotHostedOnServer(database.Identity.ToString(), server.Identity.ToString())), ErrorCategory.InvalidData, database.Identity);
}
}
