private Stream LoadAttachmentDocument(bool isLoadingStream, out RightsManagedMessageDecryptionStatus decryptionStatus)
        {
            decryptionStatus = RightsManagedMessageDecryptionStatus.Success;
            StringBuilder       stringBuilder     = new StringBuilder();
            List <AttachmentId> list              = new List <AttachmentId>();
            UserContext         userContext       = this.owaContext.UserContext;
            string           queryStringParameter = Utilities.GetQueryStringParameter(this.owaContext.HttpContext.Request, "ewsid", false);
            bool             flag = string.IsNullOrEmpty(queryStringParameter);
            OwaStoreObjectId owaStoreObjectId;
            string           text;

            if (!flag)
            {
                stringBuilder.Append("service.svc/s/GetFileAttachment?id=");
                stringBuilder.Append(Utilities.UrlEncode(queryStringParameter));
                string canary15CookieValue = Utilities.GetCanary15CookieValue();
                if (canary15CookieValue != null)
                {
                    stringBuilder.Append("&X-OWA-CANARY=" + canary15CookieValue);
                }
                IdHeaderInformation idHeaderInformation = ServiceIdConverter.ConvertFromConcatenatedId(queryStringParameter, BasicTypes.Attachment, list);
                owaStoreObjectId = OwaStoreObjectId.CreateFromMailboxItemId(idHeaderInformation.ToStoreObjectId());
                text             = owaStoreObjectId.ToString();
            }
            else
            {
                text             = Utilities.GetQueryStringParameter(this.owaContext.HttpContext.Request, "id");
                owaStoreObjectId = OwaStoreObjectId.CreateFromString(text);
                stringBuilder.Append("attachment.ashx?attach=1&id=");
                stringBuilder.Append(Utilities.UrlEncode(text));
            }
            Stream result;

            using (Item item = Utilities.GetItem <Item>(userContext, owaStoreObjectId, new PropertyDefinition[]
            {
                ItemSchema.SentRepresentingDisplayName,
                ItemSchema.Subject
            }))
            {
                if (!Utilities.IsPublic(item) && userContext.IsIrmEnabled && isLoadingStream)
                {
                    item.OpenAsReadWrite();
                }
                if (Utilities.IsIrmRestricted(item))
                {
                    if (!userContext.IsIrmEnabled || userContext.IsBasicExperience)
                    {
                        decryptionStatus = RightsManagedMessageDecryptionStatus.FeatureDisabled;
                        return(null);
                    }
                    RightsManagedMessageItem rightsManagedMessageItem = (RightsManagedMessageItem)item;
                    if (!rightsManagedMessageItem.CanDecode)
                    {
                        decryptionStatus = RightsManagedMessageDecryptionStatus.NotSupported;
                        return(null);
                    }
                    try
                    {
                        Utilities.IrmDecryptIfRestricted(item, userContext, true);
                    }
                    catch (RightsManagementPermanentException exception)
                    {
                        decryptionStatus = RightsManagedMessageDecryptionStatus.CreateFromException(exception);
                        return(null);
                    }
                    catch (RightsManagementTransientException exception2)
                    {
                        decryptionStatus = RightsManagedMessageDecryptionStatus.CreateFromException(exception2);
                        return(null);
                    }
                }
                this.messageFrom    = ItemUtility.GetProperty <string>(item, ItemSchema.SentRepresentingDisplayName, string.Empty);
                this.messageSubject = ItemUtility.GetProperty <string>(item, ItemSchema.Subject, string.Empty);
                this.messageId      = text;
                if (flag)
                {
                    Utilities.FillAttachmentIdList(item, this.owaContext.HttpContext.Request, list);
                }
                using (StreamAttachment streamAttachment = Utilities.GetAttachment(item, list, userContext) as StreamAttachment)
                {
                    if (streamAttachment == null)
                    {
                        throw new OwaInvalidRequestException("Attachment is not a stream attachment");
                    }
                    this.mimeType     = (streamAttachment.ContentType ?? streamAttachment.CalculatedContentType);
                    this.fileName     = ((!string.IsNullOrEmpty(streamAttachment.DisplayName)) ? streamAttachment.DisplayName : streamAttachment.FileName);
                    this.fileSize     = streamAttachment.Size;
                    this.documentPath = this.fileName;
                    this.documentIdStringBuilder.Append(Convert.ToBase64String(userContext.MailboxSession.MailboxOwner.MailboxInfo.GetDatabaseGuid().ToByteArray()));
                    this.documentIdStringBuilder.Append("-");
                    for (int i = 0; i < list.Count; i++)
                    {
                        this.documentIdStringBuilder.Append(list[i].ToBase64String());
                        this.documentIdStringBuilder.Append("-");
                        if (flag)
                        {
                            stringBuilder.Append("&attid");
                            stringBuilder.Append(i.ToString(CultureInfo.InstalledUICulture));
                            stringBuilder.Append("=");
                            stringBuilder.Append(Utilities.UrlEncode(list[i].ToBase64String()));
                        }
                    }
                    if (flag)
                    {
                        stringBuilder.Append("&attcnt=");
                        stringBuilder.Append(list.Count);
                    }
                    this.documentIdStringBuilder.Append(streamAttachment.LastModifiedTime.UtcTicks);
                    this.openLink = stringBuilder.ToString();
                    if (isLoadingStream)
                    {
                        Stream       contentStream = streamAttachment.GetContentStream();
                        MsoIpiResult msoIpiResult  = MsoIpiResult.Unknown;
                        try
                        {
                            msoIpiResult = ProtectorsManager.Instance.IsProtected(this.fileName, contentStream);
                        }
                        catch (AttachmentProtectionException exception3)
                        {
                            decryptionStatus = new RightsManagedMessageDecryptionStatus(RightsManagementFailureCode.CorruptData, exception3);
                            return(null);
                        }
                        if (msoIpiResult == MsoIpiResult.Protected)
                        {
                            this.isIrmProtected = true;
                            contentStream.Dispose();
                            if (!userContext.IsIrmEnabled || userContext.IsBasicExperience)
                            {
                                decryptionStatus = RightsManagedMessageDecryptionStatus.FeatureDisabled;
                                result           = null;
                            }
                            else
                            {
                                UseLicenseAndUsageRights useLicenseAndUsageRights;
                                bool   flag2;
                                Stream stream;
                                try
                                {
                                    stream = StreamAttachment.OpenRestrictedAttachment(streamAttachment, this.owaContext.ExchangePrincipal.MailboxInfo.OrganizationId, this.owaContext.ExchangePrincipal.MailboxInfo.PrimarySmtpAddress.ToString(), this.owaContext.LogonIdentity.UserSid, this.owaContext.ExchangePrincipal.RecipientTypeDetails, out useLicenseAndUsageRights, out flag2);
                                }
                                catch (RightsManagementPermanentException exception4)
                                {
                                    decryptionStatus = RightsManagedMessageDecryptionStatus.CreateFromException(exception4);
                                    return(null);
                                }
                                catch (RightsManagementTransientException exception5)
                                {
                                    decryptionStatus = RightsManagedMessageDecryptionStatus.CreateFromException(exception5);
                                    return(null);
                                }
                                if (flag2 && ObjectClass.IsMessage(item.ClassName, false) && !Utilities.IsIrmRestricted(item))
                                {
                                    object obj = item.TryGetProperty(MessageItemSchema.IsDraft);
                                    if (obj is bool && !(bool)obj && !DrmClientUtils.IsCachingOfLicenseDisabled(useLicenseAndUsageRights.UseLicense))
                                    {
                                        streamAttachment[AttachmentSchema.DRMRights]     = useLicenseAndUsageRights.UsageRights;
                                        streamAttachment[AttachmentSchema.DRMExpiryTime] = useLicenseAndUsageRights.ExpiryTime;
                                        using (Stream stream2 = streamAttachment.OpenPropertyStream(AttachmentSchema.DRMServerLicenseCompressed, PropertyOpenMode.Create))
                                        {
                                            DrmEmailCompression.CompressUseLicense(useLicenseAndUsageRights.UseLicense, stream2);
                                        }
                                        streamAttachment[AttachmentSchema.DRMPropsSignature] = useLicenseAndUsageRights.DRMPropsSignature;
                                        streamAttachment.Save();
                                        item.Save(SaveMode.ResolveConflicts);
                                    }
                                }
                                string      conversationOwnerFromPublishLicense = DrmClientUtils.GetConversationOwnerFromPublishLicense(useLicenseAndUsageRights.PublishingLicense);
                                RmsTemplate rmsTemplate = RmsTemplate.CreateFromPublishLicense(useLicenseAndUsageRights.PublishingLicense);
                                this.isPrintRestricted = !useLicenseAndUsageRights.UsageRights.IsUsageRightGranted(ContentRight.Print);
                                this.isCopyRestricted  = !useLicenseAndUsageRights.UsageRights.IsUsageRightGranted(ContentRight.Extract);
                                SanitizingStringBuilder <OwaHtml> sanitizingStringBuilder = new SanitizingStringBuilder <OwaHtml>();
                                string str = string.Format(LocalizedStrings.GetNonEncoded(-500320626), rmsTemplate.Name, rmsTemplate.Description);
                                sanitizingStringBuilder.Append(str);
                                if (!string.IsNullOrEmpty(conversationOwnerFromPublishLicense))
                                {
                                    sanitizingStringBuilder.Append("<br>");
                                    sanitizingStringBuilder.Append(string.Format(LocalizedStrings.GetNonEncoded(1670455506), conversationOwnerFromPublishLicense));
                                }
                                this.irmInfobarMessage = sanitizingStringBuilder.ToSanitizedString <SanitizedHtmlString>();
                                result = stream;
                            }
                        }
                        else
                        {
                            contentStream.Seek(0L, SeekOrigin.Begin);
                            result = contentStream;
                        }
                    }
                    else
                    {
                        result = null;
                    }
                }
            }
            return(result);
        }