public static Charset GetItemWindowsCharset(Item item, OutboundConversionOptions options)
{
int valueOrDefault = item.GetValueOrDefault <int>(InternalSchema.InternetCpid, 0);
Charset charset;
if (Charset.TryGetCharset(valueOrDefault, out charset))
{
charset = ConvertUtils.MapItemWindowsCharset(charset);
if (charset != null && charset.IsAvailable)
{
return(charset);
}
}
int valueOrDefault2 = item.GetValueOrDefault <int>(InternalSchema.Codepage, 0);
if (ConvertUtils.TryGetValidCharset(valueOrDefault2, out charset))
{
return(charset);
}
if (options != null && options.DetectionOptions.PreferredCharset != null)
{
charset = ConvertUtils.MapItemWindowsCharset(options.DetectionOptions.PreferredCharset);
if (charset != null && charset.IsAvailable)
{
return(charset);
}
}
return(Charset.DefaultWindowsCharset);
}
private static Charset GetItemOutboundMimeCharsetInternal(Item item, OutboundConversionOptions options)
{
object obj = item.TryGetProperty(InternalSchema.InternetCpid);
bool valueOrDefault = item.GetValueOrDefault <bool>(InternalSchema.IsAutoForwarded, false);
string className = item.ClassName;
Charset charset = null;
if (valueOrDefault || (obj is PropertyError && !item.Body.IsBodyDefined) || (options != null && options.DetectionOptions.PreferredCharset != null && (options.DetectionOptions.RequiredCoverage < 100 || ObjectClass.IsTaskRequest(className) || ObjectClass.IsMeetingMessage(className))))
{
charset = ConvertUtils.DetectOutboundCharset(item, options, obj, !valueOrDefault);
if (charset != null)
{
if (!item.CharsetDetector.IsItemCharsetKnownWithoutDetection(BodyCharsetFlags.DisableCharsetDetection, charset, out charset))
{
throw new InvalidOperationException();
}
return(charset);
}
}
if (!(obj is PropertyError) && Charset.TryGetCharset((int)obj, out charset) && ConvertUtils.TryTransformCharset(ref charset))
{
return(charset);
}
object obj2 = item.TryGetProperty(InternalSchema.Codepage);
if (!(obj2 is PropertyError) && Charset.TryGetCharset((int)obj2, out charset))
{
charset = charset.Culture.MimeCharset;
if (ConvertUtils.TryTransformCharset(ref charset))
{
return(charset);
}
}
return(Charset.GetCharset(65001));
}
public static RightsManagedMessageItem ReBind(MessageItem item, OutboundConversionOptions options, bool acquireLicense)
{
Util.ThrowOnNullArgument(item, "item");
Util.ThrowOnNullArgument(options, "options");
StoreSession storeSession = item.Session ?? ((item.CoreItem.TopLevelItem != null) ? item.CoreItem.TopLevelItem.Session : null);
if (storeSession == null)
{
throw new ArgumentException("Cannot use ReBind() for in-memory message.", "item");
}
RightsManagedMessageItem.CheckSession(storeSession);
if (!item.IsRestricted)
{
throw new ArgumentException("Only protected messages can be used for ReBind()");
}
RightsManagedMessageItem result;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
RightsManagedMessageItem rightsManagedMessageItem = new RightsManagedMessageItem(new CoreItemWrapper(item.CoreItem));
disposeGuard.Add <RightsManagedMessageItem>(rightsManagedMessageItem);
rightsManagedMessageItem.Decode(options, acquireLicense);
disposeGuard.Success();
rightsManagedMessageItem.originalItem = item;
result = rightsManagedMessageItem;
}
return(result);
}
public OutboundConversionOptions(OutboundConversionOptions source)
{
this.encodeAttachmentsAsBinhex = source.encodeAttachmentsAsBinhex;
this.suppressDisplayName = source.suppressDisplayName;
this.internetMessageFormat = source.internetMessageFormat;
this.internetTextFormat = source.internetTextFormat;
this.imceaEncapsulationDomain = source.imceaEncapsulationDomain;
this.preserveReportBody = source.preserveReportBody;
this.byteEncoderTypeFor7BitCharsets = source.byteEncoderTypeFor7BitCharsets;
this.clearCategories = source.clearCategories;
this.owaServer = source.owaServer;
this.userADSession = source.userADSession;
this.recipientCache = source.recipientCache;
this.useRFC2231Encoding = source.useRFC2231Encoding;
this.allowUTF8Headers = source.allowUTF8Headers;
this.limits = (ConversionLimits)source.limits.Clone();
this.dsnWriter = source.dsnWriter;
this.logDirectoryPath = source.LogDirectoryPath;
this.isSenderTrusted = source.IsSenderTrusted;
this.useSimpleDisplayName = source.useSimpleDisplayName;
this.allowPartialStnefContent = source.allowPartialStnefContent;
this.generateMimeSkeleton = source.generateMimeSkeleton;
this.demoteBcc = source.demoteBcc;
this.detectionOptions = source.detectionOptions;
this.filterAttachment = source.filterAttachment;
this.filterBody = source.filterBody;
this.resolveRecipientsInAttachedMessages = source.resolveRecipientsInAttachedMessages;
this.quoteDisplayNameBeforeRfc2047Encoding = source.quoteDisplayNameBeforeRfc2047Encoding;
this.allowDlpHeadersToPenetrateFirewall = source.allowDlpHeadersToPenetrateFirewall;
this.EnableCalendarHeaderGeneration = source.EnableCalendarHeaderGeneration;
this.EwsOutboundMimeConversion = source.EwsOutboundMimeConversion;
this.blockPlainTextConversion = source.BlockPlainTextConversion;
this.useSkeleton = source.UseSkeleton;
}
private void InitNewItem(OutboundConversionOptions options)
{
this[StoreObjectSchema.ContentClass] = "rpmsg.message";
base.IconIndex = IconIndex.MailIrm;
this.decodedItem = MessageItem.CreateInMemory(StoreObjectSchema.ContentConversionProperties);
this.SetConversionOptions(options);
this.UpdateEffectiveRights();
}
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);
}
internal static Charset GetItemOutboundMimeCharset(Item item, OutboundConversionOptions options)
{
Charset charset = ConvertUtils.GetItemOutboundMimeCharsetInternal(item, options);
string className = item.ClassName;
if (options.DetectionOptions.PreferredCharset == null && charset.CodePage != 54936 && (ObjectClass.IsTaskRequest(className) || ObjectClass.IsMeetingMessage(className) || ObjectClass.IsCalendarItem(className)))
{
charset = Charset.GetCharset(65001);
}
return(charset);
}
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 static Charset DetectOutboundCharset(Item item, OutboundConversionOptions options, object internetCpidObj, bool trustInternetCpid)
{
if (options != null && options.DetectionOptions.PreferredCharset != null && (options.DetectionOptions.RequiredCoverage == 0 || (!(internetCpidObj is PropertyError) && trustInternetCpid && options.DetectionOptions.PreferredCharset.CodePage == (int)internetCpidObj)))
{
Charset preferredCharset = options.DetectionOptions.PreferredCharset;
if (ConvertUtils.TryTransformCharset(ref preferredCharset))
{
return(preferredCharset);
}
}
StringBuilder stringBuilder = new StringBuilder();
item.CoreItem.GetCharsetDetectionData(stringBuilder, CharsetDetectionDataFlags.Complete | CharsetDetectionDataFlags.NoMessageDecoding);
if (item.Body.IsBodyDefined)
{
using (TextReader textReader = item.Body.OpenTextReader(BodyFormat.TextPlain))
{
char[] array = new char[32768];
int charCount = textReader.ReadBlock(array, 0, array.Length);
stringBuilder.Append(array, 0, charCount);
}
}
OutboundCodePageDetector outboundCodePageDetector = new OutboundCodePageDetector();
outboundCodePageDetector.AddText(stringBuilder.ToString());
if (options != null && options.DetectionOptions.PreferredCharset != null && outboundCodePageDetector.GetCodePageCoverage(options.DetectionOptions.PreferredCharset.CodePage) >= options.DetectionOptions.RequiredCoverage)
{
Charset preferredCharset = options.DetectionOptions.PreferredCharset;
if (ConvertUtils.TryTransformCharset(ref preferredCharset))
{
return(preferredCharset);
}
}
if (!(internetCpidObj is PropertyError) && !trustInternetCpid)
{
int num = (options != null) ? options.DetectionOptions.RequiredCoverage : 100;
Charset preferredCharset;
if (Charset.TryGetCharset((int)internetCpidObj, out preferredCharset) && preferredCharset.IsDetectable && outboundCodePageDetector.GetCodePageCoverage((int)internetCpidObj) >= num && ConvertUtils.TryTransformCharset(ref preferredCharset))
{
return(preferredCharset);
}
}
if (!trustInternetCpid || (internetCpidObj is PropertyError && !item.Body.IsBodyDefined))
{
int codePage = outboundCodePageDetector.GetCodePage();
Charset preferredCharset;
if (Charset.TryGetCharset(codePage, out preferredCharset) && ConvertUtils.TryTransformCharset(ref preferredCharset))
{
return(preferredCharset);
}
}
return(null);
}
public static void ExportVCard(Contact contact, Stream dataStream, OutboundConversionOptions options)
{
Util.ThrowOnNullArgument(dataStream, "dataStream");
Util.ThrowOnNullArgument(contact, "contact");
Util.ThrowOnNullArgument(options, "options");
Util.ThrowOnNullOrEmptyArgument(options.ImceaEncapsulationDomain, "options.ImceaEncapsulationDomain");
if (!contact.HasAllPropertiesLoaded)
{
throw new ArgumentException("Properties not loaded for contact");
}
OutboundVCardConverter.Convert(dataStream, Encoding.UTF8, contact, options, new ConversionLimitsTracker(options.Limits));
}
public RightsManagedMessageDecryptionStatus TryDecode(OutboundConversionOptions options, bool acquireLicense)
{
try
{
this.Decode(options, acquireLicense);
}
catch (RightsManagementPermanentException)
{
}
catch (RightsManagementTransientException)
{
}
return(this.decryptionStatus);
}
private void WriteParticipant(ContactWriter writer, Participant addr, OutboundConversionOptions options)
{
if (addr == null)
{
return;
}
string participantSmtpAddress = ItemToMimeConverter.GetParticipantSmtpAddress(addr, options);
if (!string.IsNullOrEmpty(participantSmtpAddress))
{
writer.StartProperty(PropertyId.EMail);
writer.WriteParameter(ParameterId.Type, "INTERNET");
writer.WritePropertyValue(participantSmtpAddress);
}
}
private void SetConversionOptions(OutboundConversionOptions options)
{
this.options = options;
if (this.InternalSession != null)
{
this.orgId = this.InternalSession.MailboxOwner.MailboxInfo.OrganizationId;
return;
}
if (options.UserADSession != null)
{
this.orgId = options.UserADSession.SessionSettings.CurrentOrganizationId;
return;
}
this.orgId = OrganizationId.ForestWideOrgId;
}
public static RightsManagedMessageItem CreateInMemory(OutboundConversionOptions options)
{
Util.ThrowOnNullArgument(options, "options");
RightsManagedMessageItem rightsManagedMessageItem = null;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
rightsManagedMessageItem = ItemBuilder.ConstructItem <RightsManagedMessageItem>(null, null, null, StoreObjectSchema.ContentConversionProperties, () => new InMemoryPersistablePropertyBag(StoreObjectSchema.ContentConversionProperties), ItemCreateInfo.RightsManagedMessageItemInfo.Creator, Origin.Existing, ItemLevel.TopLevel);
disposeGuard.Add <RightsManagedMessageItem>(rightsManagedMessageItem);
rightsManagedMessageItem[InternalSchema.ItemClass] = "IPM.Note";
rightsManagedMessageItem.InitNewItem(options);
rightsManagedMessageItem.SetDefaultEnvelopeBody(null);
disposeGuard.Success();
}
return(rightsManagedMessageItem);
}
private ItemToTnefConverter(Item itemIn, OutboundAddressCache addressCache, OutboundConversionOptions options, ConversionLimitsTracker limits, TnefType tnefType, bool parsingEmbeddedItem)
{
if (options.FilterAttachmentHandler != null)
{
throw new NotSupportedException("FilterAttachmentHandler is not supported in ItemToTnefConverter");
}
if (options.FilterBodyHandler != null)
{
throw new NotSupportedException("FilterBodyHandler is not supported in ItemToTnefConverter");
}
this.item = itemIn;
this.addressCache = addressCache;
this.options = options;
this.limitsTracker = limits;
this.isEmbeddedItem = parsingEmbeddedItem;
this.tnefType = tnefType;
}
internal TnefPropertyChecker(TnefType tnefType, bool isEmbeddedMessage, OutboundConversionOptions options)
{
this.isEmbeddedMessage = isEmbeddedMessage;
this.tnefType = tnefType;
if (isEmbeddedMessage)
{
this.messagePropertyExceptions = new Dictionary <NativeStorePropertyDefinition, bool>(TnefPropertyChecker.embeddedPropertyTransmittabilities);
}
else
{
this.messagePropertyExceptions = new Dictionary <NativeStorePropertyDefinition, bool>(TnefPropertyChecker.rootPropertyTransmittabilities);
}
this.messagePropertyExceptions.Add(InternalSchema.Categories, !options.ClearCategories);
if (tnefType == TnefType.SummaryTnef)
{
this.recipientPropertyExceptions = new Dictionary <NativeStorePropertyDefinition, bool>(TnefPropertyChecker.stnefRecipientPropertyTransmittabilities);
}
}
public static RightsManagedMessageItem Create(MessageItem item, OutboundConversionOptions options)
{
Util.ThrowOnNullArgument(item, "item");
Util.ThrowOnNullArgument(options, "options");
RightsManagedMessageItem.CheckSession(item.Session);
RightsManagedMessageItem result;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
RightsManagedMessageItem rightsManagedMessageItem = new RightsManagedMessageItem(new CoreItemWrapper(item.CoreItem));
disposeGuard.Add <RightsManagedMessageItem>(rightsManagedMessageItem);
rightsManagedMessageItem.InitNewItem(options);
RightsManagedMessageItem.CopyProtectableData(item, rightsManagedMessageItem.decodedItem);
rightsManagedMessageItem.SetDefaultEnvelopeBody(null);
disposeGuard.Success();
rightsManagedMessageItem.originalItem = item;
result = rightsManagedMessageItem;
}
return(result);
}
internal static InboundConversionOptions FromOutboundOptions(OutboundConversionOptions outboundOptions)
{
InboundConversionOptions inboundConversionOptions = new InboundConversionOptions(outboundOptions.ImceaEncapsulationDomain);
if (outboundOptions.DetectionOptions.PreferredCharset != null)
{
inboundConversionOptions.defaultCharset = outboundOptions.DetectionOptions.PreferredCharset;
}
inboundConversionOptions.isSenderTrusted = outboundOptions.IsSenderTrusted;
inboundConversionOptions.userADSession = outboundOptions.UserADSession;
inboundConversionOptions.recipientCache = outboundOptions.RecipientCache;
inboundConversionOptions.clearCategories = outboundOptions.ClearCategories;
inboundConversionOptions.preserveReportBody = outboundOptions.PreserveReportBody;
inboundConversionOptions.logDirectoryPath = outboundOptions.LogDirectoryPath;
inboundConversionOptions.detectionOptions = outboundOptions.DetectionOptions;
inboundConversionOptions.resolveRecipientsInAttachedMessages = outboundOptions.ResolveRecipientsInAttachedMessages;
if (outboundOptions.Limits != null)
{
inboundConversionOptions.limits = outboundOptions.Limits;
}
return(inboundConversionOptions);
}
internal MsgToRpMsgConverter(MessageItem envelopeMessage, Participant conversationOwner, OrganizationId orgId, RmsTemplate restriction, OutboundConversionOptions options)
{
MsgToRpMsgConverter < > 4__this = this;
using (DisposeGuard disposeGuard = this.Guard())
{
this.options = options;
this.orgId = orgId;
this.charset = ConvertUtils.GetItemMimeCharset(envelopeMessage.CoreItem.PropertyBag);
this.messageId = envelopeMessage.InternetMessageId;
MsgToRpMsgConverter.RpMsgConversionAddressCache rpMsgConversionAddressCache = new MsgToRpMsgConverter.RpMsgConversionAddressCache(this.options);
rpMsgConversionAddressCache.CopyRecipientsFromItem(envelopeMessage);
rpMsgConversionAddressCache.Sender = conversationOwner;
if (envelopeMessage.From != null)
{
rpMsgConversionAddressCache.From = envelopeMessage.From;
}
rpMsgConversionAddressCache.Resolve();
string senderAddress = ItemToMimeConverter.TryGetParticipantSmtpAddress(rpMsgConversionAddressCache.Sender ?? conversationOwner);
if (string.IsNullOrEmpty(senderAddress))
{
ExTraceGlobals.StorageTracer.TraceError <string>(0L, "Message sender must have SMTP address to protect the message: {0}", conversationOwner.DisplayName);
throw new CorruptDataException(ServerStrings.CannotProtectMessageForNonSmtpSender);
}
List <string> recipientAddresses = new List <string>(envelopeMessage.Recipients.Count);
for (int i = 0; i < envelopeMessage.Recipients.Count; i++)
{
string text = ItemToMimeConverter.TryGetParticipantSmtpAddress(rpMsgConversionAddressCache.GetRecipient(i) ?? envelopeMessage.Recipients[i].Participant);
if (!string.IsNullOrEmpty(text))
{
recipientAddresses.Add(text);
}
else
{
ExTraceGlobals.StorageTracer.TraceError <string>(0L, "Message recipient must have SMTP address to be included in the IRM message license: {0}", envelopeMessage.Recipients[i].Participant.DisplayName);
}
}
string fromAddress = string.Empty;
if (rpMsgConversionAddressCache.From != null)
{
fromAddress = ItemToMimeConverter.TryGetParticipantSmtpAddress(rpMsgConversionAddressCache.From);
if (string.IsNullOrEmpty(fromAddress))
{
ExTraceGlobals.StorageTracer.TraceError <string>(0L, "Message from participant must have SMTP address to be included in the IRM message license: {0}", rpMsgConversionAddressCache.From.DisplayName);
}
}
this.InitTenantLicenses();
MsgToRpMsgConverter.CallRM(delegate
{
internal ItemToTnefConverter(Item itemIn, OutboundAddressCache addressCache, ItemToTnefConverter.TnefContentWriter writer, OutboundConversionOptions options, ConversionLimitsTracker limits, TnefType tnefType, bool parsingEmbeddedItem) : this(itemIn, addressCache, options, limits, tnefType, parsingEmbeddedItem)
{
this.tnefWriter = writer;
this.tnefCorrelationKey = null;
this.propertyChecker = new TnefPropertyChecker(tnefType, parsingEmbeddedItem, options);
this.disposeTracker = this.GetDisposeTracker();
}
internal ItemToTnefConverter(Item itemIn, OutboundAddressCache addressCache, Stream mimeOut, OutboundConversionOptions options, ConversionLimitsTracker limits, TnefType tnefType, string tnefCorrelationKey, bool parsingEmbeddedItem) : this(itemIn, addressCache, options, limits, tnefType, parsingEmbeddedItem)
{
this.tnefCorrelationKey = tnefCorrelationKey;
Charset itemWindowsCharset = ConvertUtils.GetItemWindowsCharset(this.item, options);
this.tnefWriter = new ItemToTnefConverter.TnefContentWriter(mimeOut, itemWindowsCharset);
this.propertyChecker = new TnefPropertyChecker(tnefType, parsingEmbeddedItem, options);
this.disposeTracker = this.GetDisposeTracker();
}
public static RightsManagedMessageItem Bind(MailboxSession session, StoreId messageId, OutboundConversionOptions options, bool acquireLicense, ICollection <PropertyDefinition> propsToReturn)
{
Util.ThrowOnNullArgument(session, "session");
Util.ThrowOnNullArgument(messageId, "messageId");
Util.ThrowOnNullArgument(options, "options");
RightsManagedMessageItem.CheckSession(session);
RightsManagedMessageItem rightsManagedMessageItem = null;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
rightsManagedMessageItem = ItemBuilder.ItemBind <RightsManagedMessageItem>(session, messageId, RightsManagedMessageItemSchema.Instance, propsToReturn);
disposeGuard.Add <RightsManagedMessageItem>(rightsManagedMessageItem);
rightsManagedMessageItem.Decode(options, acquireLicense);
disposeGuard.Success();
}
return(rightsManagedMessageItem);
}
public static RightsManagedMessageItem Bind(MailboxSession session, StoreId messageId, OutboundConversionOptions options, ICollection <PropertyDefinition> propsToReturn)
{
return(RightsManagedMessageItem.Bind(session, messageId, options, true, propsToReturn));
}
public static RightsManagedMessageItem Bind(MailboxSession session, StoreId messageId, OutboundConversionOptions options, bool acquireLicense)
{
return(RightsManagedMessageItem.Bind(session, messageId, options, acquireLicense, new PropertyDefinition[0]));
}
internal static void Convert(Stream dataStream, Encoding encoding, Contact contact, OutboundConversionOptions options, ConversionLimitsTracker limitsTracker)
{
Util.ThrowOnNullArgument(options, "options");
Util.ThrowOnNullOrEmptyArgument(options.ImceaEncapsulationDomain, "options.ImceaEncapsulationDomain");
ContactWriter contactWriter = new ContactWriter(dataStream, encoding);
contactWriter.StartVCard();
OutboundVCardConverter.PropertyExporter.Context context = new OutboundVCardConverter.PropertyExporter.Context(encoding, options, limitsTracker);
foreach (OutboundVCardConverter.PropertyExporter propertyExporter in OutboundVCardConverter.exporters)
{
propertyExporter.Export(contactWriter, contact, context);
}
contactWriter.EndVCard();
}
public static RightsManagedMessageItem CreateFromInMemory(MessageItem item, MailboxSession session, StoreId destFolderId, OutboundConversionOptions options)
{
Util.ThrowOnNullArgument(item, "item");
Util.ThrowOnNullArgument(session, "session");
Util.ThrowOnNullArgument(destFolderId, "destFolderId");
Util.ThrowOnNullArgument(options, "options");
RightsManagedMessageItem.CheckSession(session);
if (item.Session != null)
{
throw new InvalidOperationException("Item should be in-memory, not backed by store.");
}
RightsManagedMessageItem result;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
RightsManagedMessageItem rightsManagedMessageItem = RightsManagedMessageItem.Create(session, destFolderId, options);
disposeGuard.Add <RightsManagedMessageItem>(rightsManagedMessageItem);
RightsManagedMessageItem.CopyProtectableData(item, rightsManagedMessageItem.decodedItem);
foreach (NativeStorePropertyDefinition nativeStorePropertyDefinition in item.AllNativeProperties)
{
if (!Body.BodyPropSet.Contains(nativeStorePropertyDefinition) && nativeStorePropertyDefinition != StoreObjectSchema.ContentClass)
{
object obj = item.TryGetProperty(nativeStorePropertyDefinition);
if (!(obj is PropertyError))
{
rightsManagedMessageItem[nativeStorePropertyDefinition] = obj;
}
else if (PropertyError.IsPropertyValueTooBig(obj))
{
using (Stream stream = item.OpenPropertyStream(nativeStorePropertyDefinition, PropertyOpenMode.ReadOnly))
{
using (Stream stream2 = rightsManagedMessageItem.OpenPropertyStream(nativeStorePropertyDefinition, PropertyOpenMode.Create))
{
Util.StreamHandler.CopyStreamData(stream, stream2);
}
}
}
}
}
rightsManagedMessageItem.Recipients.CopyRecipientsFrom(item.Recipients);
rightsManagedMessageItem.SaveFlags |= (PropertyBagSaveFlags.IgnoreMapiComputedErrors | PropertyBagSaveFlags.IgnoreUnresolvedHeaders);
disposeGuard.Success();
result = rightsManagedMessageItem;
}
return(result);
}
public static RightsManagedMessageItem Create(MailboxSession session, StoreId destFolderId, OutboundConversionOptions options)
{
Util.ThrowOnNullArgument(session, "session");
Util.ThrowOnNullArgument(destFolderId, "destFolderId");
Util.ThrowOnNullArgument(options, "options");
RightsManagedMessageItem.CheckSession(session);
RightsManagedMessageItem rightsManagedMessageItem = null;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
rightsManagedMessageItem = ItemBuilder.CreateNewItem <RightsManagedMessageItem>(session, destFolderId, ItemCreateInfo.RightsManagedMessageItemInfo, CreateMessageType.Normal);
disposeGuard.Add <RightsManagedMessageItem>(rightsManagedMessageItem);
rightsManagedMessageItem[InternalSchema.ItemClass] = "IPM.Note";
rightsManagedMessageItem.InitNewItem(options);
rightsManagedMessageItem.SetDefaultEnvelopeBody(null);
disposeGuard.Success();
}
return(rightsManagedMessageItem);
}
internal OutboundAddressCache(OutboundConversionOptions options, ConversionLimitsTracker limitsTracker) : base(limitsTracker, options.UseSimpleDisplayName, options.EwsOutboundMimeConversion)
{
this.outboundOptions = options;
}
public static void ExportCalendar(Stream outputStream, string charset, OutboundConversionOptions options, MailboxSession session, StoreObjectId folderId, ExDateTime windowStart, ExDateTime windowEnd, DetailLevelEnumType detailType)
{
EnumValidator.ThrowIfInvalid <DetailLevelEnumType>(detailType, "detailType");
PropertyDefinition[] array = InternetCalendarSchema.FromDetailLevel(detailType);
Array.IndexOf <PropertyDefinition>(array, CalendarItemBaseSchema.FreeBusyStatus);
int num = Array.IndexOf <PropertyDefinition>(array, InternalSchema.ItemId);
using (CalendarFolder calendarFolder = CalendarFolder.Bind(session, folderId))
{
object[][] array2 = calendarFolder.InternalGetCalendarView(windowStart, windowEnd, detailType == DetailLevelEnumType.AvailabilityOnly, true, true, RecurrenceExpansionOption.IncludeMaster | RecurrenceExpansionOption.TruncateMaster, array);
Item[] items = new Item[array2.Length];
try
{
for (int i = 0; i < array2.Length; i++)
{
items[i] = MessageItem.CreateInMemory(StoreObjectSchema.ContentConversionProperties);
for (int j = 0; j < array.Length; j++)
{
StorePropertyDefinition storePropertyDefinition = array[j] as StorePropertyDefinition;
if (storePropertyDefinition != null && (storePropertyDefinition.PropertyFlags & PropertyFlags.ReadOnly) != PropertyFlags.ReadOnly)
{
object obj = array2[i][j];
if (!PropertyError.IsPropertyError(obj))
{
items[i][storePropertyDefinition] = obj;
}
}
}
if (detailType == DetailLevelEnumType.FullDetails && array2[i][num] is VersionedId)
{
using (CoreItem coreItem = CoreItem.Bind(session, (VersionedId)array2[i][num], new PropertyDefinition[]
{
ItemSchema.TextBody,
ItemSchema.HtmlBody,
ItemSchema.RtfBody
}))
{
using (TextReader textReader = coreItem.Body.OpenTextReader(BodyFormat.TextPlain))
{
items[i][ItemSchema.TextBody] = textReader.ReadToEnd();
}
}
}
}
OutboundAddressCache addressCache = new OutboundAddressCache(options, new ConversionLimitsTracker(options.Limits));
List <LocalizedString> errorStream = new List <LocalizedString>();
ConvertUtils.CallCts(ExTraceGlobals.ICalTracer, "ICalSharingHelper::ExportCalendar", ServerStrings.ConversionCorruptContent, delegate
{
CalendarDocument.InternalItemsToICal(calendarFolder.DisplayName, items, null, addressCache, true, outputStream, errorStream, charset, options);
});
if (errorStream.Count > 0)
{
ExTraceGlobals.ICalTracer.TraceError <int>(0L, "{0} errors found during outbound iCal content conversion.", errorStream.Count);
AnonymousSharingLog.LogEntries(session, errorStream);
}
}
finally
{
foreach (Item item in items)
{
if (item != null)
{
item.Dispose();
}
}
}
}
}
internal Context(Encoding encoding, OutboundConversionOptions options, ConversionLimitsTracker limitsTracker)
{
this.Encoding = encoding;
this.AddressCache = new OutboundAddressCache(options, limitsTracker);
this.Options = options;
}
