private bool?GetAuthentication(ExchangeVirtualDirectory dataObject, string subVDirName, AuthenticationMethodFlags authFlags)
{
TaskLogger.LogEnter();
try
{
string text = dataObject.MetabasePath;
if (!string.IsNullOrEmpty(subVDirName))
{
text = string.Format("{0}/{1}", text, subVDirName);
}
if (IisUtility.Exists(text))
{
using (DirectoryEntry directoryEntry = IisUtility.CreateIISDirectoryEntry(text, new Task.TaskErrorLoggingReThrowDelegate(this.WriteError), dataObject.Identity))
{
bool ignoreAnonymousOnCert = dataObject is ADPowerShellCommonVirtualDirectory;
return(new bool?(IisUtility.CheckForAuthenticationMethod(directoryEntry, authFlags, ignoreAnonymousOnCert)));
}
}
}
catch (Exception ex)
{
TaskLogger.Trace("Exception occurred: {0}", new object[]
{
ex.Message
});
base.WriteError(new LocalizedException(this.MetabaseGetPropertiesFailureMessage, ex), (ErrorCategory)1001, dataObject.Identity);
}
finally
{
TaskLogger.LogExit();
}
return(null);
}
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);
}
public override bool Verify()
{
TaskLogger.LogEnter();
bool flag = false;
if (this.webSitePath != null)
{
flag = IisUtility.Exists(this.WebSitePath, "IIsWebServer");
}
else
{
try
{
IisUtility.FindWebSiteRoot(this.WebSiteName, this.ServerName);
flag = true;
}
catch (WebObjectNotFoundException)
{
flag = false;
}
}
TaskLogger.Trace("WebSiteExistsCondition is returning '{0}'", new object[]
{
flag
});
TaskLogger.LogExit();
return(flag);
}
public static void DeleteFromMetabase(string webSiteRoot, string virtualDirectoryName, ICollection childVirtualDirectoryNames)
{
if (childVirtualDirectoryNames != null)
{
string text = string.Format("{0}/{1}", webSiteRoot, virtualDirectoryName);
foreach (object obj in childVirtualDirectoryNames)
{
string text2 = (string)obj;
if (IisUtility.WebDirObjectExists(text, text2))
{
DeleteVirtualDirectory deleteVirtualDirectory = new DeleteVirtualDirectory();
deleteVirtualDirectory.Name = text2;
deleteVirtualDirectory.Parent = text;
deleteVirtualDirectory.Initialize();
deleteVirtualDirectory.Execute();
}
}
}
if (IisUtility.Exists(webSiteRoot, virtualDirectoryName, "IIsWebVirtualDir"))
{
DeleteVirtualDirectory deleteVirtualDirectory2 = new DeleteVirtualDirectory();
deleteVirtualDirectory2.Name = virtualDirectoryName;
deleteVirtualDirectory2.Parent = webSiteRoot;
deleteVirtualDirectory2.Initialize();
deleteVirtualDirectory2.Execute();
}
}
protected virtual bool CreateToMetabase()
{
bool result = false;
T dataObject = this.DataObject;
int num = dataObject.MetabasePath.LastIndexOf('/');
T dataObject2 = this.DataObject;
string text = dataObject2.MetabasePath.Substring(0, num);
T dataObject3 = this.DataObject;
string text2 = dataObject3.MetabasePath.Substring(num + 1);
if (!this.FailOnVirtualDirectoryAlreadyExists())
{
T dataObject4 = this.DataObject;
if (IisUtility.Exists(dataObject4.MetabasePath, "IIsWebVirtualDir"))
{
IisUtility.DeleteWebDirObject(text, text2);
}
}
CreateVirtualDirectory createVirtualDirectory = new CreateVirtualDirectory();
createVirtualDirectory.Name = text2;
createVirtualDirectory.Parent = text;
createVirtualDirectory.LocalPath = this.Path;
createVirtualDirectory.ApplicationPool = this.AppPoolId;
createVirtualDirectory.AppPoolIdentityType = this.AppPoolIdentityType;
createVirtualDirectory.AppPoolManagedPipelineMode = this.AppPoolManagedPipelineMode;
createVirtualDirectory.CustomizedVDirProperties = this.CustomizedVDirProperties;
if (!string.IsNullOrEmpty(createVirtualDirectory.ApplicationPool) && this.LimitMaximumMemory)
{
ulong totalPhysicalMemory = new ComputerInfo().TotalPhysicalMemory;
createVirtualDirectory.MaximumPrivateMemory = (long)(totalPhysicalMemory / 100UL * 80UL / 1024UL);
}
createVirtualDirectory.Initialize();
createVirtualDirectory.Execute();
result = true;
string parent = string.Format("{0}/{1}", text, text2);
ListDictionary childVirtualDirectories = this.ChildVirtualDirectories;
if (childVirtualDirectories != null)
{
foreach (object obj in childVirtualDirectories.Keys)
{
string text3 = (string)obj;
CreateVirtualDirectory createVirtualDirectory2 = new CreateVirtualDirectory();
createVirtualDirectory2.Name = text3;
createVirtualDirectory2.Parent = parent;
createVirtualDirectory2.CustomizedVDirProperties = (ICollection)childVirtualDirectories[text3];
createVirtualDirectory2.LocalPath = (string)IisUtility.GetIisPropertyValue("Path", (ICollection)childVirtualDirectories[text3]);
createVirtualDirectory2.Initialize();
createVirtualDirectory2.Execute();
}
}
return(result);
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
if (!this.Force)
{
foreach (ADPropertyDefinition adpropertyDefinition in NewWebServicesVirtualDirectory.HostProperties)
{
if (!NewWebServicesVirtualDirectory.IsValidHost(this.DataObject, adpropertyDefinition) && !base.ShouldContinue(Strings.ConfirmationMessageHostCannotBeResolved(adpropertyDefinition.Name)))
{
TaskLogger.LogExit();
return;
}
}
}
if (!(this.DataObject.WindowsAuthentication ?? true))
{
if (base.ExchangeRunspaceConfig != null && base.ExchangeRunspaceConfig.ConfigurationSettings != null && (base.ExchangeRunspaceConfig.ConfigurationSettings.ClientApplication == ExchangeRunspaceConfigurationSettings.ExchangeApplication.ECP || base.ExchangeRunspaceConfig.ConfigurationSettings.ClientApplication == ExchangeRunspaceConfigurationSettings.ExchangeApplication.OSP))
{
if (!this.Force && !base.ShouldContinue(new LocalizedString(string.Format("{0} {1}", Strings.WarningMessageSetWebServicesVirtualDirectoryWindowsAuthentication(this.Identity.ToString()), Strings.ConfirmationMessageWebServicesVirtualDirectoryContinue))))
{
TaskLogger.LogExit();
return;
}
}
else
{
this.WriteWarning(Strings.WarningMessageSetWebServicesVirtualDirectoryWindowsAuthentication(this.Identity.ToString()));
if (!this.Force && !base.ShouldContinue(Strings.ConfirmationMessageWebServicesVirtualDirectoryContinue))
{
TaskLogger.LogExit();
return;
}
}
}
this.DataObject.CertificateAuthentication = null;
base.InternalProcessRecord();
base.InternalEnableLiveIdNegotiateAuxiliaryModule();
if (Datacenter.IsMicrosoftHostedOnly(true))
{
string text = string.Format("{0}/{1}", this.DataObject.MetabasePath, "Nego2");
if (!IisUtility.Exists(text))
{
DirectoryEntry directoryEntry = IisUtility.CreateWebDirObject(this.DataObject.MetabasePath, null, "Nego2");
IisUtility.SetProperty(directoryEntry, "AccessFlags", MetabasePropertyTypes.AccessFlags.Read | MetabasePropertyTypes.AccessFlags.Script, true);
directoryEntry.CommitChanges();
}
ExchangeServiceVDirHelper.SetSplitVirtualDirectoryAuthenticationMethods(this.DataObject, text, new Task.TaskErrorLoggingDelegate(base.WriteError), this.MetabaseSetPropertiesFailureMessage);
ExchangeServiceVDirHelper.ForceAnonymous(text);
}
ExchangeServiceVDirHelper.ForceAnonymous(this.DataObject.MetabasePath);
ExchangeServiceVDirHelper.EwsAutodiscMWA.OnSetManageWCFEndpoints(this, ExchangeServiceVDirHelper.EwsAutodiscMWA.EndpointProtocol.Ews, this.WSSecurityAuthentication, this.DataObject);
this.UpdateCompressionSettings();
TaskLogger.LogExit();
}
protected override void InternalValidate()
{
base.InternalValidate();
if (base.HasErrors)
{
return;
}
if (!this.IsInSetup && this.DataObject.ExchangeVersion.IsOlderThan(ADMobileVirtualDirectory.MinimumSupportedExchangeObjectVersion))
{
base.WriteError(new TaskException(Strings.ErrorSetOlderVirtualDirectory(this.DataObject.Identity.ToString(), this.DataObject.ExchangeVersion.ToString(), ADMobileVirtualDirectory.MinimumSupportedExchangeObjectVersion.ToString())), ErrorCategory.InvalidArgument, null);
}
string metabasePath = this.DataObject.MetabasePath;
if (!IisUtility.Exists(metabasePath))
{
base.WriteError(new WebObjectNotFoundException(Strings.ErrorObjectNotFound(metabasePath)), ErrorCategory.ObjectNotFound, metabasePath);
return;
}
if (ExchangeServiceVDirHelper.IsBackEndVirtualDirectory(this.DataObject) && !this.IsInSetup)
{
bool flag = false;
for (int i = 0; i < this.InvalidParametersOnMbxRole.Length; i++)
{
if (base.Fields.Contains(this.InvalidParametersOnMbxRole[i]))
{
this.WriteError(new InvalidArgumentForServerRoleException(this.InvalidParametersOnMbxRole[i], DirectoryStrings.ServerRoleCafe), ErrorCategory.InvalidArgument, this.DataObject, false);
flag = true;
}
}
if (flag)
{
return;
}
}
bool flag2 = IisUtility.SSLEnabled(metabasePath);
if (this.DataObject.BasicAuthEnabled && !flag2)
{
this.WriteWarning(Strings.WarnBasicAuthInClear);
}
if (this.DataObject.ClientCertAuth != ClientCertAuthTypes.Ignore && this.DataObject.ClientCertAuth != ClientCertAuthTypes.Accepted && this.DataObject.ClientCertAuth != ClientCertAuthTypes.Required)
{
base.WriteError(new ArgumentException(Strings.InvalidCertAuthValue, "ClientCertAuth"), ErrorCategory.InvalidArgument, null);
return;
}
if (this.DataObject.ClientCertAuth == ClientCertAuthTypes.Required && !flag2)
{
base.WriteError(new ArgumentException(Strings.CertAuthWithoutSSLError, "ClientCertAuth"), ErrorCategory.InvalidArgument, null);
}
}
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 static void UpdateSubDirectory(ADMobileVirtualDirectory dataObject, string vdirPath, Task task)
{
if (IisUtility.Exists(vdirPath))
{
using (DirectoryEntry directoryEntry = IisUtility.CreateIISDirectoryEntry(vdirPath))
{
IisUtility.SetAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.None, false);
IisUtility.SetAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.WindowsIntegrated, true);
IisUtility.SetProperty(directoryEntry, "AccessFlags", MetabasePropertyTypes.AccessFlags.Script, true);
directoryEntry.CommitChanges();
}
}
if (dataObject.ProxyVirtualDirectoryObject != null)
{
MobileSyncVirtualDirectoryHelper.CopyProxyExtendedParameters(dataObject);
ExtendedProtection.CommitToMetabase(dataObject.ProxyVirtualDirectoryObject, task);
}
}
protected override void PreDeleteFromMetabase()
{
if (!DirectoryEntry.Exists(base.DataObject.MetabasePath))
{
return;
}
using (DirectoryEntry directoryEntry = IisUtility.CreateIISDirectoryEntry(base.DataObject.MetabasePath, new Task.TaskErrorLoggingReThrowDelegate(this.WriteError), this.Identity))
{
PropertyValueCollection propertyValueCollection = directoryEntry.Properties["ScriptMaps"];
foreach (object obj in propertyValueCollection)
{
string text = (string)obj;
string[] array = text.Split(new char[]
{
','
});
if (array.Length >= 2)
{
string fileName = Path.GetFileName(array[1]);
if (string.Compare(fileName, "davex.dll", true, CultureInfo.InvariantCulture) == 0 || string.Compare(fileName, "exprox.dll", true, CultureInfo.InvariantCulture) == 0)
{
this.scriptMapPhysicalPath = array[1];
break;
}
}
}
try
{
string parent = null;
string text2 = null;
string name = null;
IisUtility.ParseApplicationRootPath(directoryEntry.Path, ref parent, ref text2, ref name);
if (IisUtility.Exists(parent, name, "IIsWebVirtualDir"))
{
OwaVirtualDirectoryHelper.DisableIsapiFilter(base.DataObject);
}
}
catch (Exception)
{
this.WriteWarning(Strings.OwaMetabaseIsapiUninstallFailure);
throw;
}
}
}
internal static T FindWebAppVirtualDirectoryInSameWebSite <T>(ExchangeWebAppVirtualDirectory source, IConfigDataProvider dataProvider) where T : ExchangeWebAppVirtualDirectory, new()
{
T result = default(T);
IConfigurable[] array = dataProvider.Find <T>(null, source.Server, true, null);
if (array != null)
{
foreach (ExchangeWebAppVirtualDirectory exchangeWebAppVirtualDirectory in array)
{
if (IisUtility.Exists(exchangeWebAppVirtualDirectory.MetabasePath))
{
WebAppVirtualDirectoryHelper.UpdateFromMetabase(exchangeWebAppVirtualDirectory);
if (string.Equals(source.WebSite, exchangeWebAppVirtualDirectory.WebSite, StringComparison.OrdinalIgnoreCase))
{
result = (T)((object)exchangeWebAppVirtualDirectory);
break;
}
}
}
}
return(result);
}
private static void InstallSubDirectory(ADMobileVirtualDirectory dataObject, string subDirectoryName, Task task)
{
bool flag = false;
using (DirectoryEntry directoryEntry = IisUtility.CreateIISDirectoryEntry(dataObject.MetabasePath, new Task.TaskErrorLoggingReThrowDelegate(task.WriteError), dataObject.Identity))
{
string path = Path.Combine(directoryEntry.Properties["Path"].Value.ToString(), subDirectoryName);
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
string text = string.Format("{0}/{1}", dataObject.MetabasePath, subDirectoryName);
if (!IisUtility.Exists(text))
{
IisUtility.CreateWebDirectory(directoryEntry, subDirectoryName);
MobileSyncVirtualDirectoryHelper.UpdateSubDirectory(dataObject, text, task);
directoryEntry.CommitChanges();
IisUtility.CommitMetabaseChanges((dataObject.Server == null) ? null : dataObject.Server.Name);
flag = true;
}
ExTraceGlobals.TaskTracer.Information(0L, string.Format("Installed SubDirectory '{0}' with result '{1}'", subDirectoryName, flag));
}
}
public override bool Verify()
{
TaskLogger.LogEnter();
bool result = false;
if (this.virtualDirectoryPath != null)
{
result = IisUtility.Exists(this.VirtualDirectoryPath, "IIsWebVirtualDir");
}
else
{
try
{
string str = IisUtility.FindWebSiteRoot(this.WebSiteName, this.ServerName);
result = IisUtility.Exists(str + "/" + this.VirtualDirectoryName, "IIsWebVirtualDir");
}
catch (WebObjectNotFoundException)
{
result = false;
}
}
TaskLogger.LogExit();
return(result);
}
public static void CopyDavVdirsToMetabase(string domainController, string exchangeServerName, string metabaseServerName)
{
ADSessionSettings sessionSettings = ADSessionSettings.FromRootOrgScopeSet();
ITopologyConfigurationSession topologyConfigurationSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(domainController, true, ConsistencyMode.PartiallyConsistent, null, sessionSettings, 154, "CopyDavVdirsToMetabase", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\SystemConfigurationTasks\\VirtualDirectoryTasks\\OWAVirtualDirectoryHelper.cs");
Server server = topologyConfigurationSession.FindServerByName(exchangeServerName);
IConfigDataProvider configDataProvider = topologyConfigurationSession;
IEnumerable <ADOwaVirtualDirectory> enumerable = configDataProvider.FindPaged <ADOwaVirtualDirectory>(null, server.Id, true, null, 0);
OwaVirtualDirectoryHelper.SetWebSvcExtRestrictionList(metabaseServerName);
foreach (ADOwaVirtualDirectory adowaVirtualDirectory in enumerable)
{
if (!adowaVirtualDirectory.IsExchange2007OrLater)
{
string[] array = adowaVirtualDirectory.MetabasePath.Split(new char[]
{
'/'
});
if (array.Length == 7)
{
array[2] = metabaseServerName;
MultiValuedProperty <AuthenticationMethod> internalAuthenticationMethods = adowaVirtualDirectory.InternalAuthenticationMethods;
adowaVirtualDirectory.WindowsAuthentication = true;
string appPoolRootPath = IisUtility.GetAppPoolRootPath(metabaseServerName);
string text = "MSExchangeOWAAppPool";
if (!IisUtility.Exists(appPoolRootPath, text, "IIsApplicationPool"))
{
using (DirectoryEntry directoryEntry = IisUtility.CreateApplicationPool(metabaseServerName, text))
{
IisUtility.SetProperty(directoryEntry, "AppPoolIdentityType", 0, true);
directoryEntry.CommitChanges();
}
}
if (!IisUtility.Exists(string.Join("/", array)))
{
DirectoryEntry directoryEntry2 = IisUtility.CreateWebDirObject(string.Join("/", array, 0, 6), adowaVirtualDirectory.FolderPathname, array[6]);
ArrayList arrayList = new ArrayList();
arrayList.Add(new MetabaseProperty("LogonMethod", MetabasePropertyTypes.LogonMethod.ClearTextLogon));
arrayList.Add(new MetabaseProperty("AccessFlags", MetabasePropertyTypes.AccessFlags.Read | MetabasePropertyTypes.AccessFlags.Write | MetabasePropertyTypes.AccessFlags.Source | MetabasePropertyTypes.AccessFlags.Script));
arrayList.Add(new MetabaseProperty("DirBrowseFlags", (MetabasePropertyTypes.DirBrowseFlags) 3221225534U));
arrayList.Add(new MetabaseProperty("ScriptMaps", OwaVirtualDirectoryHelper.GetDavScriptMaps(), true));
if (adowaVirtualDirectory.VirtualDirectoryType == VirtualDirectoryTypes.Exchweb)
{
arrayList.Add(new MetabaseProperty("HttpExpires", "D, 0x278d00"));
}
if (adowaVirtualDirectory.DefaultDomain.Length > 0)
{
arrayList.Add(new MetabaseProperty("DefaultLogonDomain", adowaVirtualDirectory.DefaultDomain, true));
}
OwaIsapiFilter.DisableFba(directoryEntry2);
uint num = 0U;
using (MultiValuedProperty <AuthenticationMethod> .Enumerator enumerator2 = adowaVirtualDirectory.InternalAuthenticationMethods.GetEnumerator())
{
while (enumerator2.MoveNext())
{
switch (enumerator2.Current)
{
case AuthenticationMethod.Basic:
num |= 2U;
break;
case AuthenticationMethod.Digest:
num |= 16U;
break;
case AuthenticationMethod.Ntlm:
num |= 4U;
break;
case AuthenticationMethod.Fba:
OwaIsapiFilter.EnableFba(directoryEntry2);
break;
}
}
}
arrayList.Add(new MetabaseProperty("AuthFlags", num, true));
IisUtility.SetProperties(directoryEntry2, arrayList);
IisUtility.AssignApplicationPool(directoryEntry2, text);
}
}
}
}
}
