internal static void RegisterCounters(string installationPath)
{
string filename = Path.Combine(installationPath, "Microsoft.Exchange.Diagnostics.Service.Common.EdsPerformanceCounters.xml");
SafeXmlDocument safeXmlDocument = new SafeXmlDocument();
safeXmlDocument.Load(filename);
string text = LoadEdsPerformanceCounters.ReadStringElement(safeXmlDocument, "Category/Name");
Logger.LogInformationMessage("Found performance counter category {0}", new object[]
{
text
});
if (!LoadEdsPerformanceCounters.SafeExists(text))
{
Logger.LogInformationMessage("Registering EDS performance counters.", new object[0]);
CounterCreationDataCollection counterCreationDataCollection = new CounterCreationDataCollection();
XmlNodeList xmlNodeList = safeXmlDocument.SelectNodes("Category/Counters/Counter");
using (xmlNodeList)
{
for (int i = 0; i < xmlNodeList.Count; i++)
{
string text2 = LoadEdsPerformanceCounters.ReadStringElement(xmlNodeList[i], "Name");
PerformanceCounterType counterType = (PerformanceCounterType)Enum.Parse(typeof(PerformanceCounterType), LoadEdsPerformanceCounters.ReadStringElement(xmlNodeList[i], "Type"), true);
counterCreationDataCollection.Add(new CounterCreationData(text2, string.Empty, counterType));
Logger.LogInformationMessage("Loaded counter {0}", new object[]
{
text2
});
}
}
LoadEdsPerformanceCounters.SafeCreate(text, counterCreationDataCollection);
return;
}
Logger.LogInformationMessage("Counters are already registered.", new object[0]);
}
void Sign(MemoryStream memoryStream)
{
memoryStream.Position = 0;
SafeXmlDocument document = new SafeXmlDocument();
document.PreserveWhitespace = true;
document.Load(memoryStream);
WSSecurityUtilityIdSignedXml signedXml = new WSSecurityUtilityIdSignedXml(document);
signedXml.SignedInfo.CanonicalizationMethod = SignedXml.XmlDsigExcC14NTransformUrl;
//signedXml.AddReference("/soap:Envelope/soap:Header/t:ExchangeImpersonation");
signedXml.AddReference("/soap:Envelope/soap:Header/wsse:Security/wsu:Timestamp");
signedXml.KeyInfo.AddClause(this.keyInfoNode);
{
signedXml.ComputeSignature(hashedAlgorithm);
}
XmlElement signature = signedXml.GetXml();
XmlNode wssecurityNode = document.SelectSingleNode(
"/soap:Envelope/soap:Header/wsse:Security",
WSSecurityBasedCredentials.NamespaceManager);
wssecurityNode.AppendChild(signature);
memoryStream.Position = 0;
document.Save(memoryStream);
}
private void LoadConfigFile(string configPath)
{
SafeXmlDocument safeXmlDocument = new SafeXmlDocument();
if (!File.Exists(configPath))
{
ReportingWebServiceEventLogConstants.Tuple_LoadReportingschemaFailed.LogEvent(new object[]
{
Strings.ErrorSchemaConfigurationFileMissing(configPath)
});
ServiceDiagnostics.ThrowError(ReportingErrorCode.ErrorSchemaInitializationFail, Strings.ErrorSchemaInitializationFail);
}
safeXmlDocument.Load(configPath);
try
{
Dictionary <string, ReportingSchema.ReportPropertyCmdletParamMapping[]> reportPropertyCmdletParamMapping = this.LoadRbacMapping(safeXmlDocument);
this.LoadEntityNodes(safeXmlDocument, reportPropertyCmdletParamMapping);
}
catch (ReportingSchema.SchemaLoadException ex)
{
ReportingWebServiceEventLogConstants.Tuple_LoadReportingschemaFailed.LogEvent(new object[]
{
ex.Message
});
ServiceDiagnostics.ThrowError(ReportingErrorCode.ErrorSchemaInitializationFail, Strings.ErrorSchemaInitializationFail, ex);
}
}
private void InitializeTuples()
{
string[] manifestResourceNames = Assembly.GetExecutingAssembly().GetManifestResourceNames();
foreach (string text in manifestResourceNames)
{
if (text.EndsWith("EventLog.xml"))
{
SafeXmlDocument safeXmlDocument = new SafeXmlDocument();
safeXmlDocument.Load(Assembly.GetExecutingAssembly().GetManifestResourceStream(text));
Dictionary <string, short> dictionary = new Dictionary <string, short>();
foreach (object obj in safeXmlDocument.SelectNodes("/root/category"))
{
XmlElement xmlElement = (XmlElement)obj;
string attribute = xmlElement.GetAttribute("name");
short value = short.Parse(xmlElement.SelectSingleNode("number").InnerText);
dictionary.Add(attribute, value);
}
foreach (object obj2 in safeXmlDocument.SelectNodes("/root/data"))
{
XmlElement xmlElement2 = (XmlElement)obj2;
string attribute2 = xmlElement2.GetAttribute("name");
uint eventId = (uint)Enum.Parse(typeof(MSExchangeDiagnosticsEventLogConstants.Message), attribute2);
string innerText = xmlElement2.SelectSingleNode("category").InnerText;
string innerText2 = xmlElement2.SelectSingleNode("stringvalue").InnerText;
short categoryId = dictionary[innerText];
string innerText3 = xmlElement2.SelectSingleNode("eventtype").InnerText;
string component = string.Empty;
XmlNode xmlNode = xmlElement2.SelectSingleNode("component");
if (xmlNode != null)
{
component = EventLogger.FormatString(xmlNode.InnerText);
}
string tag = string.Empty;
XmlNode xmlNode2 = xmlElement2.SelectSingleNode("tag");
if (xmlNode2 != null)
{
tag = EventLogger.FormatString(xmlNode2.InnerText);
}
string exception = string.Empty;
XmlNode xmlNode3 = xmlElement2.SelectSingleNode("exception");
if (xmlNode3 != null)
{
exception = EventLogger.FormatString(xmlNode3.InnerText);
}
EventLogEntryType enumValue = EventLogger.GetEnumValue <EventLogEntryType>(xmlElement2, "eventtype");
ExEventLog.EventLevel enumValue2 = EventLogger.GetEnumValue <ExEventLog.EventLevel>(xmlElement2, "level");
ExEventLog.EventPeriod enumValue3 = EventLogger.GetEnumValue <ExEventLog.EventPeriod>(xmlElement2, "period");
ExEventLog.EventTuple tuple = new ExEventLog.EventTuple(eventId, categoryId, enumValue, enumValue2, enumValue3);
this.tuples.Add(attribute2, new EventLogger.EventData(tuple, component, tag, exception));
string text2 = EventLogger.FormatString(innerText2);
if (!TriggerHandler.Triggers.ContainsKey(attribute2))
{
TriggerHandler.Triggers.Add(attribute2, new TriggerHandler.TriggerData(innerText3, text2));
}
}
}
}
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
string text = null;
try
{
string text2 = "Exchange-" + this.ShortNameForRole + ".xml";
string text3 = Path.Combine(ConfigurationContext.Setup.BinPath, text2);
string text4 = Path.Combine(ConfigurationContext.Setup.SetupLoggingPath, this.ShortNameForRole + "Prereqs.log");
string text5 = text3;
if (this.ADToolsNeeded)
{
SafeXmlDocument safeXmlDocument = new SafeXmlDocument();
safeXmlDocument.Load(text3);
XmlNode documentElement = safeXmlDocument.DocumentElement;
XmlElement xmlElement = safeXmlDocument.CreateElement("Feature", documentElement.NamespaceURI);
xmlElement.SetAttribute("Id", "RSAT-ADDS");
documentElement.AppendChild(xmlElement);
string text6 = Path.Combine(ConfigurationContext.Setup.SetupLoggingPath, "temp" + text2);
safeXmlDocument.Save(text6);
text5 = text6;
text = text6;
}
base.Args = string.Concat(new string[]
{
"-inputPath \"",
text5,
"\" -logPath \"",
text4,
"\""
});
base.InternalProcessRecord();
}
catch (IOException exception)
{
base.WriteError(exception, ErrorCategory.InvalidOperation, null);
}
catch (UnauthorizedAccessException exception2)
{
base.WriteError(exception2, ErrorCategory.SecurityError, null);
}
finally
{
if (text != null)
{
try
{
File.Delete(text);
}
catch
{
}
}
}
TaskLogger.LogExit();
}
/// <summary>
/// Helper to convert to xml dcouemnt from the current value.
/// </summary>
/// <param name="reader">the reader.</param>
/// <returns>The xml document</returns>
static SafeXmlDocument ReadToXmlDocument(EwsServiceXmlReader reader)
{
{
reader.ReadBase64ElementValue(stream);
stream.Position = 0;
SafeXmlDocument manifest = new SafeXmlDocument();
manifest.Load(stream);
return(manifest);
}
}
private bool UpdateSetting(string filePath)
{
Exception ex = null;
bool result = false;
try
{
SafeXmlDocument safeXmlDocument = new SafeXmlDocument();
safeXmlDocument.Load(filePath);
XmlNode documentElement = safeXmlDocument.DocumentElement;
if (documentElement == null)
{
TaskLogger.Trace("The aspnet.config file at {0} does not contain a root element. Skipping the file.", new object[]
{
filePath
});
return(result);
}
XmlNode xmlNode = documentElement.SelectSingleNode("descendant::runtime/legacyImpersonationPolicy");
if (xmlNode == null || xmlNode.Attributes == null || xmlNode.Attributes.Count <= 0)
{
TaskLogger.Trace("The aspnet.config file at {0} does not contain a valid legacyImpersonationPolicy setting. Skipping the file.", new object[]
{
filePath
});
return(result);
}
xmlNode.Attributes[0].Value = "false";
safeXmlDocument.Save(filePath);
TaskLogger.Trace("Successfully changed the legacyImpersonationPolicy setting to false in aspnet.config file at {0}.", new object[]
{
filePath
});
result = true;
}
catch (XPathException ex2)
{
ex = ex2;
}
catch (XmlException ex3)
{
ex = ex3;
}
if (ex != null)
{
TaskLogger.Trace("Failed to parse the aspnet.config file at {0}. Skipping the file. Exception: {1}.", new object[]
{
filePath,
ex
});
}
return(result);
}
private void LoadPublicAgents(string filePath, out List <AgentInfo> publicAgents)
{
int num = 20;
if (string.IsNullOrEmpty(filePath))
{
publicAgents = new List <AgentInfo>();
return;
}
for (;;)
{
XmlDocument xmlDocument = new SafeXmlDocument();
xmlDocument.Schemas = MExConfiguration.Schemas;
try
{
using (FileStream fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
xmlDocument.Load(fileStream);
xmlDocument.Validate(delegate(object sender, ValidationEventArgs args)
{
throw new ExchangeConfigurationException(MExRuntimeStrings.InvalidConfigurationFile(filePath), args.Exception);
});
this.LoadSettings(xmlDocument.SelectSingleNode("/configuration/mexRuntime/settings"));
this.LoadMonitoringOptions(xmlDocument.SelectSingleNode("/configuration/mexRuntime/monitoring"));
publicAgents = this.LoadAgentList(xmlDocument.SelectSingleNode("/configuration/mexRuntime/agentList"), false);
}
}
catch (XmlException innerException)
{
throw new ExchangeConfigurationException(MExRuntimeStrings.InvalidConfigurationFile(filePath), innerException);
}
catch (FormatException innerException2)
{
throw new ExchangeConfigurationException(MExRuntimeStrings.InvalidConfigurationFile(filePath), innerException2);
}
catch (UnauthorizedAccessException innerException3)
{
throw new ExchangeConfigurationException(MExRuntimeStrings.InvalidConfigurationFile(filePath), innerException3);
}
catch (IOException innerException4)
{
if (num <= 0)
{
throw new ExchangeConfigurationException(MExRuntimeStrings.InvalidConfigurationFile(filePath), innerException4);
}
num--;
Thread.Sleep(50);
continue;
}
break;
}
}
public XmlElement SerializeToXmlElement()
{
XmlDocument xmlDocument = new SafeXmlDocument();
using (MemoryStream memoryStream = new MemoryStream())
{
SafeXmlSerializer safeXmlSerializer = new SafeXmlSerializer(typeof(SharedFolderData));
safeXmlSerializer.Serialize(memoryStream, this);
memoryStream.Seek(0L, SeekOrigin.Begin);
xmlDocument.Load(memoryStream);
}
return(xmlDocument.DocumentElement);
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
try
{
string text = Path.Combine(Path.Combine(this.ExchangeInstallPath, this.XmlFileRelativePath), this.XmlFileName);
base.WriteVerbose(Strings.VerboseTaskParameters(this.ExchangeInstallPath, this.XmlFileRelativePath, text, this.XmlNodeNameToRemove));
SafeXmlDocument safeXmlDocument = new SafeXmlDocument();
safeXmlDocument.Load(text);
XmlNode xmlNode = safeXmlDocument.DocumentElement.SelectSingleNode(this.XmlNodeNameToRemove);
if (xmlNode != null)
{
safeXmlDocument.DocumentElement.RemoveChild(xmlNode);
safeXmlDocument.Save(text);
}
}
catch (XmlException exception)
{
base.WriteError(exception, ErrorCategory.InvalidOperation, null);
}
catch (XPathException exception2)
{
base.WriteError(exception2, ErrorCategory.InvalidOperation, null);
}
catch (IOException exception3)
{
base.WriteError(exception3, ErrorCategory.InvalidOperation, null);
}
catch (UnauthorizedAccessException exception4)
{
base.WriteError(exception4, ErrorCategory.InvalidOperation, null);
}
catch (NotSupportedException exception5)
{
base.WriteError(exception5, ErrorCategory.InvalidOperation, null);
}
catch (SecurityException exception6)
{
base.WriteError(exception6, ErrorCategory.InvalidOperation, null);
}
catch (ArgumentException exception7)
{
base.WriteError(exception7, ErrorCategory.InvalidArgument, null);
}
TaskLogger.LogExit();
}
public ObjectSchemaLoader(DataDrivenCategory dataDrivenCategory, string xPath, string schema)
{
Stream manifestResource = WinformsHelper.GetManifestResource(dataDrivenCategory);
SafeXmlDocument safeXmlDocument = new SafeXmlDocument();
safeXmlDocument.Load(manifestResource);
foreach (object obj in safeXmlDocument.SelectNodes(xPath))
{
XmlNode xmlNode = (XmlNode)obj;
XmlNode namedItem = xmlNode.Attributes.GetNamedItem("Name");
if (namedItem.Value.Equals(schema))
{
this.objectDefinition = xmlNode;
break;
}
}
}
private void LoadInternalAgents(out List <AgentInfo> preExecutionInternalAgents, out List <AgentInfo> postExecutionInternalAgents)
{
preExecutionInternalAgents = new List <AgentInfo>();
postExecutionInternalAgents = new List <AgentInfo>();
try
{
XmlDocument xmlDocument = new SafeXmlDocument();
xmlDocument.Schemas = MExConfiguration.InternalSchemas;
Assembly executingAssembly = Assembly.GetExecutingAssembly();
using (Stream manifestResourceStream = executingAssembly.GetManifestResourceStream("internalAgents.config"))
{
xmlDocument.Load(manifestResourceStream);
xmlDocument.Validate(delegate(object sender, ValidationEventArgs args)
{
throw new ExchangeConfigurationException(MExRuntimeStrings.InvalidConfigurationFile("internalAgents.config"), args.Exception);
});
string xmlMarkups = this.GetXmlMarkups(this.exchangeSku, this.transportProcessRole);
if (xmlMarkups != null)
{
preExecutionInternalAgents = this.LoadAgentList(xmlDocument.SelectSingleNode("/internalConfiguration/internalMexRuntime/" + xmlMarkups + "/preExecution"), true);
postExecutionInternalAgents = this.LoadAgentList(xmlDocument.SelectSingleNode("/internalConfiguration/internalMexRuntime/" + xmlMarkups + "/postExecution"), true);
}
}
}
catch (XmlException innerException)
{
throw new ExchangeConfigurationException(MExRuntimeStrings.InvalidConfigurationFile("internalAgents.config"), innerException);
}
catch (UnauthorizedAccessException innerException2)
{
throw new ExchangeConfigurationException(MExRuntimeStrings.InvalidConfigurationFile("internalAgents.config"), innerException2);
}
catch (IOException innerException3)
{
throw new ExchangeConfigurationException(MExRuntimeStrings.InvalidConfigurationFile("internalAgents.config"), innerException3);
}
}
private static Uri GetRootSiteUrlFromServiceInfo(AADClient aadClient)
{
string[] array = null;
try
{
array = aadClient.GetServiceInfo("SharePoint/");
}
catch (AADException arg)
{
SharePointUrl.Tracer.TraceError <AADException>(0L, "GetServiceInfo failed: {0}", arg);
}
if (array == null)
{
return(null);
}
foreach (string s in array)
{
using (StringReader stringReader = new StringReader(s))
{
try
{
XmlDocument xmlDocument = new SafeXmlDocument();
xmlDocument.Load(stringReader);
Uri rootSiteUrlFromServiceInfo = ServiceInfoParser.GetRootSiteUrlFromServiceInfo(xmlDocument, SharePointUrl.Tracer);
if (rootSiteUrlFromServiceInfo != null && !string.IsNullOrWhiteSpace(rootSiteUrlFromServiceInfo.ToString()))
{
return(rootSiteUrlFromServiceInfo);
}
}
catch (XmlException arg2)
{
SharePointUrl.Tracer.TraceError <XmlException>(0L, "Failed to get SPO_RootSiteUrl from ServiceInfo: {0}", arg2);
}
}
}
return(null);
}
// Token: 0x06000AF8 RID: 2808 RVA: 0x000474D0 File Offset: 0x000456D0
protected override void BuildSmsMessage()
{
string text = string.Empty;
base.BuildSmsMessage();
int num = base.RemainingChar;
if (num <= 0)
{
return;
}
try
{
string text2;
if (ObjectClass.IsOfClass(base.Item.ClassName, "IPM.Note.rpmsg.Microsoft.Voicemail.UM.CA") || ObjectClass.IsOfClass(base.Item.ClassName, "IPM.Note.rpmsg.Microsoft.Voicemail.UM"))
{
text2 = Strings.SMSProtectedVoicemail.ToString(base.GetMailboxCulture());
}
else
{
using (Stream stream = base.Item.OpenPropertyStream(MessageItemSchema.AsrData, PropertyOpenMode.ReadOnly))
{
using (StreamReader streamReader = new StreamReader(stream, Encoding.UTF8))
{
XmlDocument xmlDocument = new SafeXmlDocument();
xmlDocument.Load(streamReader);
XmlNode documentElement = xmlDocument.DocumentElement;
float transcriptionConfidence = SmsVoicemailNotification.GetTranscriptionConfidence(documentElement);
text2 = ((transcriptionConfidence > 0.3f) ? this.RenderVoiceMailPreview(documentElement) : Strings.SMSLowConfidenceTranscription.ToString(base.GetMailboxCulture()));
ExTraceGlobals.MWITracer.TraceDebug <float, string>((long)this.GetHashCode(), "Confidence: {0}. Text: {1}", transcriptionConfidence, text2);
}
}
}
num--;
if (text2.Length > num)
{
num -= "...".Length;
if (num > 0)
{
text = " ";
text += text2.Substring(0, num);
text += "...";
}
}
else
{
text = " ";
text += text2;
}
base.Body += text;
}
catch (ObjectNotFoundException ex)
{
ExTraceGlobals.MWITracer.TraceDebug <string>((long)this.GetHashCode(), "ObjectNotFoundException occured while trying to add EVM Text to the SMS. Exception: {0}", ex.Message);
}
catch (IOException ex2)
{
ExTraceGlobals.MWITracer.TraceDebug <string>((long)this.GetHashCode(), "IOException occured while trying to add EVM Text to the SMS. Exception: {0}", ex2.Message);
}
catch (XmlException ex3)
{
ExTraceGlobals.MWITracer.TraceDebug <string>((long)this.GetHashCode(), "XmlException occured while trying to add EVM Text to the SMS. Exception: {0}", ex3.Message);
}
}
internal void Load(Dictionary <string, StoreDriverParameterHandler> keyHandlerCollection)
{
if (keyHandlerCollection == null)
{
return;
}
Assembly executingAssembly = Assembly.GetExecutingAssembly();
string text = Path.Combine(Path.GetDirectoryName(executingAssembly.Location), "StoreDriver.config");
if (!File.Exists(text))
{
StoreDriverParameters.diag.TraceError <string>(0L, "The config file {0} does not exist.", text);
return;
}
XmlSchemaSet xmlSchemaSet = new XmlSchemaSet();
try
{
using (Stream manifestResourceStream = executingAssembly.GetManifestResourceStream("StoreDriverParameters.xsd"))
{
if (manifestResourceStream == null)
{
StoreDriverParameters.diag.TraceDebug <string>(0L, "The schema resource {0} does not exist.", "StoreDriverParameters.xsd");
return;
}
xmlSchemaSet.Add(null, SafeXmlFactory.CreateSafeXmlTextReader(manifestResourceStream));
}
}
catch (FileLoadException arg)
{
StoreDriverParameters.diag.TraceError <string, FileLoadException>(0L, "Failed to load the manifest resource stream {0}. Error {1}", "StoreDriverParameters.xsd", arg);
return;
}
catch (FileNotFoundException arg2)
{
StoreDriverParameters.diag.TraceError <string, FileNotFoundException>(0L, "Failed to find the manifest resource stream {0}.Error: {1}", text, arg2);
return;
}
Exception ex = null;
try
{
xmlSchemaSet.Compile();
XmlDocument xmlDocument = new SafeXmlDocument();
xmlDocument.Schemas = xmlSchemaSet;
using (FileStream fileStream = new FileStream(text, FileMode.Open, FileAccess.Read, FileShare.Read))
{
xmlDocument.Load(fileStream);
XmlNodeList xmlNodeList = xmlDocument.SelectNodes("/configuration/storeDriver/parameters/add");
foreach (object obj in xmlNodeList)
{
XmlNode xmlNode = (XmlNode)obj;
if (xmlNode != null && xmlNode is XmlElement)
{
this.currentNodeValid = true;
xmlDocument.Validate(delegate(object sender, ValidationEventArgs args)
{
StoreDriverParameters.diag.TraceDebug <string>(0L, "The parameter or value is invalid: {0}.", args.Message);
this.currentNodeValid = false;
}, xmlNode);
if (this.currentNodeValid)
{
string value = xmlNode.Attributes.GetNamedItem("key").Value;
string value2 = xmlNode.Attributes.GetNamedItem("value").Value;
if (value != null && value2 != null && keyHandlerCollection.ContainsKey(value))
{
keyHandlerCollection[value](value, value2);
}
}
}
}
}
}
catch (XmlSchemaException ex2)
{
ex = ex2;
}
catch (SecurityException ex3)
{
ex = ex3;
}
catch (IOException ex4)
{
ex = ex4;
}
catch (XmlException ex5)
{
ex = ex5;
}
catch (XPathException ex6)
{
ex = ex6;
}
if (ex != null)
{
StoreDriverParameters.diag.TraceError <Exception>(0L, "Failed to load parameters from storedriver config. Will use default values. Error: {0}", ex);
}
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
SafeXmlDocument safeXmlDocument = new SafeXmlDocument();
try
{
int num = 0;
try
{
IL_0D:
safeXmlDocument.Load(this.ConfigFileFullPath);
XmlElement xmlElement = this.FindOrCreateElement(safeXmlDocument, base.ParameterSetName != "Remove");
if (xmlElement == null)
{
if (base.ParameterSetName == "Remove")
{
this.WriteWarning(Strings.ElementNotFound(this.Element));
}
return;
}
string parameterSetName;
if ((parameterSetName = base.ParameterSetName) != null)
{
if (parameterSetName == "AppSettingKey")
{
this.AddAppSettingEntry(xmlElement);
goto IL_F3;
}
if (parameterSetName == "Attribute")
{
this.AddAttribute(xmlElement);
goto IL_F3;
}
if (parameterSetName == "ListValues")
{
this.AddListValues(xmlElement);
goto IL_F3;
}
if (parameterSetName == "Remove")
{
this.RemoveElementOrAppSettingEntry(xmlElement);
goto IL_F3;
}
if (parameterSetName == "XmlNode")
{
this.SetXmlNode(safeXmlDocument, xmlElement);
goto IL_F3;
}
}
base.WriteError(new InvalidOperationException("invalid parameter set name"), (ErrorCategory)1003, null);
IL_F3:
safeXmlDocument.Save(this.ConfigFileFullPath);
}
catch (IOException exception)
{
num++;
if (num > 3)
{
base.WriteError(exception, (ErrorCategory)1003, null);
}
else
{
this.WriteWarning(Strings.AppConfigIOException(this.ConfigFileFullPath, 3, 3));
Thread.Sleep(3000);
}
goto IL_0D;
}
}
catch (XmlException exception2)
{
base.WriteError(exception2, (ErrorCategory)1003, null);
}
catch (ArgumentException exception3)
{
base.WriteError(exception3, (ErrorCategory)1003, null);
}
catch (UnauthorizedAccessException exception4)
{
base.WriteError(exception4, (ErrorCategory)1003, null);
}
catch (NotSupportedException exception5)
{
base.WriteError(exception5, (ErrorCategory)1003, null);
}
catch (SecurityException exception6)
{
base.WriteError(exception6, (ErrorCategory)1003, null);
}
TaskLogger.LogExit();
}
// Token: 0x06000BB5 RID: 2997 RVA: 0x0002FB58 File Offset: 0x0002DD58
protected override void ParseResponse(byte[] responseBuffer, int responseBufferSize)
{
Dictionary <string, string> dictionary = new Dictionary <string, string>();
Dictionary <string, string> dictionary2 = new Dictionary <string, string>();
try
{
using (MemoryStream memoryStream = new MemoryStream(responseBuffer, 0, responseBuffer.Length))
{
SafeXmlDocument safeXmlDocument = new SafeXmlDocument();
safeXmlDocument.PreserveWhitespace = true;
safeXmlDocument.Load(memoryStream);
XmlNamespaceManager xmlNamespaceManager = new XmlNamespaceManager(safeXmlDocument.NameTable);
xmlNamespaceManager.AddNamespace("o", "urn:schemas-microsoft-com:office:office");
XmlNodeList xmlNodeList = safeXmlDocument.SelectNodes("/o:assets/o:asset", xmlNamespaceManager);
foreach (object obj in xmlNodeList)
{
XmlNode xmlNode = (XmlNode)obj;
string attributeStringValue = ExtensionData.GetAttributeStringValue(xmlNode, "o:cm");
string attributeStringValue2 = ExtensionData.GetAttributeStringValue(xmlNode, "o:assetid");
string value = HttpUtility.UrlEncode(HttpUtility.HtmlDecode(ExtensionData.GetAttributeStringValue(xmlNode, "o:etok")));
bool flag = false;
string optionalAttributeStringValue = ExtensionData.GetOptionalAttributeStringValue(xmlNode, "o:status", string.Empty);
foreach (TokenRenewRequestAsset tokenRenewRequestAsset in this.extensionTokenRenewList)
{
if (string.Equals(tokenRenewRequestAsset.MarketplaceAssetID, attributeStringValue2, StringComparison.OrdinalIgnoreCase) && string.Equals(tokenRenewRequestAsset.MarketplaceContentMarket, attributeStringValue, StringComparison.OrdinalIgnoreCase))
{
tokenRenewRequestAsset.IsResponseFound = true;
if ("1".Equals(optionalAttributeStringValue, StringComparison.OrdinalIgnoreCase))
{
dictionary.Add(tokenRenewRequestAsset.ExtensionID, value);
}
else if ("6".Equals(optionalAttributeStringValue, StringComparison.OrdinalIgnoreCase))
{
dictionary2.Add(tokenRenewRequestAsset.ExtensionID, "2.1");
}
else
{
dictionary2.Add(tokenRenewRequestAsset.ExtensionID, "2.0");
}
flag = true;
break;
}
}
if (!flag)
{
BaseAsyncCommand.Tracer.TraceError <string, string, string>(0L, "The returned token does not match the asset and marketplace in the request. Asset id: {0} Marketplace: {1} Status code: {2}.", attributeStringValue2, attributeStringValue, optionalAttributeStringValue);
ExtensionDiagnostics.Logger.LogEvent(ApplicationLogicEventLogConstants.Tuple_MismatchedReturnedToken, attributeStringValue2, new object[]
{
this.scenario,
this.requestId,
base.GetLoggedMailboxIdentifier(),
attributeStringValue2,
attributeStringValue,
optionalAttributeStringValue
});
}
}
foreach (TokenRenewRequestAsset tokenRenewRequestAsset2 in this.extensionTokenRenewList)
{
if (!tokenRenewRequestAsset2.IsResponseFound)
{
dictionary2.Add(tokenRenewRequestAsset2.ExtensionID, "2.0");
}
}
}
}
catch (XmlException exception)
{
this.InternalFailureCallback(exception, null);
return;
}
base.LogResponseParsed();
this.successCallback(dictionary, dictionary2);
}
