// 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); } } }