// Token: 0x06000BA7 RID: 2983 RVA: 0x0002F860 File Offset: 0x0002DA60
protected override void ParseResponse(byte[] responseBuffer, int responseBufferSize)
{
ExtensionData extensionData = null;
try
{
extensionData = ExtensionData.ParseOsfManifest(responseBuffer, responseBufferSize, this.downloadRequestAsset.MarketplaceAssetID, this.downloadRequestAsset.MarketplaceContentMarket, ExtensionType.MarketPlace, this.downloadRequestAsset.Scope, this.downloadRequestAsset.Enabled, this.downloadRequestAsset.DisableReason, string.Empty, this.downloadRequestAsset.Etoken);
}
catch (OwaExtensionOperationException exception)
{
this.InternalFailureCallback(exception, null);
return;
}
base.LogResponseParsed();
this.successCallback(extensionData, this.uri);
}
private IConfigurable ReadManifest(Stream source, ExtensionType extensionType)
{
ExtensionData extensionData = ExtensionData.ParseOsfManifest(source, this.MarketplaceAssetID, this.MarketplaceQueryMarket, extensionType, this.OrganizationApp ? ExtensionInstallScope.Organization : ExtensionInstallScope.User, true, DisableReasonType.NotDisabled, string.Empty, null);
if (this.OrganizationApp)
{
return(new OrgApp(new DefaultStateForUser?(this.DefaultStateForUser), this.ProvidedTo, OrgApp.ConvertUserListToPresentationFormat(this, new DataAccessHelper.CategorizedGetDataObjectDelegate(base.GetDataObject <ADRecipient>), this.UserList), extensionData.MarketplaceAssetID, extensionData.MarketplaceContentMarket, extensionData.ProviderName, extensionData.IconURL, extensionData.ExtensionId, extensionData.VersionAsString, extensionData.Type, extensionData.Scope, extensionData.RequestedCapabilities, extensionData.DisplayName, extensionData.Description, this.Enabled, extensionData.Manifest.OuterXml, this.Etoken, null, extensionData.AppStatus, (this.adUser != null) ? this.adUser.Id : new ADObjectId())
{
IsDownloadOnly = this.DownloadOnly
});
}
if (!base.ExchangeRunspaceConfig.HasRoleOfType(RoleType.OrgMarketplaceApps) && !this.AllowReadWriteMailbox && RequestedCapabilities.ReadWriteMailbox == extensionData.RequestedCapabilities)
{
throw new OwaExtensionOperationException(Strings.ErrorReasonUserNotAllowedToInstallReadWriteMailbox);
}
return(new App(null, extensionData.MarketplaceAssetID, extensionData.MarketplaceContentMarket, extensionData.ProviderName, extensionData.IconURL, extensionData.ExtensionId, extensionData.VersionAsString, extensionData.Type, extensionData.Scope, extensionData.RequestedCapabilities, extensionData.DisplayName, extensionData.Description, this.Enabled, extensionData.Manifest.OuterXml, this.adUser.Id, this.Etoken, null, extensionData.AppStatus)
{
IsDownloadOnly = this.DownloadOnly
});
}
// Token: 0x06000BED RID: 3053 RVA: 0x00031178 File Offset: 0x0002F378
internal bool CacheSatisfiesRequest(UpdateRequestAsset requestAsset, List <ExtensionData> updates)
{
bool result = false;
ExtensionsCacheEntry extensionsCacheEntry = null;
if (this.extensionsCache.TryGetEntry(requestAsset.MarketplaceAssetID, out extensionsCacheEntry) && requestAsset.Version <= extensionsCacheEntry.Version && extensionsCacheEntry.Manifest != null)
{
if (requestAsset.ExtensionID != extensionsCacheEntry.ExtensionID)
{
GetUpdates.Tracer.TraceError <string, string, string>(0L, "GetUpdates.CacheSatisfiesRequest: Asset {0} extension ID {1} does not match the cache entry {2}", requestAsset.MarketplaceAssetID, requestAsset.ExtensionID, extensionsCacheEntry.ExtensionID);
ExtensionDiagnostics.Logger.LogEvent(ApplicationLogicEventLogConstants.Tuple_MismatchedCacheMailboxExtensionId, requestAsset.MarketplaceAssetID, new object[]
{
"ProcessUpdates",
this.GetLoggedMailboxIdentifier(),
requestAsset.MarketplaceAssetID,
requestAsset.ExtensionID,
extensionsCacheEntry.ExtensionID
});
result = true;
}
else if (requestAsset.Version == extensionsCacheEntry.Version)
{
GetUpdates.Tracer.TraceDebug <string>(0L, "GetUpdates.CacheSatisfiesRequest: Asset {0} version matches the cache entry", requestAsset.MarketplaceAssetID);
result = true;
}
else if (requestAsset.Version < extensionsCacheEntry.Version && extensionsCacheEntry.Manifest != null)
{
if (ExtensionData.CompareCapabilities(extensionsCacheEntry.RequestedCapabilities.Value, requestAsset.RequestedCapabilities) > 0)
{
GetUpdates.Tracer.TraceDebug <string, RequestedCapabilities, RequestedCapabilities>(0L, "GetUpdates.CacheSatisfiesRequest: Asset cache entry requires more capabilities than installed asset. Asset ID: {0} Update: {1} Installed: {2}", requestAsset.MarketplaceAssetID, extensionsCacheEntry.RequestedCapabilities.Value, requestAsset.RequestedCapabilities);
ExtensionDiagnostics.Logger.LogEvent(ApplicationLogicEventLogConstants.Tuple_MoreCapabilitiesSkipUpdate, requestAsset.MarketplaceAssetID, new object[]
{
"ProcessUpdates",
this.GetLoggedMailboxIdentifier(),
requestAsset.MarketplaceAssetID,
requestAsset.RequestedCapabilities,
extensionsCacheEntry.RequestedCapabilities.Value
});
result = true;
}
else if (!GetUpdates.IsValidUpdateState(new OmexConstants.AppState?(extensionsCacheEntry.State)))
{
GetUpdates.Tracer.TraceDebug <string, OmexConstants.AppState>(0L, "GetUpdates.CacheSatisfiesRequest: Asset {0} cache entry AppState {1} is not valid for updates", requestAsset.MarketplaceAssetID, extensionsCacheEntry.State);
ExtensionDiagnostics.Logger.LogEvent(ApplicationLogicEventLogConstants.Tuple_InvalidStateSkipUpdate, requestAsset.MarketplaceAssetID, new object[]
{
"ProcessUpdates",
this.GetLoggedMailboxIdentifier(),
requestAsset.MarketplaceAssetID,
extensionsCacheEntry.State
});
result = true;
}
else
{
GetUpdates.Tracer.TraceDebug <string>(0L, "GetUpdates.CacheSatisfiesRequest: Asset {0} will be updated from the cache", requestAsset.MarketplaceAssetID);
ExtensionData updatedExtension = null;
Exception ex = InstalledExtensionTable.RunClientExtensionAction(delegate
{
updatedExtension = ExtensionData.ParseOsfManifest(extensionsCacheEntry.Manifest, extensionsCacheEntry.Manifest.Length, requestAsset.MarketplaceAssetID, requestAsset.MarketplaceContentMarket, ExtensionType.MarketPlace, requestAsset.Scope, requestAsset.Enabled, requestAsset.DisableReason, string.Empty, requestAsset.Etoken);
});
if (ex == null)
{
updates.Add(updatedExtension);
result = true;
}
else
{
GetUpdates.Tracer.TraceError <string, Exception>(0L, "GetUpdates.CacheSatisfiesRequest: Parse of manifest failed for extension {0}. Exception: {1}", requestAsset.MarketplaceAssetID, ex);
ExtensionDiagnostics.Logger.LogEvent(ApplicationLogicEventLogConstants.Tuple_CachedManifestParseFailed, requestAsset.MarketplaceAssetID, new object[]
{
"ProcessUpdates",
requestAsset.MarketplaceAssetID,
ExtensionDiagnostics.GetLoggedExceptionString(ex)
});
}
}
}
}
return(result);
}
private static Dictionary <string, ExtensionData> ReadDefaultExtensionData(IExchangePrincipal exchangePrincipal)
{
Dictionary <string, ExtensionData> dictionary = new Dictionary <string, ExtensionData>();
string text = ExchangeSetupContext.InstallPath + "ClientAccess\\owa\\" + string.Format("\\prem\\{0}\\ext\\def\\", DefaultExtensionTable.GetInstalledOwaVersion());
string[] array = null;
try
{
if (!Directory.Exists(text))
{
DefaultExtensionTable.Tracer.TraceError <string>(0L, "Default extension path {0} does not exist", text);
ExtensionDiagnostics.Logger.LogEvent(ApplicationLogicEventLogConstants.Tuple_DefaultExtensionPathNotExist, null, new object[]
{
DefaultExtensionTable.scenario
});
return(dictionary);
}
array = Directory.GetDirectories(text);
}
catch (Exception ex)
{
DefaultExtensionTable.Tracer.TraceError <Exception>(0L, "Failed to access default extension folder. ", ex);
ExtensionDiagnostics.Logger.LogEvent(ApplicationLogicEventLogConstants.Tuple_DefaultExtensionFolderAccessFailed, ex.GetType().ToString(), new object[]
{
DefaultExtensionTable.scenario,
ExtensionDiagnostics.GetLoggedExceptionString(ex)
});
return(dictionary);
}
foreach (string text2 in array)
{
try
{
string path = text2 + "\\" + "manifest.xml";
if (File.Exists(path))
{
using (FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read))
{
ExtensionData extensionData = ExtensionData.ParseOsfManifest(fileStream, null, null, ExtensionType.Default, ExtensionInstallScope.Default, true, DisableReasonType.NotDisabled, string.Empty, null);
extensionData.ProvidedTo = ClientExtensionProvidedTo.Everyone;
extensionData.IsMandatory = false;
extensionData.IsEnabledByDefault = true;
extensionData.InstalledByVersion = ExchangeSetupContext.InstalledVersion;
if (exchangePrincipal != null)
{
Exception arg = null;
if (!DefaultExtensionTable.TryUpdateDefaultExtensionPath(exchangePrincipal, "SourceLocation", extensionData, out arg))
{
DefaultExtensionTable.Tracer.TraceError <Exception>(0L, "Skip one default extension because entry point path cannot be updated: {0}", arg);
goto IL_22D;
}
if (!DefaultExtensionTable.TryUpdateDefaultExtensionPath(exchangePrincipal, "IconUrl", extensionData, out arg))
{
DefaultExtensionTable.Tracer.TraceError <Exception>(0L, "Skip one default extension because icon path cannot be updated: {0}", arg);
goto IL_22D;
}
if (!DefaultExtensionTable.TryUpdateDefaultExtensionPath(exchangePrincipal, "HighResolutionIconUrl", extensionData, out arg))
{
DefaultExtensionTable.Tracer.TraceError <Exception>(0L, "Skip one default extension because hi-res icon path cannot be updated: {0}", arg);
goto IL_22D;
}
}
dictionary[ExtensionDataHelper.FormatExtensionId(extensionData.ExtensionId)] = extensionData;
}
}
}
catch (Exception ex2)
{
DefaultExtensionTable.Tracer.TraceError <Exception>(0L, "Skip one default extension because of error. {0}", ex2);
ExtensionDiagnostics.Logger.LogEvent(ApplicationLogicEventLogConstants.Tuple_DefaultExtensionRetrievalFailed, text2, new object[]
{
DefaultExtensionTable.scenario,
text2,
ExtensionDiagnostics.GetLoggedExceptionString(ex2)
});
}
IL_22D :;
}
return(dictionary);
}
