// Token: 0x06002914 RID: 10516 RVA: 0x000E8774 File Offset: 0x000E6974
protected void RenderMime()
{
OutboundConversionOptions outboundConversionOptions = Utilities.CreateOutboundConversionOptions(base.UserContext);
outboundConversionOptions.AllowPartialStnefConversion = true;
outboundConversionOptions.DemoteBcc = true;
try
{
ItemConversion.ConvertItemToMime(base.Item, base.Response.OutputStream, outboundConversionOptions);
}
catch (NotSupportedException innerException)
{
throw new OwaInvalidRequestException("Conversion failed", innerException);
}
catch (NotImplementedException innerException2)
{
throw new OwaInvalidRequestException("Conversion failed", innerException2);
}
catch (StoragePermanentException innerException3)
{
throw new OwaInvalidRequestException("Conversion failed", innerException3);
}
catch (StorageTransientException innerException4)
{
throw new OwaInvalidRequestException("Conversion failed", innerException4);
}
}
// Token: 0x06001C33 RID: 7219 RVA: 0x0006FF24 File Offset: 0x0006E124
protected override string InternalExecute()
{
IdAndSession idAndSession = base.IdConverter.ConvertItemIdToIdAndSessionReadOnly(this.itemId);
MessageItem messageItem = Item.BindAsMessage(idAndSession.Session, idAndSession.Id);
messageItem.Load(StoreObjectSchema.ContentConversionProperties);
OutboundConversionOptions outboundConversionOptions = new OutboundConversionOptions(base.CallContext.DefaultDomain.DomainName.ToString());
UserContext userContext = UserContextManager.GetUserContext(base.CallContext.HttpContext);
outboundConversionOptions.UserADSession = UserContextUtilities.CreateADRecipientSession(base.CallContext.ClientCulture.LCID, true, ConsistencyMode.IgnoreInvalid, false, userContext, true, base.CallContext.Budget);
outboundConversionOptions.LoadPerOrganizationCharsetDetectionOptions(userContext.ExchangePrincipal.MailboxInfo.OrganizationId);
outboundConversionOptions.AllowPartialStnefConversion = true;
outboundConversionOptions.DemoteBcc = true;
string @string;
using (MemoryStream memoryStream = new MemoryStream())
{
ItemConversion.ConvertItemToMime(messageItem, memoryStream, outboundConversionOptions);
memoryStream.Position = 0L;
byte[] array = new byte[memoryStream.Length];
memoryStream.Read(array, 0, array.Length);
@string = Encoding.ASCII.GetString(array);
}
return(@string);
}
public FileInfo LogItem(Item item, out string result)
{
result = null;
try
{
if (item != null)
{
FileInfo fileInfo = new FileInfo(this.GetFullFileName(item));
if (fileInfo.Exists)
{
return(fileInfo);
}
if (!fileInfo.Directory.Exists)
{
fileInfo.Directory.Create();
}
using (Stream stream = fileInfo.Open(FileMode.CreateNew, FileAccess.ReadWrite))
{
item.Load(StoreObjectSchema.ContentConversionProperties);
ItemConversion.ConvertItemToMsgStorage(item, stream, this.OutboundConversionOptions);
}
return(fileInfo);
}
}
catch (ConversionFailedException ex)
{
result = string.Format("{0} {1}", ex.Message, item.Id.ToBase64String());
}
return(null);
}
protected override byte[] MessageSaveChanges(StorageFxProxyPool.MessageEntry entry)
{
CoreItem referencedObject = entry.WrappedObject.ReferenceCoreItem.ReferencedObject;
if (entry.MimeStream != null || entry.CachedItemProperties.Count > 0)
{
using (Item item = new Item(referencedObject, true))
{
if (entry.MimeStream != null)
{
InboundConversionOptions scopedInboundConversionOptions = MapiUtils.GetScopedInboundConversionOptions(this.destMailbox.StoreSession.GetADRecipientSession(true, ConsistencyMode.IgnoreInvalid));
using (entry.MimeStream)
{
ItemConversion.ConvertAnyMimeToItem(item, entry.MimeStream, scopedInboundConversionOptions);
}
}
foreach (ItemPropertiesBase itemPropertiesBase in entry.CachedItemProperties)
{
itemPropertiesBase.Apply((MailboxSession)this.destMailbox.StoreSession, item);
}
}
}
if (entry.CachedPropValues.Count > 0)
{
this.SetProps(entry.WrappedObject.PropertyBag, entry.CachedPropValues.ToArray());
}
entry.WrappedObject.Save();
referencedObject.PropertyBag.Load(StorageFxProxyPool.EntryIdPropDef);
return(referencedObject.PropertyBag[StorageFxProxyPool.EntryIdPropDef[0]] as byte[]);
}
// Token: 0x06000620 RID: 1568 RVA: 0x00030A78 File Offset: 0x0002EC78
public static void RenderReadBody(TextWriter output, Item item, OwaSafeHtmlCallbackBase callBack, bool isJunkOrPhishing)
{
if (output == null)
{
throw new ArgumentNullException("output");
}
if (item == null)
{
return;
}
ReportMessage reportMessage = item as ReportMessage;
bool flag = null != reportMessage;
if (Utilities.IsOpaqueSigned(item))
{
MessageItem messageItem = item as MessageItem;
Item item2 = null;
if (messageItem != null && ItemConversion.TryOpenSMimeContent(messageItem, OwaContext.Current.UserContext.Configuration.DefaultAcceptedDomain.Name, out item2))
{
item = item2;
}
}
if (item.Body == null || (flag && item.Body.Size <= 0L))
{
if (flag)
{
using (MemoryStream memoryStream = new MemoryStream())
{
Charset charset;
reportMessage.GenerateReportBody(memoryStream, out charset);
item.OpenAsReadWrite();
BodyWriteConfiguration configuration = new BodyWriteConfiguration(BodyFormat.TextHtml, charset.Name);
using (Stream stream = item.Body.OpenWriteStream(configuration))
{
memoryStream.Position = 0L;
memoryStream.WriteTo(stream);
}
goto IL_DC;
}
}
return;
}
IL_DC:
Body body = item.Body;
if (!OwaContext.Current.UserContext.IsBasicExperience && OwaContext.Current.UserContext.IsIrmEnabled && Utilities.IsIrmRestrictedAndDecrypted(item))
{
body = ((RightsManagedMessageItem)item).ProtectedBody;
}
if (body.Size > 0L)
{
Markup markup = Markup.Html;
if (isJunkOrPhishing)
{
markup = Markup.PlainText;
}
BodyConversionUtilities.ConvertAndOutputBody(output, body, markup, callBack, false);
}
}
internal void DisperseSeeds()
{
if (!m_nview ||
!m_nview.IsOwner() ||
!m_nview.IsValid() ||
Player.m_localPlayer == null)
{
return;
}
bool dispersed = false;
int totalPlaced = 0;
int maxRetries = configMaxRetries.Value;
while (GetQueueSize() > 0)
{
string currentSeed = GetQueuedSeed();
int currentCount = GetQueuedSeedCount();
if (!seedPrefabMap.ContainsKey(currentSeed))
{
logger.LogWarning("Key '" + currentSeed + "' not found in seedPrefabMap");
DumpQueueDetails();
logger.LogWarning("Shifting queue to remove invalid entry");
ShiftQueueDown();
return;
}
ItemConversion conversion = seedPrefabMap[currentSeed];
PlacementStatus status = TryPlacePlant(conversion, maxRetries);
SetStatus(status);
if (status == PlacementStatus.Planting)
{
totalPlaced += 1;
dispersed = true;
}
else if (status == PlacementStatus.WrongBiome)
{
logger.LogDebug("Wrong biome deteced, moving " + currentSeed + " to end of queue");
MoveToEndOfQueue(currentSeed, currentCount, status);
break;
}
else if (status == PlacementStatus.NoRoom)
{
break;
}
if (totalPlaced >= configDispersionCount.Value)
{
break;
}
}
;
if (dispersed)
{
m_disperseEffects.Create(transform.position, Quaternion.Euler(0f, Random.Range(0, 360), 0f), transform, configRadius.Value / 5f);
}
}
private bool TryGenerateMessageFromMsgFileData(string defaultDomain)
{
bool result;
using (Stream stream = new MemoryStream(this.MessageFileData))
{
using (MessageItem messageItem = MessageItem.CreateInMemory(StoreObjectSchema.ContentConversionProperties))
{
using (Stream stream2 = new MemoryStream())
{
try
{
InboundConversionOptions inboundConversionOptions = new InboundConversionOptions(defaultDomain);
inboundConversionOptions.UserADSession = this.GetRecipientSession();
OutboundConversionOptions outboundConversionOptions = new OutboundConversionOptions(defaultDomain);
outboundConversionOptions.UserADSession = inboundConversionOptions.UserADSession;
ItemConversion.ConvertMsgStorageToItem(stream, messageItem, inboundConversionOptions);
if (this.WasSpecifiedByUser("Sender"))
{
SmtpAddress sender = this.Sender;
Participant sender2 = new Participant(string.Empty, (string)this.Sender, "SMTP");
messageItem.Sender = sender2;
}
ItemConversion.ConvertItemToSummaryTnef(messageItem, stream2, outboundConversionOptions);
stream2.Position = 0L;
this.message = EmailMessage.Create(stream2);
result = true;
}
catch (CorruptDataException ex)
{
base.WriteVerbose(Strings.UnableToCreateFromMsg(ex.Message));
result = false;
}
catch (ConversionFailedException ex2)
{
base.WriteVerbose(Strings.UnableToCreateFromMsg(ex2.Message));
result = false;
}
catch (PropertyErrorException ex3)
{
base.WriteVerbose(Strings.UnableToCreateFromMsg(ex3.Message));
result = false;
}
catch (StoragePermanentException ex4)
{
base.WriteVerbose(Strings.UnableToCreateFromMsg(ex4.Message));
result = false;
}
catch (StorageTransientException ex5)
{
base.WriteVerbose(Strings.UnableToCreateFromMsg(ex5.Message));
result = false;
}
}
}
}
return(result);
}
public override void Apply(MailboxSession session, Item item)
{
if (string.IsNullOrEmpty(this.ICalContents))
{
return;
}
InboundConversionOptions scopedInboundConversionOptions = MapiUtils.GetScopedInboundConversionOptions(session.GetADRecipientSession(true, ConsistencyMode.IgnoreInvalid));
ItemConversion.ConvertICalToItem(item, scopedInboundConversionOptions, this.ICalContents);
}
public void CreatePublicFolderMessage(MailRecipient recipient, DeliverableItem item)
{
PublicFolderSession publicFolderSession = (PublicFolderSession)this.storeSession;
bool flag = false;
try
{
this.context.BeginTrackLatency(LatencyComponent.StoreDriverDeliveryRpc);
using (Folder folder = Folder.Bind(publicFolderSession, this.deliverToFolder, new PropertyDefinition[]
{
FolderSchema.SecurityDescriptor
}))
{
switch (MailPublicFolderPermissionHandler.CheckAccessForEmailDelivery(this.context, folder))
{
case AccessCheckResult.NotAllowedAnonymous:
DeliveryItem.Diag.TraceError(0L, "Anonymous users are not permitted to add contents to mail enabled public folder.");
throw new SmtpResponseException(AckReason.NotAuthenticated, MessageAction.NDR);
case AccessCheckResult.NotAllowedAuthenticated:
DeliveryItem.Diag.TraceError <RoutingAddress>(0L, "User {0} is not permitted to add contents to mail enabled public folder.", this.context.MbxTransportMailItem.From);
throw new SmtpResponseException(AckReason.RecipientPermissionRestricted, MessageAction.NDR);
case AccessCheckResult.NotAllowedInternalSystemError:
DeliveryItem.Diag.TraceError(0L, "Exception occured when determining permission for sender on public folder");
throw new SmtpResponseException(AckReason.PublicFolderSenderValidationFailed, MessageAction.NDR);
default:
if (folder.IsContentAvailable())
{
this.messageItem = MessageItem.CreateForDelivery(publicFolderSession, folder.Id, this.context.ReplayItem.InternetMessageId, this.context.ReplayItem.GetValueAsNullable <ExDateTime>(ItemSchema.SentTime));
if (this.messageItem != null && this.messageItem.DisposeTracker != null)
{
this.messageItem.DisposeTracker.AddExtraDataWithStackTrace("DeliveryItem owns messageItem at:{0}{1}");
}
flag = true;
}
else
{
this.ReroutePublicFolderRecipient(publicFolderSession, folder, recipient);
}
break;
}
}
}
finally
{
TimeSpan additionalLatency = this.context.EndTrackLatency(LatencyComponent.StoreDriverDeliveryRpc);
this.context.AddRpcLatency(additionalLatency, "Open message");
}
if (flag)
{
ItemConversion.ReplayInboundContent(this.context.ReplayItem, this.messageItem);
}
}
public bool Decode(OutboundConversionOptions options, bool acquireLicense)
{
this.CheckDisposed("Decode");
Util.ThrowOnNullArgument(options, "options");
this.decryptionStatus = RightsManagedMessageDecryptionStatus.Success;
if (this.decodedItem != null)
{
return(true);
}
if (this.InternalSession == null)
{
this.decryptionStatus = RightsManagedMessageDecryptionStatus.NotSupported;
throw new InvalidOperationException("Decoding of in-memory messages is not supported.");
}
RightsManagedMessageItem.CheckSession(this.InternalSession);
this.SetConversionOptions(options);
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
try
{
MessageItem messageItem = ItemConversion.OpenRestrictedContent(this, this.orgId, acquireLicense, out this.licenseAcquired, out this.useLicenseValue, out this.restrictionInfo);
if (messageItem == null)
{
ExTraceGlobals.StorageTracer.TraceError(0L, "Failed to decode protected message - no user license is present.");
throw new RightsManagementPermanentException(RightsManagementFailureCode.UnknownFailure, ServerStrings.GenericFailureRMDecryption);
}
disposeGuard.Add <MessageItem>(messageItem);
this.UpdateEffectiveRights();
this.conversationOwner = new Participant(this.restrictionInfo.ConversationOwner, this.restrictionInfo.ConversationOwner, "SMTP");
this.CheckPermission(ContentRight.View);
messageItem.CoreItem.TopLevelItem = (base.CoreItem.TopLevelItem ?? base.CoreItem);
this.serverUseLicense = (messageItem.TryGetProperty(MessageItemSchema.DRMServerLicense) as string);
this.publishLicense = (messageItem.TryGetProperty(MessageItemSchema.DrmPublishLicense) as string);
this.rmsTemplate = RmsTemplate.CreateFromPublishLicense(this.publishLicense);
MsgToRpMsgConverter.CallRM(delegate
{
this.publishedByExternalRMS = !RmsClientManager.IsPublishedByOrganizationRMS(this.orgId, this.publishLicense);
}, ServerStrings.FailedToCheckPublishLicenseOwnership(this.orgId.ToString()));
this.decodedItem = messageItem;
disposeGuard.Success();
}
catch (RightsManagementPermanentException exception)
{
this.decryptionStatus = RightsManagedMessageDecryptionStatus.CreateFromException(exception);
throw;
}
catch (RightsManagementTransientException exception2)
{
this.decryptionStatus = RightsManagedMessageDecryptionStatus.CreateFromException(exception2);
throw;
}
}
return(true);
}
private void InitializeSmimeInfo(IItem item, string domainName, out AttachmentCollection attachmentCollection)
{
attachmentCollection = item.AttachmentCollection;
MessageItem messageItem = item as MessageItem;
Item item2;
if (messageItem != null && ItemConversion.TryOpenSMimeContent(messageItem, domainName, out item2))
{
attachmentCollection = item2.AttachmentCollection;
}
}
public ImapItemConverter(Item itemIn, OutboundConversionOptions options)
{
StorageGlobals.ContextTraceInformation(ExTraceGlobals.CcOutboundMimeTracer, "ImapItemConverter::ctor.");
using (DisposeGuard disposeGuard = this.Guard())
{
Util.ThrowOnNullArgument(itemIn, "itemIn");
Util.ThrowOnNullArgument(options, "options");
Util.ThrowOnNullOrEmptyArgument(options.ImceaEncapsulationDomain, "options.ImceaEncapsulationDomain");
if (!ItemConversion.IsItemClassConvertibleToMime(itemIn.ClassName))
{
StorageGlobals.ContextTraceError <string>(ExTraceGlobals.CcOutboundMimeTracer, "ImapItemConverter::CheckItemType: wrong item type, {0}", itemIn.ClassName);
throw new WrongObjectTypeException(ServerStrings.ConversionInvalidItemType(itemIn.ClassName));
}
this.itemIn = itemIn;
this.options = options;
using (StorageGlobals.SetTraceContext(this.options))
{
using (StorageGlobals.SetTraceContext(this.itemIn))
{
if (this.options.GenerateMimeSkeleton)
{
PropertyError propertyError = this.itemIn.TryGetProperty(InternalSchema.MimeSkeleton) as PropertyError;
if (propertyError != null && propertyError.PropertyErrorCode == PropertyErrorCode.NotFound)
{
if (this.itemIn.IsReadOnly)
{
this.itemIn.OpenAsReadWrite();
}
this.itemNeedsSave = true;
using (Stream stream = this.itemIn.OpenPropertyStream(InternalSchema.MimeSkeleton, PropertyOpenMode.Create))
{
using (Stream stream2 = new MimeStreamWriter.MimeTextStream(null))
{
using (ItemToMimeConverter itemToMimeConverter = new ItemToMimeConverter(itemIn, options, ConverterFlags.GenerateSkeleton))
{
using (MimeStreamWriter mimeStreamWriter = new MimeStreamWriter(stream2, stream, itemToMimeConverter.GetItemMimeEncodingOptions(this.options), MimeStreamWriter.Flags.ForceMime))
{
ConversionLimitsTracker limits = new ConversionLimitsTracker(this.options.Limits);
itemToMimeConverter.ConvertItemToMime(mimeStreamWriter, limits);
}
}
}
}
}
}
ItemToMimeConverter itemToMimeConverter2 = new ItemToMimeConverter(itemIn, options, ConverterFlags.None);
this.mimeProvider = IImapMimeProvider.CreateInstance(itemToMimeConverter2);
this.itemEncodingOptions = itemToMimeConverter2.GetItemMimeEncodingOptions(this.options);
}
}
disposeGuard.Success();
}
}
private PlacementStatus TryPlacePlant(ItemConversion conversion, int maxRetries)
{
int tried = 0;
PlacementStatus result = PlacementStatus.Planting;
do
{
tried++;
Vector3 position = transform.position + Vector3.up + Random.onUnitSphere * configRadius.Value;
float groundHeight = ZoneSystem.instance.GetGroundHeight(position);
position.y = groundHeight;
if (conversion.plant.m_biome != 0 && configCheckBiome.Value && !IsCorrectBiome(position, conversion.plant.m_biome))
{
result = PlacementStatus.WrongBiome;
continue;
}
if (conversion.plant.m_needCultivatedGround && configCheckCultivated.Value && !IsCultivated(position))
{
result = PlacementStatus.NoRoom;
continue;
}
if (!HasGrowSpace(position, conversion.plant.m_growRadius))
{
result = PlacementStatus.NoRoom;
continue;
}
logger.LogDebug("Placing new plant " + conversion.plantPiece + " at " + position);
Quaternion rotation = Quaternion.Euler(0f, Random.Range(0, 360), 0f);
GameObject placedPlant = Instantiate(conversion.plantPiece.gameObject, position, rotation);
if (placedPlant)
{
result = PlacementStatus.Planting;
conversion.plantPiece.m_placeEffect.Create(position, rotation, placedPlant.transform);
RemoveOneSeed();
break;
}
else
{
logger.LogWarning("No object returned?");
}
break;
} while (tried <= maxRetries);
logger.LogDebug("Max retries reached, result " + result);
return(result);
}
internal static void CreateAttachment(IItem parentItem, Attachment16Data attachmentData)
{
AirSyncDiagnostics.TraceDebug <byte>(ExTraceGlobals.RequestsTracer, null, "CreateAttachment with AttachMethod:{0}", attachmentData.Method);
if (attachmentData.Method == 1)
{
if (attachmentData.Content == null)
{
throw new ConversionException(string.Format(" Attachment content can not be null.", new object[0]));
}
IStreamAttachment streamAttachment = parentItem.IAttachmentCollection.CreateIAttachment(AttachmentType.Stream) as IStreamAttachment;
AttachmentHelper.CopyCommonAttachmentProperties(streamAttachment, attachmentData);
using (Stream contentStream = streamAttachment.GetContentStream())
{
contentStream.Write(attachmentData.Content, 0, attachmentData.Content.Length);
}
streamAttachment.Save();
}
else
{
if (attachmentData.Method != 5)
{
throw new ConversionException(string.Format("UnSupported Value '{0}' for Attachment Method. Only 1 & 5 is supported AttachemntType", attachmentData.Method));
}
ItemAttachment itemAttachment = parentItem.IAttachmentCollection.CreateIAttachment(AttachmentType.EmbeddedMessage) as ItemAttachment;
AttachmentHelper.CopyCommonAttachmentProperties(itemAttachment, attachmentData);
using (Stream stream = new MemoryStream(attachmentData.Content))
{
stream.Seek(0L, SeekOrigin.Begin);
InboundConversionOptions inboundConversionOptions = AirSyncUtility.GetInboundConversionOptions();
inboundConversionOptions.ClearCategories = false;
try
{
using (Item item = itemAttachment.GetItem())
{
ItemConversion.ConvertAnyMimeToItem(item, stream, inboundConversionOptions);
item.Save(SaveMode.NoConflictResolution);
}
}
catch (ExchangeDataException innerException)
{
throw new AirSyncPermanentException(HttpStatusCode.BadRequest, StatusCode.InvalidMIME, innerException, false);
}
catch (ConversionFailedException innerException2)
{
throw new AirSyncPermanentException(HttpStatusCode.BadRequest, StatusCode.InvalidMIME, innerException2, false);
}
}
itemAttachment.Save();
}
AirSyncDiagnostics.TraceDebug <int>(ExTraceGlobals.RequestsTracer, null, "AttachmentHelper:CreateAttachments:: AttachmentCreated successful. AttachmentCount:{0}", parentItem.IAttachmentCollection.Count);
}
internal static CalendarLog FromFile(FileInfo file)
{
if (file.Exists)
{
using (MessageItem messageItem = MessageItem.CreateInMemory(StoreObjectSchema.ContentConversionProperties))
{
using (FileStream fileStream = file.OpenRead())
{
ItemConversion.ConvertMsgStorageToItem(fileStream, messageItem, new InboundConversionOptions(new EmptyRecipientCache(), null));
return(new CalendarLog(messageItem, file, null));
}
}
}
return(null);
}
public static void ScanCultivator()
{
if (scanningCultivator)
{
return;
}
scanningCultivator = true;
foreach (PieceTable table in Resources.FindObjectsOfTypeAll(typeof(PieceTable)))
{
string name = table.gameObject.name;
if (name.Equals("_CultivatorPieceTable"))
{
foreach (GameObject cultivatorRecipe in table.m_pieces)
{
Piece piece = cultivatorRecipe.GetComponent <Piece>();
Plant plant = piece.GetComponent <Plant>();
if (plant)
{
Piece.Requirement[] requirements = piece.m_resources;
if (requirements.Length > 1)
{
logger.LogWarning(" Multiple seeds required for " + plant.m_name + "? Skipping");
continue;
}
Piece.Requirement requirement = requirements[0];
ItemDrop itemData = requirement.m_resItem;
if (!seedPrefabMap.ContainsKey(itemData.m_itemData.m_shared.m_name))
{
logger.LogDebug("Looking for Prefab of " + itemData.m_itemData.m_shared.m_name + " -> " + itemData.gameObject.name);
ItemConversion conversion = new ItemConversion
{
seedDrop = requirement.m_resItem,
plantPiece = piece,
plant = plant
};
logger.LogDebug("Registering seed type: " + conversion);
seedPrefabMap.Add(itemData.m_itemData.m_shared.m_name, conversion);
}
}
}
}
}
scanningCultivator = false;
}
private void WriteMimePart(IImapMimeProvider mimeProvider, MimeStreamWriter writer, OutboundConversionOptions options, MimePartInfo partInfo, ItemToMimeConverter.MimeFlags conversionFlags)
{
try
{
ConvertUtils.CallCts(ExTraceGlobals.CcOutboundMimeTracer, "ImapItemConverter::WriteMimePart", ServerStrings.ConversionCorruptContent, delegate
{
ConversionLimitsTracker limits = new ConversionLimitsTracker(options.Limits);
mimeProvider.WriteMimePart(writer, limits, partInfo, conversionFlags);
});
}
catch (StoragePermanentException exc)
{
ItemConversion.SaveFailedItem(this.itemIn, options, exc);
throw;
}
}
public bool JsonImport(string path, string name)
{
string FilePath = path + "/" + name + ".json";
if (!File.Exists(FilePath))
{
return(false);
}
ItemConversion ic = JsonIO.JsonImport <ItemConversion>(path, name);
Name = ic.Name;
ItemConversionRecipe = ic.ItemConversionRecipe;
Attribute = ic.Attribute;
return(true);
}
// Token: 0x06001988 RID: 6536 RVA: 0x000953D4 File Offset: 0x000935D4
internal Stream GetItemAttachmentStream(Attachment attachment, HttpContext httpContext)
{
OwaContext owaContext = OwaContext.Get(httpContext);
UserContext userContext = owaContext.UserContext;
OutboundConversionOptions outboundConversionOptions = Utilities.CreateOutboundConversionOptions(userContext);
Stream stream = Streams.CreateTemporaryStorageStream();
string text = null;
ItemAttachment itemAttachment = attachment as ItemAttachment;
using (Item item = itemAttachment.GetItem(StoreObjectSchema.ContentConversionProperties))
{
try
{
if (ItemConversion.IsItemClassConvertibleToMime(item.ClassName))
{
ItemConversion.ConvertItemToMime(item, stream, outboundConversionOptions);
text = ".eml";
}
else if (ObjectClass.IsCalendarItemCalendarItemOccurrenceOrRecurrenceException(item.ClassName))
{
(item as CalendarItemBase).ExportAsICAL(stream, "UTF-8", outboundConversionOptions);
text = ".ics";
}
else if (ObjectClass.IsContact(item.ClassName))
{
Contact.ExportVCard(item as Contact, stream, outboundConversionOptions);
text = ".vcf";
}
else
{
ItemConversion.ConvertItemToMsgStorage(item, stream, outboundConversionOptions);
}
}
catch (Exception)
{
stream = this.GetContentsReplacementStream(-1706159495);
text = ".txt";
}
}
if (text != null)
{
this.fileName = this.GetConvertedItemFileName(this.fileName, text);
this.encodedfileNameBytes = this.GetEncodedString(this.fileName);
}
stream.Position = 0L;
return(stream);
}
public TimeSpan CopyContentTo(TransportMailItem mailItem)
{
this.ConversionOptions.RecipientCache = mailItem.ADRecipientCache;
this.ConversionOptions.UserADSession = mailItem.ADRecipientCache.ADSession;
mailItem.CacheTransportSettings();
this.ConversionOptions.ClearCategories = mailItem.TransportSettings.ClearCategories;
this.ConversionOptions.UseRFC2231Encoding = mailItem.TransportSettings.Rfc2231EncodingEnabled;
this.ConversionOptions.AllowDlpHeadersToPenetrateFirewall = true;
this.storeDriverTracer.StoreDriverCommonTracer.TracePass <long>(this.storeDriverTracer.MessageProbeActivityId, 0L, "Generate content for mailitem {0}", mailItem.RecordId);
ExDateTime utcNow = ExDateTime.UtcNow;
using (Stream stream = mailItem.OpenMimeWriteStream(MimeLimits.Default))
{
this.conversionResult = ItemConversion.ConvertItemToSummaryTnef(this.messageItem, stream, this.ConversionOptions);
stream.Flush();
}
return(ExDateTime.UtcNow - utcNow);
}
private CalendarLogAnalysis LoadFromFile(CalendarLogId id, UriHandler handler)
{
FileInfo fileInfo = new FileInfo(handler.Uri.LocalPath);
if (fileInfo.Exists)
{
using (MessageItem messageItem = MessageItem.CreateInMemory(StoreObjectSchema.ContentConversionProperties))
{
using (FileStream fileStream = fileInfo.OpenRead())
{
ItemConversion.ConvertMsgStorageToItem(fileStream, messageItem, new InboundConversionOptions(new EmptyRecipientCache(), null));
IEnumerable <PropertyDefinition> displayProperties = AnalysisDetailLevels.GetDisplayProperties(this.detailLevel);
return(new CalendarLogAnalysis(id, messageItem, displayProperties));
}
}
}
throw new ArgumentException("Item argument cannot be resolved.", "item");
}
private void ImportMessageMime(MessageItem item)
{
this.ClearMessagePropertiesForMimeImport(item);
InboundConversionOptions options = Utilities.CreateInboundConversionOptions(base.UserContext);
using (MemoryStream memoryStream = new MemoryStream(Encoding.ASCII.GetBytes((string)base.GetParameter("MimeBlob"))))
{
ItemConversion.ConvertAnyMimeToItem(item, memoryStream, options);
}
if (Utilities.IsIrmDecrypted(item))
{
RightsManagedMessageItem rightsManagedMessageItem = (RightsManagedMessageItem)item;
rightsManagedMessageItem.SetProtectedData(item.Body, item.AttachmentCollection);
rightsManagedMessageItem.SetDefaultEnvelopeBody(null);
}
item.From = null;
item.Sender = null;
base.UpdateComplianceAction(item);
}
// Token: 0x0600003E RID: 62 RVA: 0x00004434 File Offset: 0x00002634
private void AttachOriginalMessageToNotification(MessageItem initiationMessage, MessageItem notificationMessage, out string originalSenderDisplayname)
{
originalSenderDisplayname = string.Empty;
if (string.IsNullOrEmpty(this.defaultAcceptedDomain))
{
ModeratedDLApplication.diag.TraceDebug((long)this.GetHashCode(), "Cannot attach original message to notification without domain for content conversion.");
return;
}
AttachmentCollection attachmentCollection = initiationMessage.AttachmentCollection;
foreach (AttachmentHandle handle in attachmentCollection)
{
using (Attachment attachment = attachmentCollection.Open(handle))
{
if ("OriginalMessage".Equals(attachment.FileName, StringComparison.OrdinalIgnoreCase))
{
StreamAttachment streamAttachment = attachment as StreamAttachment;
if (streamAttachment != null)
{
using (Stream contentStream = streamAttachment.GetContentStream(PropertyOpenMode.ReadOnly))
{
using (ItemAttachment itemAttachment = (ItemAttachment)notificationMessage.AttachmentCollection.Create(AttachmentType.EmbeddedMessage))
{
using (Item item = itemAttachment.GetItem())
{
InboundConversionOptions options = new InboundConversionOptions(this.defaultAcceptedDomain);
ItemConversion.ConvertAnyMimeToItem(item, contentStream, options);
item[MessageItemSchema.Flags] = MessageFlags.None;
originalSenderDisplayname = (item.TryGetProperty(MessageItemSchema.SenderDisplayName) as string);
item.Save(SaveMode.NoConflictResolution);
itemAttachment[AttachmentSchema.DisplayName] = initiationMessage.Subject;
itemAttachment.Save();
}
}
}
}
break;
}
}
}
}
private bool TryParkThisMessage(StoreDriverDeliveryEventArgsImpl args, MeetingSeriesMessageOrderingAgent.SeriesHeadersData headersData)
{
Guid networkMessageId = args.MailItemDeliver.MbxTransportMailItem.NetworkMessageId;
this.AddUnparkedHeader(args.MailItem.Message.MimeDocument.RootPart.Headers, networkMessageId);
bool encapsulationSucceeded = true;
string text;
bool encapsulationSucceeded2;
using (EmailMessage emailMessage = ModerationHelper.EncapsulateOriginalMessage(args.MailItemDeliver.MbxTransportMailItem, new List <MailRecipient>
{
args.MailRecipient
}, args.MailRecipient.Email.ToString(), args.MailRecipient.Email.ToString(), MeetingSeriesMessageOrderingAgent.tracer, delegate(Exception param0)
{
encapsulationSucceeded = false;
}, out text))
{
if (encapsulationSucceeded)
{
MailboxSession mailboxSession = args.MailboxSession;
using (ParkedMeetingMessage parkedMeetingMessage = ParkedMeetingMessage.Create(mailboxSession))
{
if (parkedMeetingMessage != null)
{
string internetMessageId = args.MailItemDeliver.MbxTransportMailItem.InternetMessageId;
ItemConversion.ConvertAnyMimeToItem(parkedMeetingMessage, emailMessage.MimeDocument, new InboundConversionOptions(args.ADRecipientCache));
parkedMeetingMessage.ParkedCorrelationId = ParkedMeetingMessage.GetCorrelationId(headersData.SeriesId, headersData.SeriesSequenceNumber);
parkedMeetingMessage[StoreObjectSchema.ItemClass] = "IPM.Parked.MeetingMessage";
parkedMeetingMessage.CleanGlobalObjectId = headersData.InstanceGoid;
parkedMeetingMessage.OriginalMessageId = internetMessageId;
int retentionPeriod = MeetingSeriesMessageOrderingAgent.GetRetentionPeriod(args.MailboxOwner);
PolicyTagHelper.SetRetentionProperties(parkedMeetingMessage, ExDateTime.UtcNow.AddDays((double)retentionPeriod), retentionPeriod);
parkedMeetingMessage.Save(SaveMode.NoConflictResolution);
}
}
}
encapsulationSucceeded2 = encapsulationSucceeded;
}
return(encapsulationSucceeded2);
}
private void CopyMfnContentTo(MeetingForwardNotification meetingForwardNotification, TransportMailItem mailItem)
{
OutboundConversionOptions outboundConversionOptions = new OutboundConversionOptions(Components.Configuration.FirstOrgAcceptedDomainTable.DefaultDomainName);
outboundConversionOptions.DsnMdnOptions = DsnMdnOptions.PropagateUserSettings;
outboundConversionOptions.DsnHumanReadableWriter = Components.DsnGenerator.DsnHumanReadableWriter;
outboundConversionOptions.RecipientCache = mailItem.ADRecipientCache;
outboundConversionOptions.UserADSession = mailItem.ADRecipientCache.ADSession;
mailItem.CacheTransportSettings();
outboundConversionOptions.ClearCategories = mailItem.TransportSettings.ClearCategories;
outboundConversionOptions.UseRFC2231Encoding = mailItem.TransportSettings.Rfc2231EncodingEnabled;
outboundConversionOptions.Limits.MimeLimits = MimeLimits.Unlimited;
outboundConversionOptions.AllowDlpHeadersToPenetrateFirewall = true;
using (Stream stream = mailItem.OpenMimeWriteStream())
{
if (Components.Configuration.LocalServer.TransportServer.ContentConversionTracingEnabled && Components.Configuration.LocalServer.TransportServer.PipelineTracingPath != null)
{
outboundConversionOptions.LogDirectoryPath = Components.Configuration.LocalServer.TransportServer.PipelineTracingPath.PathName;
}
ItemConversion.ConvertItemToSummaryTnef(meetingForwardNotification, stream, outboundConversionOptions);
}
}
public static Stream ConvertItemToMime(StoreObject xsoItem)
{
Item item = xsoItem as Item;
if (item == null)
{
throw new UnexpectedTypeException("Item", xsoItem);
}
OutboundConversionOptions outboundConversionOptions = AirSyncUtility.GetOutboundConversionOptions();
PolicyData policyData = ADNotificationManager.GetPolicyData(Command.CurrentCommand.User);
if (policyData != null && !policyData.AttachmentsEnabled)
{
outboundConversionOptions.FilterAttachmentHandler = ((Item item1, Attachment attachment) => false);
}
item.Load(StoreObjectSchema.ContentConversionProperties);
AirSyncStream airSyncStream = new AirSyncStream();
try
{
if (BodyConversionUtilities.IsMessageRestrictedAndDecoded(item))
{
ItemConversion.ConvertItemToMime(((RightsManagedMessageItem)item).DecodedItem, airSyncStream, outboundConversionOptions);
}
else
{
ItemConversion.ConvertItemToMime(item, airSyncStream, outboundConversionOptions);
}
}
catch (ConversionFailedException innerException)
{
throw new ConversionException(string.Format(CultureInfo.InvariantCulture, "MIME conversion failed for Item {0}", new object[]
{
item
}), innerException);
}
return(airSyncStream);
}
public byte[] CalculateBodyTag(out int latestMessagePartWordCount)
{
latestMessagePartWordCount = int.MinValue;
if (this.IsBodyDefined && this.Size / 2048L <= 2048L)
{
try
{
ConversationBodyScanner conversationBodyScanner = this.GetConversationBodyScanner();
latestMessagePartWordCount = conversationBodyScanner.CalculateLatestMessagePartWordCount();
BodyFragmentInfo bodyFragmentInfo = new BodyFragmentInfo(conversationBodyScanner);
return(bodyFragmentInfo.BodyTag.ToByteArray());
}
catch (TextConvertersException)
{
return(new byte[Body.BodyTagLength]);
}
}
if (ObjectClass.IsSmime(this.coreItem.ClassName()) && !ObjectClass.IsSmimeClearSigned(this.coreItem.ClassName()))
{
Item item = null;
try
{
InboundConversionOptions inboundConversionOptions = ConvertUtils.GetInboundConversionOptions();
if (ItemConversion.TryOpenSMimeContent(this.coreItem, inboundConversionOptions, out item))
{
return(item.Body.CalculateBodyTag(out latestMessagePartWordCount));
}
}
finally
{
if (item != null)
{
item.Dispose();
}
}
}
return(new byte[12]);
}
public void CreateMailboxMessage(bool leaveReceivedTime)
{
MailboxSession mailboxSession = (MailboxSession)this.storeSession;
try
{
this.context.BeginTrackLatency(LatencyComponent.StoreDriverDeliveryRpc);
if (this.deliverToFolder == null)
{
this.deliverToFolder = mailboxSession.GetDefaultFolderId(DefaultFolderType.Inbox);
}
ExDateTime?clientSubmitTime = this.context.ReplayItem.GetValueAsNullable <ExDateTime>(ItemSchema.SentTime);
if (leaveReceivedTime)
{
this.messageItem = MessageItem.CreateAggregatedForDelivery(mailboxSession, this.deliverToFolder, this.context.ReplayItem.InternetMessageId, clientSubmitTime);
}
else
{
bool value = this.context.Recipient.ExtendedProperties.GetValue <bool>("Microsoft.Exchange.Transport.MailboxTransport.RetryOnDuplicateDelivery ", false);
if (value)
{
clientSubmitTime = null;
}
this.messageItem = MessageItem.CreateForDelivery(mailboxSession, this.deliverToFolder, this.context.ReplayItem.InternetMessageId, clientSubmitTime);
}
}
finally
{
TimeSpan additionalLatency = this.context.EndTrackLatency(LatencyComponent.StoreDriverDeliveryRpc);
this.context.AddRpcLatency(additionalLatency, "Create message");
}
if (this.messageItem != null && this.messageItem.DisposeTracker != null)
{
this.messageItem.DisposeTracker.AddExtraDataWithStackTrace("DeliveryItem owns messageItem at:{0}{1}");
}
ItemConversion.ReplayInboundContent(this.context.ReplayItem, this.messageItem);
}
protected override void InternalCopyFromModified(IProperty srcProperty)
{
IContentProperty contentProperty = (IContentProperty)srcProperty;
BodyType nativeType = contentProperty.GetNativeType();
if (nativeType == BodyType.Mime && string.Equals(base.XsoItem.ClassName, "IPM.NOTE.MOBILE.MMS", StringComparison.OrdinalIgnoreCase))
{
Item itemOut = (Item)base.XsoItem;
InboundConversionOptions inboundConversionOptions = AirSyncUtility.GetInboundConversionOptions();
inboundConversionOptions.ClearCategories = false;
try
{
Stream body = ((IContentProperty)srcProperty).Body;
ItemConversion.ConvertAnyMimeToItem(itemOut, body, inboundConversionOptions);
goto IL_8A;
}
catch (ExchangeDataException ex)
{
throw new ConversionException("Mime conversion for MMS item failed due to InvalidCharSetError", ex.InnerException);
}
catch (ConversionFailedException ex2)
{
throw new ConversionException("Mime conversion for MMS item failed due to InvalidMime", ex2.InnerException);
}
}
base.InternalCopyFromModified(srcProperty);
IL_8A:
if (string.Equals(base.XsoItem.ClassName, "IPM.NOTE.MOBILE.SMS", StringComparison.OrdinalIgnoreCase))
{
MessageItem messageItem = (MessageItem)base.XsoItem;
StreamReader streamReader = new StreamReader(((IContentProperty)srcProperty).Body);
char[] array = new char[78];
int length = streamReader.ReadBlock(array, 0, array.Length);
messageItem.Subject = new string(array, 0, length);
}
}
public void LoadItemConversionInfo()
{
RecipesItemConversionAll = new LinkedList <ItemConversion>();
RecipesItemConversion = new Dictionary <string, LinkedList <ItemConversion> >();
DirectoryInfo dir = new DirectoryInfo(SystemVariables.RootPath + "/Data/Item/ItemConversion");
FileInfo[] info = dir.GetFiles("*.json");
foreach (FileInfo f in info)
{
string name = Path.GetFileNameWithoutExtension(f.Name);
ItemConversion ic = JsonIO.JsonImport <ItemConversion>(SystemVariables.RootPath + "/Data/Item/ItemConversion", name);
RecipesItemConversionAll.AddLast(ic);
foreach (var i in ic.Attribute)
{
if (!RecipesItemConversion.ContainsKey(i))
{
RecipesItemConversion.Add(i, new LinkedList <ItemConversion>());
}
RecipesItemConversion[i].AddLast(ic);
}
}
}
