internal static void CreateOmaVDir(string metabasePath, VirtualDirectoryRole role)
{
MetabasePropertyTypes.AppPoolIdentityType appPoolIdentityType = MetabasePropertyTypes.AppPoolIdentityType.LocalSystem;
if (IisUtility.WebDirObjectExists(metabasePath, "oma"))
{
string hostName = IisUtility.GetHostName(metabasePath);
string appPoolRootPath = IisUtility.GetAppPoolRootPath(hostName);
using (DirectoryEntry directoryEntry = IisUtility.FindWebObject(appPoolRootPath, "MSExchangeOWAAppPool", "IIsApplicationPool"))
{
IisUtility.SetProperty(directoryEntry, "AppPoolIdentityType", appPoolIdentityType, true);
directoryEntry.CommitChanges();
}
return;
}
CreateVirtualDirectory createVirtualDirectory = new CreateVirtualDirectory();
createVirtualDirectory.Name = "oma";
createVirtualDirectory.Parent = metabasePath;
createVirtualDirectory.LocalPath = OwaVirtualDirectoryHelper.OwaCafePath;
createVirtualDirectory.CustomizedVDirProperties = OwaVirtualDirectoryHelper.GetOmaVDirProperties(role);
createVirtualDirectory.ApplicationPool = "MSExchangeOWAAppPool";
createVirtualDirectory.AppPoolIdentityType = appPoolIdentityType;
createVirtualDirectory.AppPoolManagedPipelineMode = MetabasePropertyTypes.ManagedPipelineMode.Integrated;
createVirtualDirectory.AppPoolQueueLength = 10;
createVirtualDirectory.Initialize();
createVirtualDirectory.Execute();
}
private bool IsOrphanVdir(ExchangeVirtualDirectory vdir)
{
string hostName = IisUtility.GetHostName(vdir.MetabasePath);
if (string.IsNullOrEmpty(hostName))
{
base.TraceInfo("IsOrphanVdir: hostname from vdir.MetabasePath is null.");
return(false);
}
string text = TestVirtualDirectoryConnectivity.GetFirstPeriodDelimitedWord(Environment.MachineName).ToLower();
base.TraceInfo("vdir hostname is {0}, localHost is {1}, vdir metabasepath: {2}", new object[]
{
hostName.ToLower(),
text.ToLower(),
vdir.MetabasePath
});
if (!TestVirtualDirectoryConnectivity.GetFirstPeriodDelimitedWord(hostName.ToLower()).Equals(text))
{
base.TraceInfo("IsOrphanVdir: Vdir is not on localhost, so can't check whether it is an orphan.");
return(false);
}
if (!IisUtility.Exists(vdir.MetabasePath))
{
base.TraceInfo("IsOrphanVdir: Vdir is an orphan.");
return(true);
}
base.TraceInfo("IsOrphanVdir: Vdir is not an orphan.");
return(false);
}
internal static bool CheckAuthModule(ADExchangeServiceVirtualDirectory advdir, bool isChildVDirApplication, string moduleName)
{
DirectoryEntry directoryEntry = IisUtility.CreateIISDirectoryEntry(advdir.MetabasePath);
bool result;
using (ServerManager serverManager = ServerManager.OpenRemote(IisUtility.GetHostName(advdir.MetabasePath)))
{
Configuration webConfiguration;
if (isChildVDirApplication)
{
webConfiguration = serverManager.Sites[IisUtility.GetWebSiteName(directoryEntry.Parent.Parent.Path)].Applications[string.Format("/{0}/{1}", directoryEntry.Parent.Name, directoryEntry.Name)].GetWebConfiguration();
}
else
{
webConfiguration = serverManager.Sites[IisUtility.GetWebSiteName(directoryEntry.Parent.Path)].Applications["/" + directoryEntry.Name].GetWebConfiguration();
}
ConfigurationElementCollection collection = webConfiguration.GetSection("system.webServer/modules").GetCollection();
foreach (ConfigurationElement configurationElement in collection)
{
if (string.Equals(configurationElement.Attributes["name"].Value.ToString(), moduleName, StringComparison.Ordinal))
{
return(true);
}
}
result = false;
}
return(result);
}
protected override void InternalProcessRecord()
{
object[] array = new object[1];
object[] array2 = array;
int num = 0;
T dataObject = base.DataObject;
array2[num] = dataObject.Identity;
TaskLogger.LogEnter(array);
T dataObject2 = base.DataObject;
byte major = dataObject2.ExchangeVersion.ExchangeBuild.Major;
T dataObject3 = base.DataObject;
if (major != dataObject3.MaximumSupportedExchangeObjectVersion.ExchangeBuild.Major)
{
T dataObject4 = base.DataObject;
base.WriteError(new CannotModifyCrossVersionObjectException(dataObject4.Id.DistinguishedName), ErrorCategory.InvalidOperation, null);
return;
}
base.InternalProcessRecord();
try
{
this.PreDeleteFromMetabase();
this.DeleteFromMetabase();
}
catch (COMException ex)
{
if (ex.ErrorCode == -2147023174)
{
T dataObject5 = base.DataObject;
Exception exception = new IISNotReachableException(IisUtility.GetHostName(dataObject5.MetabasePath), ex.Message);
ErrorCategory category = ErrorCategory.ReadError;
T dataObject6 = base.DataObject;
this.WriteError(exception, category, dataObject6.Identity, false);
return;
}
T dataObject7 = base.DataObject;
string name = dataObject7.Server.Name;
T dataObject8 = base.DataObject;
Exception exception2 = new InvalidOperationException(Strings.DeleteVirtualDirectoryFail(name, dataObject8.MetabasePath), ex);
ErrorCategory category2 = ErrorCategory.InvalidOperation;
T dataObject9 = base.DataObject;
base.WriteError(exception2, category2, dataObject9.Identity);
return;
}
catch (Exception innerException)
{
T dataObject10 = base.DataObject;
string name2 = dataObject10.Server.Name;
T dataObject11 = base.DataObject;
Exception exception3 = new InvalidOperationException(Strings.DeleteVirtualDirectoryFail(name2, dataObject11.MetabasePath), innerException);
ErrorCategory category3 = ErrorCategory.InvalidOperation;
T dataObject12 = base.DataObject;
base.WriteError(exception3, category3, dataObject12.Identity);
return;
}
TaskLogger.LogExit();
}
private void RunIisConfigurationOperation()
{
if (this.applyDefaults)
{
IISConfigurationUtilities.CreateAndConfigureLocalMapiHttpFrontEnd(this.IISAuthenticationMethods);
return;
}
IISConfigurationUtilities.UpdateRemoteMapiHttpFrontEnd(IisUtility.GetHostName(this.metabasePath), this.IISAuthenticationMethods);
}
internal static void UpdateMetabase(ExchangeWebAppVirtualDirectory webAppVirtualDirectory, string metabasePath, bool enableAnonymous)
{
try
{
DirectoryEntry directoryEntry2;
DirectoryEntry directoryEntry = directoryEntry2 = IisUtility.CreateIISDirectoryEntry(webAppVirtualDirectory.MetabasePath);
try
{
ArrayList arrayList = new ArrayList();
if (webAppVirtualDirectory.DefaultDomain.Length > 0)
{
arrayList.Add(new MetabaseProperty("DefaultLogonDomain", webAppVirtualDirectory.DefaultDomain, true));
}
else if (webAppVirtualDirectory.DefaultDomain == "")
{
directoryEntry.Properties["DefaultLogonDomain"].Clear();
}
IisUtility.SetProperties(directoryEntry, arrayList);
directoryEntry.CommitChanges();
IisUtility.SetAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.None, true);
IisUtility.SetAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.Basic, webAppVirtualDirectory.BasicAuthentication);
IisUtility.SetAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.Digest, webAppVirtualDirectory.DigestAuthentication);
IisUtility.SetAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.WindowsIntegrated, webAppVirtualDirectory.WindowsAuthentication);
IisUtility.SetAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.LiveIdFba, webAppVirtualDirectory.LiveIdAuthentication);
if (webAppVirtualDirectory.FormsAuthentication)
{
OwaIsapiFilter.EnableFba(directoryEntry);
}
else
{
OwaIsapiFilter.DisableFba(directoryEntry);
}
IisUtility.SetAuthenticationMethod(directoryEntry, MetabasePropertyTypes.AuthFlags.Anonymous, enableAnonymous);
directoryEntry.CommitChanges();
}
finally
{
if (directoryEntry2 != null)
{
((IDisposable)directoryEntry2).Dispose();
}
}
GzipLevel gzipLevel = webAppVirtualDirectory.GzipLevel;
string site = IisUtility.WebSiteFromMetabasePath(webAppVirtualDirectory.MetabasePath);
Gzip.SetIisGzipLevel(site, GzipLevel.High);
Gzip.SetVirtualDirectoryGzipLevel(webAppVirtualDirectory.MetabasePath, gzipLevel);
}
catch (IISGeneralCOMException ex)
{
if (ex.Code == -2147023174)
{
throw new IISNotReachableException(IisUtility.GetHostName(webAppVirtualDirectory.MetabasePath), ex.Message);
}
throw;
}
}
public void Execute()
{
DirectoryEntry directoryEntry = IisUtility.CreateWebDirObject(this.Parent, this.LocalPath, this.Name);
if (this.CustomizedVDirProperties != null)
{
IisUtility.SetProperties(directoryEntry, this.CustomizedVDirProperties);
}
directoryEntry.CommitChanges();
string hostName = IisUtility.GetHostName(this.Parent);
IisUtility.CommitMetabaseChanges(hostName);
if (this.ApplicationPool != null && IisUtility.IsSupportedIisVersion(hostName))
{
string appPoolRootPath = IisUtility.GetAppPoolRootPath(hostName);
if (!IisUtility.Exists(appPoolRootPath, this.ApplicationPool, "IIsApplicationPool"))
{
using (DirectoryEntry directoryEntry2 = IisUtility.CreateApplicationPool(hostName, this.ApplicationPool))
{
IisUtility.SetProperty(directoryEntry2, "AppPoolIdentityType", (int)this.AppPoolIdentityType, true);
IisUtility.SetProperty(directoryEntry2, "managedPipelineMode", (int)this.AppPoolManagedPipelineMode, true);
if (this.AppPoolQueueLength != 0)
{
IisUtility.SetProperty(directoryEntry2, "AppPoolQueueLength", this.AppPoolQueueLength, true);
}
directoryEntry2.CommitChanges();
IisUtility.CommitMetabaseChanges(hostName);
using (ServerManager serverManager = new ServerManager())
{
ApplicationPool applicationPool = serverManager.ApplicationPools[this.ApplicationPool];
applicationPool.ProcessModel.LoadUserProfile = true;
if (this.MaximumMemory != 0L)
{
applicationPool.Recycling.PeriodicRestart.Memory = this.MaximumMemory;
}
if (this.MaximumPrivateMemory != 0L)
{
applicationPool.Recycling.PeriodicRestart.PrivateMemory = this.MaximumPrivateMemory;
}
serverManager.CommitChanges();
}
}
}
IisUtility.AssignApplicationPool(directoryEntry, this.ApplicationPool);
}
}
private void SaveLocalPath()
{
DirectoryEntry directoryEntry;
try
{
directoryEntry = IisUtility.FindWebObject(this.Parent, this.Name, "IIsWebVirtualDir");
}
catch (WebObjectNotFoundException)
{
return;
}
this.serverName = IisUtility.GetHostName(this.parent);
if (WmiWrapper.IsDirectoryExisting(this.serverName, (string)directoryEntry.Properties["Path"].Value))
{
this.localPath = (string)directoryEntry.Properties["Path"].Value;
}
}
private static bool IsLocalServer(ADMapiVirtualDirectory dataObject)
{
string hostName = IisUtility.GetHostName(dataObject.MetabasePath);
if (string.IsNullOrEmpty(hostName))
{
return(false);
}
string localComputerFqdn = NativeHelpers.GetLocalComputerFqdn(false);
if (hostName.IndexOf('.') != -1)
{
return(hostName.Equals(localComputerFqdn, StringComparison.InvariantCultureIgnoreCase));
}
string value = SetMapiVirtualDirectory.ServerShortName(localComputerFqdn);
string text = SetMapiVirtualDirectory.ServerShortName(hostName);
return(text.Equals(value, StringComparison.InvariantCultureIgnoreCase));
}
protected override void InternalValidate()
{
base.InternalValidate();
if (base.HasErrors)
{
return;
}
T dataObject = this.DataObject;
string hostName = IisUtility.GetHostName(dataObject.MetabasePath);
try
{
if (!new IisVersionValidCondition(hostName).Verify())
{
Exception exception = new ArgumentException(Strings.ErrorIisVersionIsInvalid(hostName), "Server");
ErrorCategory category = ErrorCategory.InvalidArgument;
T dataObject2 = this.DataObject;
base.WriteError(exception, category, dataObject2.Identity);
return;
}
}
catch (IOException innerException)
{
Exception exception2 = new ArgumentException(Strings.ErrorCannotDetermineIisVersion(hostName), "Server", innerException);
ErrorCategory category2 = ErrorCategory.InvalidArgument;
T dataObject3 = this.DataObject;
base.WriteError(exception2, category2, dataObject3.Identity);
}
catch (InvalidOperationException innerException2)
{
Exception exception3 = new ArgumentException(Strings.ErrorCannotDetermineIisVersion(hostName), "Server", innerException2);
ErrorCategory category3 = ErrorCategory.InvalidArgument;
T dataObject4 = this.DataObject;
base.WriteError(exception3, category3, dataObject4.Identity);
}
ExtendedProtection.Validate(this, this.DataObject);
base.VerifyIsWithinScopes((IConfigurationSession)base.DataSession, this.DataObject, true, new DataAccessTask <T> .ADObjectOutOfScopeString(Strings.ErrorCannotSetVirtualDirectoryOutOfWriteScope));
TaskLogger.LogExit();
}
internal static void UpdateFromMetabase(ExchangeWebAppVirtualDirectory webAppVirtualDirectory)
{
try
{
DirectoryEntry directoryEntry2;
DirectoryEntry directoryEntry = directoryEntry2 = IisUtility.CreateIISDirectoryEntry(webAppVirtualDirectory.MetabasePath);
try
{
MetabaseProperty[] properties = IisUtility.GetProperties(directoryEntry);
webAppVirtualDirectory.DefaultDomain = (string)IisUtility.GetIisPropertyValue("DefaultLogonDomain", properties);
webAppVirtualDirectory[ExchangeWebAppVirtualDirectorySchema.FormsAuthentication] = IisUtility.CheckForAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.Fba);
webAppVirtualDirectory[ExchangeWebAppVirtualDirectorySchema.BasicAuthentication] = IisUtility.CheckForAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.Basic);
webAppVirtualDirectory[ExchangeWebAppVirtualDirectorySchema.DigestAuthentication] = IisUtility.CheckForAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.Digest);
webAppVirtualDirectory[ExchangeWebAppVirtualDirectorySchema.WindowsAuthentication] = IisUtility.CheckForAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.Ntlm);
if (!IisUtility.CheckForAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.None))
{
webAppVirtualDirectory[ExchangeWebAppVirtualDirectorySchema.LiveIdAuthentication] = false;
}
webAppVirtualDirectory.DisplayName = directoryEntry.Name;
webAppVirtualDirectory.WebSite = IisUtility.GetWebSiteName(directoryEntry.Parent.Path);
}
finally
{
if (directoryEntry2 != null)
{
((IDisposable)directoryEntry2).Dispose();
}
}
webAppVirtualDirectory.GzipLevel = Gzip.GetGzipLevel(webAppVirtualDirectory.MetabasePath);
}
catch (IISGeneralCOMException ex)
{
if (ex.Code == -2147023174)
{
throw new IISNotReachableException(IisUtility.GetHostName(webAppVirtualDirectory.MetabasePath), ex.Message);
}
throw;
}
}
public void Execute()
{
this.checkPoints.Clear();
this.SaveLocalPath();
this.SaveAppPoolName();
try
{
IisUtility.FindWebDirObject(this.Parent, this.Name);
IisUtility.DeleteWebDirObject(this.Parent, this.Name);
this.checkPoints.Push(DeleteVirtualDirectory.CheckPoint.VirtualDirectoryDeleted);
}
catch (WebObjectNotFoundException)
{
}
string hostName = IisUtility.GetHostName(this.parent);
if (this.applicationPool != null && IisUtility.IsSupportedIisVersion(hostName))
{
if (!this.DeleteApplicationPool)
{
if (!IisUtility.ApplicationPoolIsEmpty(this.applicationPool, hostName))
{
return;
}
}
try
{
string appPoolRootPath = IisUtility.GetAppPoolRootPath(hostName);
IisUtility.FindWebObject(appPoolRootPath, this.applicationPool, "IIsApplicationPool");
IisUtility.DeleteApplicationPool(hostName, this.applicationPool);
this.checkPoints.Push(DeleteVirtualDirectory.CheckPoint.ApplicationPoolDeleted);
}
catch (WebObjectNotFoundException)
{
}
}
}
private static bool GetServerWebSiteAndPath(string metabasePath, out string serverName, out string webSiteName, out string appPath)
{
serverName = IisUtility.GetHostName(metabasePath);
int num = metabasePath.IndexOf("/ROOT/");
if (num > 0)
{
num = metabasePath.IndexOf("/", num + 1);
}
if (num > 0)
{
string text = metabasePath.Substring(0, num);
if (!string.IsNullOrEmpty(text))
{
webSiteName = IisUtility.GetWebSiteName(text);
appPath = metabasePath.Substring(num);
return(true);
}
}
serverName = string.Empty;
webSiteName = string.Empty;
appPath = string.Empty;
return(false);
}
protected override void WriteResult(IConfigurable dataObject)
{
ExchangeVirtualDirectory exchangeVirtualDirectory = (ExchangeVirtualDirectory)dataObject;
if (!this.FilterBackendVdir(exchangeVirtualDirectory))
{
exchangeVirtualDirectory.ADPropertiesOnly = this.ADPropertiesOnly;
if (!exchangeVirtualDirectory.IsReadOnly && !this.ADPropertiesOnly)
{
bool flag = true;
try
{
using (DirectoryEntry directoryEntry = IisUtility.CreateIISDirectoryEntry(exchangeVirtualDirectory.MetabasePath, new Task.TaskErrorLoggingReThrowDelegate(this.WriteError), dataObject.Identity, false))
{
if (directoryEntry != null)
{
this.MetabaseProperties = IisUtility.GetProperties(directoryEntry);
this.ProcessMetabaseProperties(exchangeVirtualDirectory);
flag = false;
}
}
}
catch (IISNotInstalledException exception)
{
this.WriteError(exception, ErrorCategory.ReadError, null, false);
}
catch (IISNotReachableException exception2)
{
this.WriteError(exception2, ErrorCategory.ReadError, null, false);
}
catch (IISGeneralCOMException ex)
{
if (ex.Code == -2147023174)
{
this.WriteError(new IISNotReachableException(IisUtility.GetHostName(exchangeVirtualDirectory.MetabasePath), ex.Message), ErrorCategory.ResourceUnavailable, null, false);
}
else
{
if (ex.Code != -2147024893)
{
throw;
}
if (!this.CanIgnoreMissingMetabaseEntry())
{
this.WriteError(ex, ErrorCategory.ReadError, null, false);
}
else
{
this.WriteWarning(this.GetMissingMetabaseEntryWarning(exchangeVirtualDirectory));
flag = false;
}
}
}
catch (UnauthorizedAccessException exception3)
{
this.WriteError(exception3, ErrorCategory.PermissionDenied, null, false);
}
if (flag)
{
return;
}
}
base.WriteResult(dataObject);
}
}
