private void UpdateIntegratedMetabase(ADOwaVirtualDirectory dataObject)
{
if (Datacenter.IsMultiTenancyEnabled())
{
base.WriteError(new TaskException(Strings.IntegratedVDirNotSupported), ErrorCategory.InvalidOperation, null);
return;
}
try
{
using (DirectoryEntry directoryEntry = IisUtility.FindWebDirObject(dataObject.MetabasePath, "Integrated"))
{
bool flag = false;
if (dataObject.IntegratedFeaturesEnabled != null && dataObject.IntegratedFeaturesEnabled != null)
{
flag = dataObject.IntegratedFeaturesEnabled.Value;
}
if (flag)
{
IisUtility.SetAuthenticationMethod(directoryEntry, MetabasePropertyTypes.AuthFlags.Ntlm, true);
}
else
{
IisUtility.SetAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.None, true);
this.WriteWarning(Strings.IntegratedVDirDisabledWarning);
}
directoryEntry.CommitChanges();
}
}
catch (WebObjectNotFoundException)
{
base.WriteError(new TaskException(Strings.IntegratedVDirNotFound), ErrorCategory.InvalidOperation, null);
}
}
private static void RemoveFilterFromLoadOrder(DirectoryEntry filterContainer, string name)
{
string text = (string)filterContainer.Properties["FilterLoadOrder"].Value;
if (text == null || text.Length == 0)
{
return;
}
StringBuilder stringBuilder = new StringBuilder();
string[] array = text.Split(new char[]
{
','
});
for (int i = 0; i < array.Length; i++)
{
if (string.Compare(array[i], name, true, CultureInfo.InvariantCulture) != 0)
{
stringBuilder.Append(array[i]);
stringBuilder.Append(",");
}
}
if (stringBuilder.Length > 0)
{
stringBuilder.Remove(stringBuilder.Length - 1, 1);
}
filterContainer.Properties["FilterLoadOrder"].Value = stringBuilder.ToString();
filterContainer.CommitChanges();
IisUtility.CommitMetabaseChanges(IisUtility.ServerFromWebSite(IisUtility.WebSiteFromMetabasePath(filterContainer.Path)));
}
internal static void UninstallIsapiFilter(ADMobileVirtualDirectory vdirObject)
{
using (DirectoryEntry directoryEntry = IisUtility.CreateIISDirectoryEntry(vdirObject.MetabasePath))
{
ActiveSyncIsapiFilter.Uninstall(directoryEntry);
}
}
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);
}
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);
}
private void buttonOK_Click(object sender, EventArgs e)
{
WebsiteName = textBox1.Text;
if (string.IsNullOrEmpty(WebsiteName))
{
MessageBox.Show(this, "Website name cannot be empty", Text, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
else
{
Regex rg = new Regex(@"^([\w])*$");
if (rg.IsMatch(WebsiteName))
{
bool iisError;
if (IisUtility.FindLocalWebSiteByName(this, WebsiteName, out iisError) != null)
{
if (!iisError)
{
MessageBox.Show(this, "The Website Name is in use", Text, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
else
{
this.DialogResult = DialogResult.OK;
}
}
else
{
MessageBox.Show(this, "Please use only alphanumeric characters in Website name", Text, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
}
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();
}
}
private void UpdateCalendarMetabase(ADOwaVirtualDirectory dataObject)
{
try
{
using (DirectoryEntry directoryEntry = IisUtility.FindWebDirObject(dataObject.MetabasePath, "Calendar"))
{
if (dataObject.AnonymousFeaturesEnabled == true)
{
IisUtility.SetAuthenticationMethod(directoryEntry, MetabasePropertyTypes.AuthFlags.Anonymous, true);
}
else
{
IisUtility.SetAuthenticationMethod(directoryEntry, AuthenticationMethodFlags.None, true);
}
directoryEntry.CommitChanges();
}
if (dataObject.AnonymousFeaturesEnabled == false)
{
this.WriteWarning(Strings.CalendarVDirDisabledWarning);
}
}
catch (WebObjectNotFoundException)
{
base.WriteError(new TaskException(Strings.CalendarVDirNotFound), ErrorCategory.InvalidOperation, null);
}
}
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 X509Certificate2 FindIisCertificate()
{
string webSiteSslCertificate = IisUtility.GetWebSiteSslCertificate("IIS://localhost/W3SVC/1");
if (string.IsNullOrEmpty(webSiteSslCertificate))
{
return(null);
}
X509Store x509Store = new X509Store(StoreName.My, StoreLocation.LocalMachine);
x509Store.Open(OpenFlags.ReadWrite | OpenFlags.OpenExistingOnly);
X509Certificate2Collection x509Certificate2Collection;
try
{
x509Certificate2Collection = x509Store.Certificates.Find(X509FindType.FindByThumbprint, webSiteSslCertificate, false);
}
finally
{
x509Store.Close();
}
if (x509Certificate2Collection.Count > 0)
{
return(x509Certificate2Collection[0]);
}
return(null);
}
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;
}
}
internal static void CreateLegacyVDirs(string metabasePath, bool deleteObjectIfExists)
{
string webSiteRoot = IisUtility.GetWebSiteRoot(metabasePath);
IList legacyVirtualDirectories = OwaVirtualDirectoryHelper.GetLegacyVirtualDirectories();
if (legacyVirtualDirectories != null)
{
ArrayList arrayList = new ArrayList();
arrayList.Add(new MetabaseProperty("HttpRedirect", "/owa"));
string localPath = Path.Combine(ConfigurationContext.Setup.InstallPath, "ClientAccess\\owa");
OwaVirtualDirectoryHelper.CreatedLegacyVDirs.Clear();
foreach (object obj in legacyVirtualDirectories)
{
string text = (string)obj;
if (deleteObjectIfExists && IisUtility.WebDirObjectExists(webSiteRoot, text))
{
IisUtility.DeleteWebDirObject(webSiteRoot, text);
}
CreateVirtualDirectory createVirtualDirectory = new CreateVirtualDirectory();
createVirtualDirectory.Name = text;
createVirtualDirectory.Parent = webSiteRoot;
createVirtualDirectory.LocalPath = localPath;
createVirtualDirectory.CustomizedVDirProperties = arrayList;
createVirtualDirectory.Initialize();
createVirtualDirectory.Execute();
OwaVirtualDirectoryHelper.CreatedLegacyVDirs.Add(text);
}
}
}
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);
}
}
private void UpdateCompressionSettings()
{
if (this.GzipLevel == GzipLevel.Error)
{
base.WriteError(new TaskException(Strings.GzipCannotBeSetToError), ErrorCategory.NotSpecified, null);
return;
}
if (this.GzipLevel == GzipLevel.Low)
{
this.WriteWarning(Strings.GzipLowDoesNotUseDynamicCompression);
}
string metabasePath = this.DataObject.MetabasePath;
Gzip.SetIisGzipLevel(IisUtility.WebSiteFromMetabasePath(metabasePath), GzipLevel.High);
Gzip.SetVirtualDirectoryGzipLevel(metabasePath, this.DataObject.GzipLevel);
if (Environment.OSVersion.Platform == PlatformID.Win32NT && Environment.OSVersion.Version.Major >= 6)
{
try
{
Gzip.SetIisGzipMimeTypes();
}
catch (Exception ex)
{
TaskLogger.Trace("Exception occurred in SetIisGzipMimeTypes(): {0}", new object[]
{
ex.Message
});
this.WriteWarning(Strings.SetIISGzipMimeTypesFailure);
throw;
}
}
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
try
{
using (IsapiExtensionList isapiExtensionList = new IsapiExtensionList(this.HostName))
{
for (int i = 0; i < this.ExtensionCount; i++)
{
IisWebServiceExtension iisWebServiceExtension = this[i];
List <int> list = isapiExtensionList.FindMatchingExtensions(this.GroupID, iisWebServiceExtension.ExecutableName);
for (int j = list.Count - 1; j >= 0; j--)
{
isapiExtensionList.RemoveAt(list[j]);
}
}
isapiExtensionList.CommitChanges();
IisUtility.CommitMetabaseChanges(this.HostName);
}
OwaIsapiFilter.RemoveFilters(this.HostName);
}
catch (IISNotInstalledException exception)
{
base.WriteError(exception, ErrorCategory.NotInstalled, this);
}
TaskLogger.LogExit();
}
internal static void InstallAuthModuleIsapiFilter(ADAutodiscoverVirtualDirectory vdirObject)
{
using (DirectoryEntry directoryEntry = IisUtility.CreateIISDirectoryEntry(vdirObject.MetabasePath))
{
AuthModuleIsapiFilter.Install(directoryEntry);
}
}
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);
}
internal static void SetStatus(string hostName, string groupID, string extensionBinary, bool allow)
{
using (IsapiExtensionList isapiExtensionList = new IsapiExtensionList(hostName))
{
List <int> list = isapiExtensionList.FindMatchingExtensions(groupID, extensionBinary);
if (list.Count == 0)
{
throw new ManageIsapiExtensionCouldNotFindExtensionException(groupID, extensionBinary);
}
if (list.Count != 1)
{
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < list.Count; i++)
{
stringBuilder.Append(isapiExtensionList[i].ToMetabaseString());
stringBuilder.Append("\r\n");
}
throw new ManageIsapiExtensionFoundMoreThanOneExtensionException(groupID, extensionBinary, stringBuilder.ToString());
}
IsapiExtension isapiExtension = isapiExtensionList[list[0]];
if (isapiExtension.Allow != allow)
{
isapiExtensionList[list[0]] = new IsapiExtension(isapiExtension.PhysicalPath, isapiExtension.GroupID, isapiExtension.Description, allow, isapiExtension.UIDeletable);
isapiExtensionList.CommitChanges();
IisUtility.CommitMetabaseChanges(hostName);
}
}
}
private void UpdateCompressionSettings()
{
if (base.Fields.IsModified("GzipLevel"))
{
string metabasePath = this.DataObject.MetabasePath;
Gzip.SetIisGzipLevel(IisUtility.WebSiteFromMetabasePath(metabasePath), GzipLevel.High);
Gzip.SetVirtualDirectoryGzipLevel(metabasePath, this.DataObject.GzipLevel);
if (Environment.OSVersion.Platform == PlatformID.Win32NT && Environment.OSVersion.Version.Major >= 6)
{
try
{
Gzip.SetIisGzipMimeTypes();
}
catch (Exception ex)
{
TaskLogger.Trace("Exception occurred in SetIisGzipMimeTypes(): {0}", new object[]
{
ex.Message
});
this.WriteWarning(Strings.SetIISGzipMimeTypesFailure);
throw;
}
}
}
}
public static VirtualWebDir CreateWebSite(LimnorProject project, string websitename, Form owner)
{
bool iisError = false;
VirtualWebDir webSite = project.GetTestWebSite(owner);
if (webSite == null)
{
webSite = IisUtility.FindLocalWebSiteByName(owner, websitename, out iisError);
}
if (webSite == null && !iisError)
{
webSite = IisUtility.FindLocalWebSite(websitename);
if (webSite == null)
{
//create the web site
DialogProjectOutput dlg = new DialogProjectOutput();
dlg.LoadData(project, websitename);
if (dlg.ShowDialog(owner) == DialogResult.OK)
{
if (dlg.WebSite != null)
{
webSite = dlg.WebSite;
}
}
}
}
return(webSite);
}
public override bool Verify()
{
TaskLogger.LogEnter();
bool result = IisUtility.IsSupportedIisVersion(this.ServerName);
TaskLogger.LogExit();
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 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);
}
}
}
}
}
}
}
}
}
}
}
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();
}
internal static void Uninstall(DirectoryEntry virtualDirectory, string filterName)
{
string iisserverName = IsapiFilterCommon.GetIISServerName(virtualDirectory);
string iislocalPath = IsapiFilterCommon.GetIISLocalPath(virtualDirectory);
string text = null;
string str = null;
string text2 = null;
IisUtility.ParseApplicationRootPath(iislocalPath, ref text, ref str, ref text2);
IsapiFilter.RemoveIsapiFilter("IIS://" + iisserverName + str, filterName);
}
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);
}
