private static void OnNewConverterCreatedCallback(IComWorker <IOleConverter> converterProcess, object requestParameters)
{
IOleConverter worker = converterProcess.Worker;
uint num = 0U;
string conversionsDirectory = OleConverter.GetConversionsDirectory(true);
if (conversionsDirectory == null)
{
StorageGlobals.ContextTraceError(ExTraceGlobals.CcOleTracer, "OleConverter::OnNewConverterCreatedCallback: conversions directory full or inaccessible.");
throw new OleConversionFailedException(ServerStrings.OleConversionFailed);
}
int num2;
worker.ConfigureConverter(out num2, 4194304U, 262144U, conversionsDirectory, out num);
if (num2 != 0)
{
StorageGlobals.ContextTraceError(ExTraceGlobals.CcOleTracer, "OleConverter::OnNewConverterCreatedCallback: failed to configure converter.");
throw new OleConversionFailedException(ServerStrings.OleConversionFailed, new COMException("HRESULT =", num2));
}
if (num != (uint)converterProcess.ProcessId)
{
StorageGlobals.ContextTraceError(ExTraceGlobals.CcOleTracer, "OleConverter::OnNewConverterCreatedCallback: process id mismatch.");
throw new OleConversionFailedException(ServerStrings.OleConversionInitError(Process.GetCurrentProcess().ProcessName, converterProcess.ProcessId, (int)num));
}
}
private static string SaveStreamToTempFile(Stream stream)
{
StringBuilder stringBuilder = new StringBuilder(256);
string conversionsDirectory = OleConverter.GetConversionsDirectory(true);
if (NativeMethods.GetTempFileName(conversionsDirectory, "ole", 0U, stringBuilder) == 0)
{
StorageGlobals.ContextTraceError <string, int>(ExTraceGlobals.CcOleTracer, "OleConverter::SaveStreamToTempFile: failed to create temp file name, directory = {0}. Error {1}", conversionsDirectory, Marshal.GetLastWin32Error());
throw new OleConversionFailedException(ServerStrings.OleConversionPrepareFailed);
}
try
{
using (FileStream fileStream = new FileStream(stringBuilder.ToString(), FileMode.OpenOrCreate, FileAccess.Write))
{
Util.StreamHandler.CopyStreamData(stream, fileStream);
fileStream.Close();
}
}
catch (IOException arg)
{
OleConverter.DeleteTempFile(stringBuilder.ToString());
StorageGlobals.ContextTraceError <IOException>(ExTraceGlobals.CcOleTracer, "OleConverter::SaveStreamToTempFile: IOException caught. Exception:\n {0}", arg);
throw new OleConversionFailedException(ServerStrings.OleConversionPrepareFailed);
}
return(stringBuilder.ToString());
}
private static Stream CreateResultStream(object result)
{
string text = result as string;
if (text != null)
{
try
{
return(new OleConverter.ConversionResultFileStream(text));
}
catch (IOException arg)
{
OleConverter.DeleteTempFile(text);
StorageGlobals.ContextTraceError <IOException>(ExTraceGlobals.CcOleTracer, "OleConverter::CreateResultStream: IOException caught. Exception:\n {0}", arg);
throw new OleConversionFailedException(ServerStrings.OleConversionResultFailed);
}
}
byte[] array = result as byte[];
if (array != null)
{
return(new MemoryStream(array));
}
StorageGlobals.ContextTraceError <Type>(ExTraceGlobals.CcOleTracer, "OleConverter::CreateResultStream: result type is invalid, {0}.", result.GetType());
throw new OleConversionFailedException(ServerStrings.OleConversionInvalidResultType);
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (!this.isDeleted && this.filename != null)
{
OleConverter.DeleteTempFile(this.filename);
this.isDeleted = true;
}
}
public override void Close()
{
base.Close();
if (!this.isDeleted)
{
OleConverter.DeleteTempFile(this.filename);
this.isDeleted = true;
}
}
private static void DestroyOleObjectData(object oleObjectData)
{
string text = oleObjectData as string;
if (text != null)
{
OleConverter.DeleteTempFile(text);
}
}
private static void DirectoryCleanup(object cleanupLock, bool isForced)
{
string conversionsDirectory = OleConverter.GetConversionsDirectory(false);
if (conversionsDirectory == null)
{
return;
}
try
{
if (Monitor.TryEnter(cleanupLock) || (isForced && Monitor.TryEnter(cleanupLock, 30000)))
{
NativeMethods.WIN32_FIND_DATA win32_FIND_DATA = default(NativeMethods.WIN32_FIND_DATA);
using (SafeFindHandle safeFindHandle = NativeMethods.FindFirstFile(Path.Combine(conversionsDirectory, "*"), out win32_FIND_DATA))
{
if (!safeFindHandle.IsInvalid)
{
do
{
if ((win32_FIND_DATA.FileAttributes & NativeMethods.FileAttributes.Directory) != NativeMethods.FileAttributes.Directory)
{
ExDateTime fileCreateTimeUtc = OleConverter.GetFileCreateTimeUtc(ref win32_FIND_DATA);
TimeSpan t = ExDateTime.UtcNow.Subtract(fileCreateTimeUtc);
if (t > OleConverter.MaxFileLifetime)
{
NativeMethods.DeleteFile(Path.Combine(conversionsDirectory, win32_FIND_DATA.FileName));
}
}
}while (NativeMethods.FindNextFile(safeFindHandle, out win32_FIND_DATA));
}
}
}
}
finally
{
if (Monitor.IsEntered(cleanupLock))
{
Monitor.Exit(cleanupLock);
}
}
}
private static object CreateOleObjectData(Stream oleDataStream, bool canCacheInMemory)
{
if (canCacheInMemory && oleDataStream.CanSeek)
{
long length = oleDataStream.Length;
if (length <= 262144L)
{
byte[] array = new byte[length];
int num;
for (int i = 0; i < array.Length; i += num)
{
num = oleDataStream.Read(array, i, (int)length - i);
if (num == 0)
{
StorageGlobals.ContextTraceError(ExTraceGlobals.CcOleTracer, "OleConverter::CreateOleObjectData: unable to load full stream.");
throw new OleConversionFailedException(ServerStrings.OleUnableToReadAttachment);
}
}
return(array);
}
}
return(OleConverter.SaveStreamToTempFile(oleDataStream));
}
private Stream ConvertToBitmap()
{
Stream stream = null;
using (StorageGlobals.SetTraceContext(this))
{
if (StandaloneFuzzing.IsEnabled)
{
using (Bitmap bitmap = new Bitmap(1, 1))
{
stream = new MemoryStream();
bitmap.Save(stream, ImageFormat.Jpeg);
goto IL_5C;
}
}
OleConverter instance = OleConverter.Instance;
using (Stream contentStream = this.GetContentStream(PropertyOpenMode.ReadOnly))
{
stream = instance.ConvertToBitmap(contentStream);
}
IL_5C :;
}
return(stream);
}
private static void DirectoryCleanup(object cleanupLock)
{
OleConverter.DirectoryCleanup(cleanupLock, false);
}
internal void ForceRunDirectoryCleanup()
{
OleConverter.DirectoryCleanup(this.cleanupLock, true);
}
internal Stream ConvertToBitmap(Stream oleDataStream)
{
object obj = null;
int num = Interlocked.Increment(ref this.nQueueSize);
Stream result;
try
{
try
{
bool canCacheInMemory = num <= 30;
obj = OleConverter.CreateOleObjectData(oleDataStream, canCacheInMemory);
OleConverter.ConversionRequestParameters conversionRequestParameters = new OleConverter.ConversionRequestParameters(obj, null);
base.ExecuteRequest(conversionRequestParameters);
result = OleConverter.CreateResultStream(conversionRequestParameters.ResponseData);
}
catch (ComInterfaceInitializeException ex)
{
StorageGlobals.ContextTraceError <ComInterfaceInitializeException>(ExTraceGlobals.CcOleTracer, "OleConverter::ConvertToBitmap: ole conversion failed. Exception:\n {0}", ex);
throw new OleConversionServerBusyException(ServerStrings.OleConversionFailed, ex);
}
catch (ComProcessBusyException ex2)
{
StorageGlobals.ContextTraceError <ComProcessBusyException>(ExTraceGlobals.CcOleTracer, "OleConverter::ConvertToBitmap: ole conversion failed. Exception:\n {0}", ex2);
throw new OleConversionServerBusyException(ServerStrings.OleConversionFailed, ex2);
}
catch (ComProcessTimeoutException ex3)
{
StorageGlobals.ContextTraceError <ComProcessTimeoutException>(ExTraceGlobals.CcOleTracer, "OleConverter::ConvertToBitmap: ole conversion failed. Exception:\n {0}", ex3);
throw new OleConversionFailedException(ServerStrings.OleConversionFailed, ex3);
}
catch (ComProcessBeyondMemoryLimitException ex4)
{
StorageGlobals.ContextTraceError <ComProcessBeyondMemoryLimitException>(ExTraceGlobals.CcOleTracer, "OleConverter::ConvertToBitmap: ole conversion failed. Exception:\n {0}", ex4);
throw new OleConversionFailedException(ServerStrings.OleConversionFailed, ex4);
}
catch (COMException ex5)
{
StorageGlobals.ContextTraceError <COMException>(ExTraceGlobals.CcOleTracer, "OleConverter::ConvertToBitmap: ole conversion failed. Exception:\n {0}", ex5);
throw new OleConversionFailedException(ServerStrings.OleConversionFailed, ex5);
}
catch (InvalidComObjectException ex6)
{
StorageGlobals.ContextTraceError <InvalidComObjectException>(ExTraceGlobals.CcOleTracer, "OleConverter::ConvertToBitmap: ole conversion failed. Exception:\n {0}", ex6);
throw new OleConversionFailedException(ServerStrings.OleConversionFailed, ex6);
}
catch (InvalidCastException ex7)
{
StorageGlobals.ContextTraceError <InvalidCastException>(ExTraceGlobals.CcOleTracer, "OleConverter::ConvertToBitmap: ole conversion failed. Exception:\n {0}", ex7);
throw new OleConversionFailedException(ServerStrings.OleConversionFailed, ex7);
}
catch (NoSupportException ex8)
{
StorageGlobals.ContextTraceError <NoSupportException>(ExTraceGlobals.CcOleTracer, "OleConverter::ConvertToBitmap: ole conversion failed. Exception:\n {0}", ex8);
throw new OleConversionFailedException(ServerStrings.OleConversionFailed, ex8);
}
}
catch (StoragePermanentException exc)
{
OleConverter.SaveFailedConversionData(obj, exc, null);
throw;
}
catch (StorageTransientException exc2)
{
OleConverter.SaveFailedConversionData(obj, exc2, null);
throw;
}
finally
{
Interlocked.Decrement(ref this.nQueueSize);
if (obj != null)
{
OleConverter.DestroyOleObjectData(obj);
}
}
return(result);
}
