private static Stream GetStreamAttachmentStream(Attachment attachment)
{
StreamAttachmentBase streamAttachmentBase = attachment as StreamAttachmentBase;
if (streamAttachmentBase == null)
{
throw new ArgumentNullException("stream", "Attachment is not a stream attachment");
}
OleAttachment oleAttachment = streamAttachmentBase as OleAttachment;
Stream stream;
if (oleAttachment != null)
{
stream = oleAttachment.TryConvertToImage(ImageFormat.Jpeg);
if (stream == null)
{
stream = new MemoryStream();
}
}
else
{
stream = streamAttachmentBase.GetContentStream(PropertyOpenMode.ReadOnly);
}
return(stream);
}
private static void PopulateAttachmentProperties(IdAndSession idAndSession, Item item, Attachment attachment, ModernAttachment outAttachment)
{
if (outAttachment == null || attachment == null || item == null)
{
return;
}
outAttachment.Data = new ModernAttachment.AttachmentData();
outAttachment.Data.AttachmentEx = new AttachmentTypeEx();
switch (attachment.AttachmentType)
{
case AttachmentType.NoAttachment:
break;
case AttachmentType.Stream:
{
StreamAttachment streamAttachment = attachment as StreamAttachment;
if (streamAttachment != null)
{
FileAttachmentType fileAttachmentType = new FileAttachmentType();
outAttachment.Data.Attachment = fileAttachmentType;
fileAttachmentType.IsContactPhoto = streamAttachment.IsContactPhoto;
}
break;
}
case AttachmentType.EmbeddedMessage:
{
ItemAttachment itemAttachment = attachment as ItemAttachment;
if (itemAttachment != null)
{
outAttachment.Data.Attachment = new ItemAttachmentType();
}
break;
}
case AttachmentType.Ole:
{
OleAttachment oleAttachment = attachment as OleAttachment;
if (oleAttachment != null)
{
FileAttachmentType fileAttachmentType2 = new FileAttachmentType();
outAttachment.Data.Attachment = fileAttachmentType2;
fileAttachmentType2.IsContactPhoto = oleAttachment.IsContactPhoto;
}
break;
}
case AttachmentType.Reference:
{
ReferenceAttachment referenceAttachment = attachment as ReferenceAttachment;
if (referenceAttachment != null)
{
UserContext userContext = UserContextManager.GetUserContext(HttpContext.Current);
if (userContext != null && userContext.FeaturesManager != null && userContext.FeaturesManager.ClientServerSettings.AttachmentsFilePicker.Enabled)
{
ReferenceAttachmentType referenceAttachmentType = new ReferenceAttachmentType();
outAttachment.Data.Attachment = referenceAttachmentType;
referenceAttachmentType.AttachLongPathName = referenceAttachment.AttachLongPathName;
referenceAttachmentType.ProviderEndpointUrl = referenceAttachment.ProviderEndpointUrl;
referenceAttachmentType.ProviderType = referenceAttachment.ProviderType;
}
else
{
outAttachment.Data.Attachment = new FileAttachmentType();
}
}
break;
}
default:
return;
}
if (outAttachment.Data.Attachment == null)
{
outAttachment.Data.Attachment = new AttachmentType();
}
IdAndSession idAndSession2;
if (idAndSession == null)
{
idAndSession2 = new IdAndSession(item.Id, item.Session);
}
else
{
idAndSession2 = idAndSession.Clone();
}
idAndSession2.AttachmentIds.Add(attachment.Id);
outAttachment.Data.Attachment.AttachmentId = new AttachmentIdType(idAndSession2.GetConcatenatedId().Id);
outAttachment.Data.Attachment.ContentId = (string.IsNullOrEmpty(attachment.ContentId) ? null : attachment.ContentId);
outAttachment.Data.Attachment.ContentLocation = ((attachment.ContentLocation == null) ? null : attachment.ContentLocation.PathAndQuery);
outAttachment.Data.Attachment.ContentType = attachment.ContentType;
outAttachment.Data.Attachment.IsInline = attachment.IsInline;
outAttachment.Data.Attachment.LastModifiedTime = GetModernAttachmentsCommand.Utilities.FormatExDateTime(attachment.LastModifiedTime);
outAttachment.Data.Attachment.Name = attachment.DisplayName;
outAttachment.Data.Attachment.Size = (int)attachment.Size;
}
private static string GetAttachmentItself(Attachment attachment, Stream outStream, int offset, int count, out int total)
{
string text = string.Empty;
total = 0;
StreamAttachmentBase streamAttachmentBase = attachment as StreamAttachmentBase;
if (streamAttachmentBase != null)
{
OleAttachment oleAttachment = streamAttachmentBase as OleAttachment;
Stream stream = null;
try
{
if (oleAttachment != null)
{
stream = oleAttachment.TryConvertToImage(ImageFormat.Jpeg);
if (stream != null)
{
text = "image/jpeg";
}
}
if (stream == null)
{
stream = streamAttachmentBase.GetContentStream();
}
if (string.IsNullOrEmpty(text))
{
text = attachment.ContentType;
}
if (string.IsNullOrEmpty(text))
{
text = attachment.CalculatedContentType;
}
if (stream.Length > 0L)
{
if ((long)offset >= stream.Length)
{
throw new ArgumentOutOfRangeException("offset");
}
int num = (count == -1) ? ((int)stream.Length) : count;
if (num > GlobalSettings.MaxDocumentDataSize)
{
throw new DataTooLargeException(StatusCode.AttachmentIsTooLarge);
}
StreamHelper.CopyStream(stream, outStream, offset, num);
total = (int)stream.Length;
}
}
finally
{
if (stream != null)
{
stream.Dispose();
stream = null;
}
}
return(text);
}
ItemAttachment itemAttachment = attachment as ItemAttachment;
if (itemAttachment != null)
{
using (Item item = itemAttachment.GetItem(StoreObjectSchema.ContentConversionProperties))
{
text = "message/rfc822";
OutboundConversionOptions outboundConversionOptions = AirSyncUtility.GetOutboundConversionOptions();
using (AirSyncStream airSyncStream = new AirSyncStream())
{
try
{
ItemConversion.ConvertItemToMime(item, airSyncStream, outboundConversionOptions);
}
catch (ConversionFailedException innerException)
{
throw new FormatException(string.Format(CultureInfo.InvariantCulture, "MIME conversion failed for Attachment {0}!", new object[]
{
attachment
}), innerException);
}
if (airSyncStream.Length > 0L)
{
if ((long)offset >= airSyncStream.Length)
{
throw new ArgumentOutOfRangeException("offset");
}
int num2 = (count == -1) ? ((int)airSyncStream.Length) : count;
if (num2 > GlobalSettings.MaxDocumentDataSize)
{
throw new DataTooLargeException(StatusCode.AttachmentIsTooLarge);
}
StreamHelper.CopyStream(airSyncStream, outStream, offset, num2);
total = (int)airSyncStream.Length;
}
}
}
return(text);
}
throw new FormatException(string.Format(CultureInfo.InvariantCulture, "Attachment {0} is of invalid format!", new object[]
{
attachment
}));
}
// Token: 0x06000107 RID: 263 RVA: 0x000041B0 File Offset: 0x000023B0
public Stream GetAttachmentStream(AttachmentHandler.IAttachmentRetriever attachmentRetriever, AttachmentHandler.IAttachmentPolicyChecker policyChecker, bool asDataUri)
{
ExTraceGlobals.AttachmentHandlingTracer.TraceDebug <string>((long)this.GetHashCode(), "AttachmentHandler.GetAttachmentStream: Getting attachment stream for id={0}", this.id);
if (string.IsNullOrEmpty(this.id))
{
ExTraceGlobals.AttachmentHandlingTracer.TraceDebug((long)this.GetHashCode(), "Attachment id is empty or null. returning null stream.");
throw new FaultException("Id cannot be null or empty.");
}
Stream stream = null;
ByteEncoder byteEncoder = null;
Stream stream2 = null;
Stream result;
try
{
Attachment attachment = attachmentRetriever.Attachment;
AttachmentPolicyLevel policy = policyChecker.GetPolicy(attachment, this.webOperationContext.IsPublicLogon);
if (AudioFile.IsProtectedVoiceAttachment(attachment.FileName))
{
attachment.ContentType = Utils.GetUnProtectedVoiceAttachmentContentType(attachment.FileName);
stream = DRMUtils.OpenProtectedAttachment(attachment, this.callContext.AccessingADUser.OrganizationId);
string fileName;
if (AudioFile.TryGetNonDRMFileNameFromDRM(attachment.FileName, out fileName))
{
attachment.FileName = fileName;
}
}
string text = AttachmentUtilities.GetContentType(attachment);
string fileExtension = attachment.FileExtension;
OleAttachment oleAttachment = attachment as OleAttachment;
if (oleAttachment != null)
{
stream = oleAttachment.ConvertToImage(ImageFormat.Jpeg);
if (stream != null)
{
text = "image/jpeg";
}
}
if (this.IsBlocked(policy) && !attachment.IsInline && !this.IsImagePreview)
{
ExTraceGlobals.AttachmentHandlingTracer.TraceDebug <string>((long)this.GetHashCode(), "Attachment is blocked. Returning null stream. id is {0}", this.id);
result = null;
}
else
{
this.WriteResponseHeaders(text, policy, attachment);
if (stream == null)
{
StreamAttachment streamAttachment = attachment as StreamAttachment;
if (streamAttachment != null)
{
if (string.Equals(text, "audio/mpeg", StringComparison.OrdinalIgnoreCase))
{
stream = streamAttachment.GetContentStream(PropertyOpenMode.Modify);
}
else
{
stream = streamAttachment.GetContentStream(PropertyOpenMode.ReadOnly);
}
}
else
{
ItemAttachment itemAttachment = attachment as ItemAttachment;
if (itemAttachment != null)
{
using (Item item = itemAttachment.GetItem(StoreObjectSchema.ContentConversionProperties))
{
IRecipientSession adrecipientSession = item.Session.GetADRecipientSession(true, ConsistencyMode.IgnoreInvalid);
OutboundConversionOptions outboundConversionOptions = new OutboundConversionOptions(this.callContext.DefaultDomain.DomainName.Domain);
outboundConversionOptions.ClearCategories = false;
outboundConversionOptions.UserADSession = adrecipientSession;
outboundConversionOptions.LoadPerOrganizationCharsetDetectionOptions(adrecipientSession.SessionSettings.CurrentOrganizationId);
stream = new MemoryStream();
ItemConversion.ConvertItemToMime(item, stream, outboundConversionOptions);
stream.Seek(0L, SeekOrigin.Begin);
}
}
}
}
long num = 0L;
long num2 = 0L;
if (AttachmentUtilities.NeedToFilterHtml(text, fileExtension, policy, this.configurationContext))
{
stream = AttachmentUtilities.GetFilteredStream(this.configurationContext, stream, attachment.TextCharset, attachmentRetriever.BlockStatus);
}
else if (this.NeedToSendPartialContent(stream, out num, out num2))
{
string value = string.Format(CultureInfo.InvariantCulture, "bytes {0}-{1}/{2}", new object[]
{
num,
num2,
stream.Length
});
this.webOperationContext.Headers["Accept-Ranges"] = "bytes";
this.webOperationContext.Headers["Content-Range"] = value;
this.webOperationContext.ETag = this.id;
this.webOperationContext.StatusCode = HttpStatusCode.PartialContent;
long num3 = num2 - num + 1L;
if (num3 < stream.Length)
{
ExTraceGlobals.AttachmentHandlingTracer.TraceDebug <long, long, long>((long)this.GetHashCode(), "RangeBytes:{0} - Seek:{1} - SetLength:{2}", num3, num, num2 + 1L);
stream.Seek(num, SeekOrigin.Begin);
return(new BoundedStream(stream, true, num, num2));
}
}
if (asDataUri)
{
byteEncoder = new Base64Encoder();
stream2 = new EncoderStream(stream, byteEncoder, EncoderStreamAccess.Read);
stream = new DataUriStream(stream2, text);
}
result = stream;
}
}
catch (Exception ex)
{
if (stream != null)
{
stream.Dispose();
}
if (stream2 != null)
{
stream2.Dispose();
}
if (byteEncoder != null)
{
byteEncoder.Dispose();
}
string formatString = string.Empty;
if (ex is ExchangeDataException)
{
formatString = "Fail to sanitize HTML getting attachment. id is {0}, Exception: {1}";
}
else if (ex is StoragePermanentException)
{
formatString = "StoragePermanentException when getting attachment. id is {0}, Exception: {1}";
}
else
{
if (!(ex is StorageTransientException))
{
throw;
}
formatString = "StorageTransientException when getting attachment. id is {0}, Exception: {1}";
}
ExTraceGlobals.AttachmentHandlingTracer.TraceError <string, Exception>((long)this.GetHashCode(), formatString, this.id, ex);
throw new CannotOpenFileAttachmentException(ex);
}
return(result);
}
// Token: 0x06000721 RID: 1825 RVA: 0x00037E14 File Offset: 0x00036014
private bool GetIsInline(StreamAttachmentBase streamAttachment, AttachmentPolicy.Level level)
{
OleAttachment oleAttachment = streamAttachment as OleAttachment;
return(level == AttachmentPolicy.Level.Allow && (streamAttachment.IsInline || null != oleAttachment));
}
