internal static void UninstallIsapiFilter(ADMobileVirtualDirectory vdirObject)
{
using (DirectoryEntry directoryEntry = IisUtility.CreateIISDirectoryEntry(vdirObject.MetabasePath))
{
ActiveSyncIsapiFilter.Uninstall(directoryEntry);
}
}
internal static void InstallAuthModuleIsapiFilter(ADAutodiscoverVirtualDirectory vdirObject)
{
using (DirectoryEntry directoryEntry = IisUtility.CreateIISDirectoryEntry(vdirObject.MetabasePath))
{
AuthModuleIsapiFilter.Install(directoryEntry);
}
}
internal static void UpdateMetabase(ADOabVirtualDirectory virtualDirectory, bool updateAuthenticationMethod, 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));
if (updateAuthenticationMethod)
{
uint num2 = (uint)((int)(IisUtility.GetIisPropertyValue("AuthFlags", IisUtility.GetProperties(directoryEntry)) ?? 0));
num2 |= 4U;
num2 &= 4294967294U;
arrayList.Add(new MetabaseProperty("AuthFlags", num2, true));
MultiValuedProperty <AuthenticationMethod> multiValuedProperty = new MultiValuedProperty <AuthenticationMethod>();
multiValuedProperty.Add(AuthenticationMethod.WindowsIntegrated);
if (IisUtility.CheckForAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.Basic))
{
multiValuedProperty.Add(AuthenticationMethod.Basic);
}
if (IisUtility.CheckForAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.Digest))
{
multiValuedProperty.Add(AuthenticationMethod.Digest);
}
if (IisUtility.CheckForAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.Fba))
{
multiValuedProperty.Add(AuthenticationMethod.Fba);
}
virtualDirectory.ExternalAuthenticationMethods = (virtualDirectory.InternalAuthenticationMethods = multiValuedProperty);
}
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);
}
}
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);
}
public IsapiExtensionList(string hostName)
{
string iisDirectoryEntryPath = string.Format("IIS://{0}/W3SVC", hostName);
try
{
this.rootEntry = IisUtility.CreateIISDirectoryEntry(iisDirectoryEntryPath);
this.restrictionList = this.rootEntry.Properties["WebSvcExtRestrictionList"];
this.extensionMap = new List <IsapiExtensionList.ExtensionMapUnit>(this.restrictionList.Count + 5);
for (int i = 0; i < this.restrictionList.Count; i++)
{
string text = this.restrictionList[i] as string;
if (text != null)
{
IsapiExtension isapiExtension = IsapiExtension.Parse(text);
if (isapiExtension != null)
{
this.extensionMap.Add(new IsapiExtensionList.ExtensionMapUnit(isapiExtension, i));
}
}
}
}
catch (Exception)
{
this.Dispose();
throw;
}
}
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);
}
internal static GzipLevel GetGzipLevel(string adsiVirtualDirectoryPath)
{
GzipLevel result;
using (DirectoryEntry directoryEntry = IisUtility.CreateIISDirectoryEntry(adsiVirtualDirectoryPath))
{
if (!directoryEntry.Properties.Contains("DoDynamicCompression") || !directoryEntry.Properties.Contains("DoStaticCompression"))
{
result = GzipLevel.Off;
}
else
{
bool flag = (bool)directoryEntry.Properties["DoDynamicCompression"].Value;
bool flag2 = (bool)directoryEntry.Properties["DoStaticCompression"].Value;
if (!flag && !flag2)
{
result = GzipLevel.Off;
}
else if (!flag && flag2)
{
result = GzipLevel.Low;
}
else if (flag && flag2)
{
result = GzipLevel.High;
}
else
{
result = GzipLevel.Error;
}
}
}
return(result);
}
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 static void LoadFromMetabase(string metabasePath, ObjectId identity, Task task, out ExtendedProtectionTokenCheckingMode extendedProtectionTokenChecking, out MultiValuedProperty <ExtendedProtectionFlag> extendedProtectionFlags, out MultiValuedProperty <string> extendedProtectionSPNList)
{
extendedProtectionTokenChecking = ExtendedProtectionTokenCheckingMode.None;
extendedProtectionFlags = new MultiValuedProperty <ExtendedProtectionFlag>();
extendedProtectionSPNList = new MultiValuedProperty <string>();
using (DirectoryEntry directoryEntry = IisUtility.CreateIISDirectoryEntry(metabasePath, (task != null) ? new Task.TaskErrorLoggingReThrowDelegate(task.WriteError) : null, identity, false))
{
if (directoryEntry != null)
{
string text;
string str;
string str2;
if (ExtendedProtection.GetServerWebSiteAndPath(metabasePath, out text, out str, out str2))
{
using (ServerManager serverManager = ServerManager.OpenRemote(text))
{
Configuration applicationHostConfiguration = serverManager.GetApplicationHostConfiguration();
if (applicationHostConfiguration != null)
{
ConfigurationSection section = applicationHostConfiguration.GetSection("system.webServer/security/authentication/windowsAuthentication", "/" + str + str2);
if (section != null)
{
ConfigurationElement configurationElement = section.ChildElements["extendedProtection"];
if (configurationElement != null)
{
object attributeValue = configurationElement.GetAttributeValue("tokenChecking");
if (attributeValue != null && attributeValue is int)
{
extendedProtectionTokenChecking = (ExtendedProtectionTokenCheckingMode)attributeValue;
}
object attributeValue2 = configurationElement.GetAttributeValue("flags");
if (attributeValue2 != null && attributeValue2 is int)
{
extendedProtectionFlags.Add((ExtendedProtectionFlag)attributeValue2);
}
ConfigurationElementCollection collection = configurationElement.GetCollection();
if (collection != null)
{
foreach (ConfigurationElement configurationElement2 in collection)
{
if (configurationElement2.Schema.Name == "spn")
{
string item = configurationElement2.GetAttributeValue("name").ToString();
extendedProtectionSPNList.Add(item);
}
}
}
}
}
}
}
}
}
}
}
private void SaveAppPoolName()
{
using (DirectoryEntry directoryEntry = IisUtility.CreateIISDirectoryEntry(this.Parent))
{
DirectoryEntry directoryEntry2 = IisUtility.FindWebDirObject(this.Parent, this.Name);
if (!string.Equals((string)directoryEntry.Properties["AppRoot"].Value, (string)directoryEntry2.Properties["AppRoot"].Value, StringComparison.InvariantCultureIgnoreCase) && !string.Equals((string)directoryEntry.Properties["AppPoolId"].Value, (string)directoryEntry2.Properties["AppPoolId"].Value, StringComparison.InvariantCultureIgnoreCase))
{
this.applicationPool = (string)directoryEntry2.Properties["AppPoolId"].Value;
}
}
}
internal static void SetVirtualDirectoryGzipLevel(string adsiVirtualDirectoryPath, GzipLevel gzipLevel)
{
using (DirectoryEntry directoryEntry = IisUtility.CreateIISDirectoryEntry(adsiVirtualDirectoryPath))
{
bool flag = gzipLevel == GzipLevel.High;
bool flag2 = gzipLevel == GzipLevel.Low || gzipLevel == GzipLevel.High;
IisUtility.SetProperty(directoryEntry, "DoDynamicCompression", flag, true);
IisUtility.SetProperty(directoryEntry, "DoStaticCompression", flag2, true);
directoryEntry.CommitChanges();
IisUtility.CommitMetabaseChanges(IisUtility.ServerFromWebSite(IisUtility.WebSiteFromMetabasePath(directoryEntry.Path)));
}
}
internal static void InstallIsapiFilter(ADMobileVirtualDirectory vdirObject, bool forCafe)
{
using (DirectoryEntry directoryEntry = IisUtility.CreateIISDirectoryEntry(vdirObject.MetabasePath))
{
if (forCafe)
{
ActiveSyncIsapiFilter.InstallForCafe(directoryEntry);
}
else
{
ActiveSyncIsapiFilter.Install(directoryEntry);
}
}
}
internal static void EnableIsapiFilter(ADOwaVirtualDirectory adOwaVirtualDirectory, bool forCafe)
{
using (DirectoryEntry directoryEntry = IisUtility.CreateIISDirectoryEntry(adOwaVirtualDirectory.MetabasePath))
{
if (forCafe)
{
OwaIsapiFilter.InstallForCafe(directoryEntry);
}
else
{
OwaIsapiFilter.Install(directoryEntry);
}
}
}
protected override void ProcessMetabaseProperties(ExchangeVirtualDirectory dataObject)
{
TaskLogger.LogEnter();
base.ProcessMetabaseProperties(dataObject);
((ADOabVirtualDirectory)dataObject).OAuthAuthentication = ((ADOabVirtualDirectory)dataObject).InternalAuthenticationMethods.Contains(AuthenticationMethod.OAuth);
((ADOabVirtualDirectory)dataObject).RequireSSL = IisUtility.SSLEnabled(dataObject.MetabasePath);
using (DirectoryEntry directoryEntry = IisUtility.CreateIISDirectoryEntry(dataObject.MetabasePath))
{
((ADOabVirtualDirectory)dataObject).BasicAuthentication = IisUtility.CheckForAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.Basic);
((ADOabVirtualDirectory)dataObject).WindowsAuthentication = IisUtility.CheckForAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.Ntlm);
}
dataObject.ResetChangeTracking();
TaskLogger.LogExit();
}
internal void CommitMetabaseValues(ExchangeVirtualDirectory dataObject, ArrayList MetabasePropertiesToChange)
{
if (MetabasePropertiesToChange != null)
{
string metabasePath = dataObject.MetabasePath;
Task.TaskErrorLoggingReThrowDelegate writeError = new Task.TaskErrorLoggingReThrowDelegate(this.WriteError);
T dataObject2 = this.DataObject;
using (DirectoryEntry directoryEntry = IisUtility.CreateIISDirectoryEntry(metabasePath, writeError, dataObject2.Identity))
{
IisUtility.SetProperties(directoryEntry, MetabasePropertiesToChange);
directoryEntry.CommitChanges();
IisUtility.CommitMetabaseChanges((dataObject.Server == null) ? null : dataObject.Server.Name);
}
}
}
protected override void StampChangesOn(IConfigurable dataObject)
{
TaskLogger.LogEnter();
ADOabVirtualDirectory adoabVirtualDirectory = (ADOabVirtualDirectory)dataObject;
adoabVirtualDirectory.OAuthAuthentication = adoabVirtualDirectory.InternalAuthenticationMethods.Contains(AuthenticationMethod.OAuth);
adoabVirtualDirectory.RequireSSL = IisUtility.SSLEnabled(adoabVirtualDirectory.MetabasePath);
using (DirectoryEntry directoryEntry = IisUtility.CreateIISDirectoryEntry(adoabVirtualDirectory.MetabasePath))
{
adoabVirtualDirectory.BasicAuthentication = IisUtility.CheckForAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.Basic);
adoabVirtualDirectory.WindowsAuthentication = IisUtility.CheckForAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.Ntlm);
}
dataObject.ResetChangeTracking();
base.StampChangesOn(dataObject);
TaskLogger.LogExit();
}
internal static void RemoveFilters(string hostName)
{
string iisDirectoryEntryPath = IisUtility.CreateAbsolutePath(IisUtility.AbsolutePathType.WebServicesRoot, hostName, null, null);
using (DirectoryEntry directoryEntry = IisUtility.CreateIISDirectoryEntry(iisDirectoryEntryPath))
{
foreach (object obj in directoryEntry.Children)
{
DirectoryEntry directoryEntry2 = (DirectoryEntry)obj;
if (directoryEntry2.SchemaClassName == "IIsWebServer")
{
OwaIsapiFilter.RemoveFilter(directoryEntry2.Path);
}
}
}
}
internal static void DisableIsapiFilter(ADOwaVirtualDirectory adOwaVirtualDirectory)
{
DirectoryEntry directoryEntry;
DirectoryEntry virtualDirectory = directoryEntry = IisUtility.CreateIISDirectoryEntry(adOwaVirtualDirectory.MetabasePath);
try
{
OwaIsapiFilter.UninstallIfLastVdir(virtualDirectory);
}
finally
{
if (directoryEntry != null)
{
((IDisposable)directoryEntry).Dispose();
}
}
}
protected override void ProcessMetabaseProperties(ExchangeVirtualDirectory dataObject)
{
TaskLogger.LogEnter();
base.ProcessMetabaseProperties(dataObject);
ADExchangeServiceVirtualDirectory adexchangeServiceVirtualDirectory = (ADExchangeServiceVirtualDirectory)dataObject;
try
{
DirectoryEntry directoryEntry2;
DirectoryEntry directoryEntry = directoryEntry2 = IisUtility.CreateIISDirectoryEntry(adexchangeServiceVirtualDirectory.MetabasePath, new Task.TaskErrorLoggingReThrowDelegate(this.WriteError), dataObject.Identity, false);
try
{
if (directoryEntry != null)
{
adexchangeServiceVirtualDirectory.BasicAuthentication = new bool?(IisUtility.CheckForAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.Basic));
adexchangeServiceVirtualDirectory.DigestAuthentication = new bool?(IisUtility.CheckForAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.Digest));
adexchangeServiceVirtualDirectory.WindowsAuthentication = new bool?(IisUtility.CheckForAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.Ntlm));
adexchangeServiceVirtualDirectory.LiveIdNegotiateAuthentication = new bool?(IisUtility.CheckForAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.LiveIdNegotiate));
adexchangeServiceVirtualDirectory.LiveIdBasicAuthentication = new bool?(adexchangeServiceVirtualDirectory.InternalAuthenticationMethods.Contains(AuthenticationMethod.LiveIdBasic));
adexchangeServiceVirtualDirectory.OAuthAuthentication = new bool?(adexchangeServiceVirtualDirectory.InternalAuthenticationMethods.Contains(AuthenticationMethod.OAuth));
adexchangeServiceVirtualDirectory.AdfsAuthentication = new bool?(adexchangeServiceVirtualDirectory.InternalAuthenticationMethods.Contains(AuthenticationMethod.Adfs));
adexchangeServiceVirtualDirectory.WSSecurityAuthentication = new bool?(adexchangeServiceVirtualDirectory.InternalAuthenticationMethods.Contains(AuthenticationMethod.WSSecurity) && IisUtility.CheckForAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.WSSecurity));
}
}
finally
{
if (directoryEntry2 != null)
{
((IDisposable)directoryEntry2).Dispose();
}
}
}
catch (Exception ex)
{
TaskLogger.Trace("Exception occurred: {0}", new object[]
{
ex.Message
});
base.WriteError(new LocalizedException(this.MetabaseGetPropertiesFailureMessage, ex), ErrorCategory.InvalidOperation, dataObject.Identity);
}
finally
{
TaskLogger.LogExit();
}
}
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;
}
}
}
public static void SetToMetabase(ADMobileVirtualDirectory adObject, Task task)
{
string metabasePath = adObject.MetabasePath;
using (DirectoryEntry directoryEntry = IisUtility.CreateIISDirectoryEntry(metabasePath))
{
ArrayList arrayList = new ArrayList();
int? num = (int?)directoryEntry.Properties["AccessSSLFlags"].Value;
if (num == null)
{
num = new int?(0);
}
if (adObject.ClientCertAuth == ClientCertAuthTypes.Ignore)
{
int num2 = 96;
num &= ~num2;
}
else if (adObject.ClientCertAuth == ClientCertAuthTypes.Required)
{
num |= 96;
}
else if (adObject.ClientCertAuth == ClientCertAuthTypes.Accepted)
{
num = ((num & -65) | 32);
}
else
{
int num3 = 96;
num &= ~num3;
}
MetabaseProperty value = new MetabaseProperty("AccessSSLFlags", num);
arrayList.Add(value);
IisUtility.SetAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.Basic, adObject.BasicAuthEnabled);
IisUtility.SetAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.WindowsIntegrated, adObject.WindowsAuthEnabled);
MetabaseProperty value2 = new MetabaseProperty("DoDynamicCompression", adObject.CompressionEnabled);
arrayList.Add(value2);
IisUtility.SetProperties(directoryEntry, arrayList);
directoryEntry.CommitChanges();
string vdirPath = string.Format("{0}/{1}", adObject.MetabasePath, "Proxy");
MobileSyncVirtualDirectoryHelper.UpdateSubDirectory(adObject, vdirPath, task);
IisUtility.CommitMetabaseChanges((adObject.Server == null) ? null : adObject.Server.ToString());
}
}
private void ProcessMetabaseProperties(ADPowerShellVirtualDirectory virtualDirectory)
{
try
{
using (DirectoryEntry directoryEntry = IisUtility.CreateIISDirectoryEntry(virtualDirectory.MetabasePath, new Task.TaskErrorLoggingReThrowDelegate(this.WriteError), virtualDirectory.Identity))
{
virtualDirectory.BasicAuthentication = new bool?(IisUtility.CheckForAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.Basic));
virtualDirectory.DigestAuthentication = new bool?(IisUtility.CheckForAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.Digest));
virtualDirectory.WindowsAuthentication = new bool?(IisUtility.CheckForAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.Ntlm));
virtualDirectory.CertificateAuthentication = new bool?(IisUtility.CheckForAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.Certificate));
virtualDirectory.LiveIdBasicAuthentication = new bool?(virtualDirectory.InternalAuthenticationMethods.Contains(AuthenticationMethod.LiveIdBasic));
virtualDirectory.WSSecurityAuthentication = new bool?(virtualDirectory.InternalAuthenticationMethods.Contains(AuthenticationMethod.WSSecurity) && IisUtility.CheckForAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.WSSecurity));
virtualDirectory.ResetChangeTracking();
}
}
catch (Exception ex)
{
base.WriteErrorAndMonitoringEvent(new CannotPopulateMetabaseInformationException(virtualDirectory.Name, ex.Message, ex), (ErrorCategory)1001, null, 1001, "MSExchange Monitoring PowerShellConnectivity Internal", true);
}
}
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);
}
}
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;
}
}
private void UpdateVDirScriptMaps()
{
TaskLogger.LogEnter();
using (DirectoryEntry directoryEntry = IisUtility.CreateIISDirectoryEntry(this.DataObject.MetabasePath, new Task.TaskErrorLoggingReThrowDelegate(this.WriteError), this.DataObject.Identity))
{
string[] array = new string[directoryEntry.Properties["ScriptMaps"].Count];
directoryEntry.Properties["ScriptMaps"].CopyTo(array, 0);
ExTraceGlobals.TaskTracer.Information((long)this.GetHashCode(), "UpdateVDirScriptMaps got ScriptMaps property");
int num = 0;
string[] array2 = array;
int i = 0;
while (i < array2.Length)
{
string text = array2[i];
if (text.StartsWith(".aspx", StringComparison.OrdinalIgnoreCase))
{
ExTraceGlobals.TaskTracer.Information <string>((long)this.GetHashCode(), "UpdateVDirScriptMaps found .aspx mapping: {0}", text);
if (text.IndexOf(",options", StringComparison.OrdinalIgnoreCase) >= 0)
{
ExTraceGlobals.TaskTracer.Information((long)this.GetHashCode(), "Leaving UpdateVDirScriptMaps without updating .aspx mapping.");
return;
}
string text2 = text + ",OPTIONS";
directoryEntry.Properties["ScriptMaps"][num] = text2;
ExTraceGlobals.TaskTracer.Information <string>((long)this.GetHashCode(), "UpdateVDirScriptMaps updated .aspx mapping to: {0}", text2);
break;
}
else
{
num++;
i++;
}
}
directoryEntry.CommitChanges();
IisUtility.CommitMetabaseChanges((base.OwningServer == null) ? null : base.OwningServer.Name);
ExTraceGlobals.TaskTracer.Information((long)this.GetHashCode(), "UpdateVDirScriptMaps committed mapping edit to vDir object.");
}
TaskLogger.LogExit();
}
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));
}
}
protected void InternalValidateBasicLiveIdBasic()
{
T dataObject = this.DataObject;
string metabasePath = dataObject.MetabasePath;
Task.TaskErrorLoggingReThrowDelegate writeError = new Task.TaskErrorLoggingReThrowDelegate(this.WriteError);
T dataObject2 = this.DataObject;
using (DirectoryEntry directoryEntry = IisUtility.CreateIISDirectoryEntry(metabasePath, writeError, dataObject2.Identity))
{
T dataObject3 = this.DataObject;
bool?basicAuthentication = dataObject3.BasicAuthentication;
T dataObject4 = this.DataObject;
bool?liveIdBasicAuthentication = dataObject4.LiveIdBasicAuthentication;
bool flag = IisUtility.CheckForAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.Basic);
bool flag2 = this.CheckLiveIdBasicAuthModule(false);
bool flag3 = basicAuthentication ?? flag;
bool flag4 = liveIdBasicAuthentication ?? flag2;
if (flag3 && flag4)
{
string format = "Enabling both Basic and LiveIdBasic Authentication is not allowed. Virtual directory '{0}' has Basic={1}, LiveIdBasic={2}";
object[] array = new object[3];
object[] array2 = array;
int num = 0;
T dataObject5 = this.DataObject;
array2[num] = dataObject5.MetabasePath;
array[1] = flag.ToString();
array[2] = flag2.ToString();
TaskLogger.Trace(format, array);
T dataObject6 = this.DataObject;
Exception exception = new LocalizedException(Strings.ErrorBasicAndLiveIdBasicNotAllowedVDir(dataObject6.MetabasePath, flag.ToString(), flag2.ToString()));
ErrorCategory category = ErrorCategory.InvalidOperation;
T dataObject7 = this.DataObject;
base.WriteError(exception, category, dataObject7.Identity);
}
}
}
protected void InternalValidateBasicLiveIdBasic()
{
T dataObject = this.DataObject;
string metabasePath = dataObject.MetabasePath;
Task.TaskErrorLoggingReThrowDelegate writeError = new Task.TaskErrorLoggingReThrowDelegate(this.WriteError);
T dataObject2 = this.DataObject;
using (IisUtility.CreateIISDirectoryEntry(metabasePath, writeError, dataObject2.Identity))
{
T dataObject3 = this.DataObject;
bool flag = dataObject3.BasicAuthentication ?? false;
T dataObject4 = this.DataObject;
bool flag2 = dataObject4.LiveIdBasicAuthentication ?? false;
if (flag && flag2)
{
TaskLogger.Trace("Enabling both Basic and LiveIdBasic Authentication is not allowed.", new object[0]);
Exception exception = new LocalizedException(Strings.ErrorBasicAndLiveIdBasicNotAllowed);
ErrorCategory category = ErrorCategory.InvalidOperation;
T dataObject5 = this.DataObject;
base.WriteError(exception, category, dataObject5.Identity);
}
}
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
base.InternalProcessRecord();
ServerIdParameter serverIdParameter = new ServerIdParameter();
Server server = (Server)base.GetDataObject <Server>(serverIdParameter, base.DataSession, null, new LocalizedString?(Strings.ErrorServerNotFound(serverIdParameter.ToString())), new LocalizedString?(Strings.ErrorServerNotUnique(serverIdParameter.ToString())));
if (!server.IsClientAccessServer && !server.IsCafeServer)
{
base.ThrowTerminatingError(server.GetServerRoleError(ServerRole.ClientAccess), ErrorCategory.InvalidOperation, server);
}
using (ServerManager serverManager = new ServerManager())
{
ApplicationPool applicationPool = serverManager.ApplicationPools["MSExchangeOWAAppPool"];
if (applicationPool == null)
{
base.ThrowTerminatingError(new ADNoSuchObjectException(Strings.ErrorOWAVdirAppPoolNotExist), ErrorCategory.ObjectNotFound, serverManager.ApplicationPools);
}
applicationPool.ManagedPipelineMode = 0;
serverManager.CommitChanges();
}
QueryFilter filter = new ComparisonFilter(ComparisonOperator.NotEqual, ADOwaVirtualDirectorySchema.OwaVersion, OwaVersions.Exchange2003or2000);
base.WriteVerbose(TaskVerboseStringHelper.GetFindDataObjectsVerboseString(base.DataSession, typeof(ADOwaVirtualDirectory), filter, server.Identity, true));
IConfigDataProvider dataSession = base.DataSession;
IEnumerable <ADOwaVirtualDirectory> enumerable = dataSession.FindPaged <ADOwaVirtualDirectory>(filter, server.Identity, true, null, 0);
foreach (ADOwaVirtualDirectory adowaVirtualDirectory in enumerable)
{
if (adowaVirtualDirectory.WebSite.Equals("Exchange Back End", StringComparison.OrdinalIgnoreCase))
{
string metabasePath = adowaVirtualDirectory.MetabasePath;
try
{
base.WriteVerbose(Strings.VerboseConnectingIISVDir(metabasePath));
using (IisUtility.CreateIISDirectoryEntry(metabasePath))
{
if (!DirectoryEntry.Exists(metabasePath))
{
this.WriteWarning(Strings.OwaAdOrphanFound(adowaVirtualDirectory.Identity.ToString()));
continue;
}
if (!IisUtility.WebDirObjectExists(metabasePath, this.owaVersion))
{
base.WriteVerbose(Strings.VerboseCreatingChildVDir(this.owaVersion, metabasePath));
CreateVirtualDirectory createVirtualDirectory = new CreateVirtualDirectory();
createVirtualDirectory.Name = this.owaVersion;
createVirtualDirectory.Parent = metabasePath;
createVirtualDirectory.CustomizedVDirProperties = OwaVirtualDirectoryHelper.GetVersionVDirProperties();
createVirtualDirectory.LocalPath = (string)IisUtility.GetIisPropertyValue("Path", createVirtualDirectory.CustomizedVDirProperties);
createVirtualDirectory.Initialize();
createVirtualDirectory.Execute();
}
}
OwaVirtualDirectoryHelper.CreateLegacyVDirs(metabasePath, true);
OwaVirtualDirectoryHelper.CreateOwaCalendarVDir(metabasePath, VirtualDirectoryRole.Mailbox);
if (ExchangeServiceVDirHelper.IsBackEndVirtualDirectory(adowaVirtualDirectory))
{
WebAppVirtualDirectoryHelper.UpdateMetabase(adowaVirtualDirectory, metabasePath, true);
}
}
catch (COMException ex)
{
base.WriteError(new IISGeneralCOMException(ex.Message, ex.ErrorCode, ex), ErrorCategory.InvalidOperation, null);
}
if (adowaVirtualDirectory.ExchangeVersion.IsOlderThan(adowaVirtualDirectory.MaximumSupportedExchangeObjectVersion))
{
try
{
adowaVirtualDirectory.SetExchangeVersion(adowaVirtualDirectory.MaximumSupportedExchangeObjectVersion);
base.DataSession.Save(adowaVirtualDirectory);
}
catch (DataSourceTransientException exception)
{
base.WriteError(exception, ErrorCategory.WriteError, null);
}
}
}
}
TaskLogger.LogExit();
}
