- fix issues with stream being trucated

Tiefseetauchner · Sep 14, 2024 · a14425e · a14425e
1 parent 2f56b5b
commit a14425e
Show file tree

Hide file tree

Showing 14 changed files with 100 additions and 72 deletions.
diff --git a/Pdfer/EncodingDetector.cs b/Pdfer/EncodingDetector.cs
@@ -0,0 +1,30 @@
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Pdfer;
+
+public class EncodingDetector : IEncodingDetector
+{
+  public async Task<Encoding> DetectEncoding(Stream stream)
+  {
+    var bytes = new byte[3];
+
+    if (await stream.ReadAsync(bytes) < 3)
+      throw new IOException("Unexpected end of stream");
+
+    if (bytes[0] == 0xEF && bytes[1] == 0xBB && bytes[2] == 0xBF)
+      return Encoding.UTF8;
+    if (bytes[0] == 0xFE && bytes[1] == 0xFF)
+      return Encoding.BigEndianUnicode;
+    if (bytes[0] == 0xFF && bytes[1] == 0xFE)
+      return Encoding.Unicode;
+
+    return Encoding.Default;
+  }
+}
+
+public interface IEncodingDetector
+{
+  Task<Encoding> DetectEncoding(Stream stream);
+}
diff --git a/Pdfer/ObjectIdentifier.cs b/Pdfer/ObjectIdentifier.cs
@@ -13,7 +13,7 @@ public static ObjectIdentifier ParseReference(string objectIdentifier)
   }
 
   public byte[] GetHeaderBytes() =>
-    Encoding.ASCII.GetBytes(GetHeaderString());
+    Encoding.UTF8.GetBytes(GetHeaderString());
 
   public string GetHeaderString() =>
     $"{ObjectNumber} {Generation} obj\n";

diff --git a/Pdfer/Objects/ArrayObjectSerializer.cs b/Pdfer/Objects/ArrayObjectSerializer.cs
@@ -5,15 +5,10 @@ namespace Pdfer.Objects;
 
 public class ArrayObjectSerializer(IPdfArrayHelper pdfArrayHelper) : IDocumentObjectSerializer<ArrayObject>
 {
-  public async Task<byte[]> Serialize(ArrayObject documentObject)
+  public async Task Serialize(Stream stream, ArrayObject documentObject)
   {
-    using var memoryStream = new MemoryStream();
-
-    await memoryStream.WriteAsync(documentObject.ObjectIdentifier.GetHeaderBytes());
-    await pdfArrayHelper.WriteArray(memoryStream, documentObject.Value);
-    await memoryStream.WriteAsync("\nendobj"u8.ToArray());
-
-    return memoryStream.ToArray();
-
+    await stream.WriteAsync(documentObject.ObjectIdentifier.GetHeaderBytes());
+    await pdfArrayHelper.WriteArray(stream, documentObject.Value);
+    await stream.WriteAsync("\nendobj"u8.ToArray());
   }
 }
diff --git a/Pdfer/Objects/DictionaryObjectSerializer.cs b/Pdfer/Objects/DictionaryObjectSerializer.cs
@@ -5,14 +5,10 @@ namespace Pdfer.Objects;
 
 public class DictionaryObjectSerializer(IPdfDictionaryHelper pdfDictionaryHelper) : IDocumentObjectSerializer<DictionaryObject>
 {
-  public async Task<byte[]> Serialize(DictionaryObject documentObject)
+  public async Task Serialize(Stream stream, DictionaryObject documentObject)
   {
-    using var memoryStream = new MemoryStream();
-
-    await memoryStream.WriteAsync(documentObject.ObjectIdentifier.GetHeaderBytes());
-    await pdfDictionaryHelper.WriteDictionary(memoryStream, documentObject.Value);
-    await memoryStream.WriteAsync("\nendobj"u8.ToArray());
-
-    return memoryStream.ToArray();
+    await stream.WriteAsync(documentObject.ObjectIdentifier.GetHeaderBytes());
+    await pdfDictionaryHelper.WriteDictionary(stream, documentObject.Value);
+    await stream.WriteAsync("\nendobj"u8.ToArray());
   }
 }
diff --git a/Pdfer/Objects/IDocumentObjectSerializer.cs b/Pdfer/Objects/IDocumentObjectSerializer.cs
@@ -1,8 +1,9 @@
+using System.IO;
 using System.Threading.Tasks;
 
 namespace Pdfer.Objects;
 
 public interface IDocumentObjectSerializer<T> where T : DocumentObject
 {
-  Task<byte[]> Serialize(T documentObject);
+  Task Serialize(Stream stream, T documentObject);
 }
diff --git a/Pdfer/Objects/NameObjectSerializer.cs b/Pdfer/Objects/NameObjectSerializer.cs
@@ -6,14 +6,10 @@ namespace Pdfer.Objects;
 
 public class NameObjectSerializer : IDocumentObjectSerializer<NameObject>
 {
-  public async Task<byte[]> Serialize(NameObject documentObject)
+  public async Task Serialize(Stream stream, NameObject documentObject)
   {
-    using var memoryStream = new MemoryStream();
-
-    await memoryStream.WriteAsync(documentObject.ObjectIdentifier.GetHeaderBytes());
-    await memoryStream.WriteAsync(Encoding.ASCII.GetBytes(documentObject.Value));
-    await memoryStream.WriteAsync("\nendobj"u8.ToArray());
-
-    return memoryStream.ToArray();
+    await stream.WriteAsync(documentObject.ObjectIdentifier.GetHeaderBytes());
+    await stream.WriteAsync(Encoding.UTF8.GetBytes(documentObject.Value));
+    await stream.WriteAsync("\nendobj"u8.ToArray());
   }
 }
diff --git a/Pdfer/Objects/NumberObjectSerializer.cs b/Pdfer/Objects/NumberObjectSerializer.cs
@@ -7,24 +7,20 @@ namespace Pdfer.Objects;
 
 public class NumberObjectSerializer() : IDocumentObjectSerializer<NumberObject>
 {
-  public async Task<byte[]> Serialize(NumberObject documentObject)
+  public async Task Serialize(Stream stream, NumberObject documentObject)
   {
-    using var memoryStream = new MemoryStream();
-
-    await memoryStream.WriteAsync(documentObject.ObjectIdentifier.GetHeaderBytes());
+    await stream.WriteAsync(documentObject.ObjectIdentifier.GetHeaderBytes());
 
     switch (documentObject)
     {
       case FloatObject floatObject:
-        await memoryStream.WriteAsync(Encoding.ASCII.GetBytes(floatObject.Value.ToString(CultureInfo.InvariantCulture)));
+        await stream.WriteAsync(Encoding.UTF8.GetBytes(floatObject.Value.ToString(CultureInfo.InvariantCulture)));
         break;
       case IntegerObject integerObject:
-        await memoryStream.WriteAsync(Encoding.ASCII.GetBytes(integerObject.Value.ToString()));
+        await stream.WriteAsync(Encoding.UTF8.GetBytes(integerObject.Value.ToString()));
         break;
     }
 
-    await memoryStream.WriteAsync("\nendobj"u8.ToArray());
-
-    return memoryStream.ToArray();
+    await stream.WriteAsync("\nendobj"u8.ToArray());
   }
 }
diff --git a/Pdfer/Objects/PdfObjectReader.cs b/Pdfer/Objects/PdfObjectReader.cs
@@ -48,7 +48,7 @@ public async Task<DocumentObject> Read(Stream stream, XRefEntry xRefEntry, Objec
 
       var buffer = new byte[7];
       _ = await stream.ReadAsync(buffer);
-      var contentAfterDictionary = Encoding.ASCII.GetString(buffer);
+      var contentAfterDictionary = Encoding.UTF8.GetString(buffer);
       stream.Position = streamPositionAfterObjectStart;
 
       if (contentAfterDictionary.Trim().StartsWith("stream"))

diff --git a/Pdfer/Objects/StreamObjectReader.cs b/Pdfer/Objects/StreamObjectReader.cs
@@ -21,6 +21,9 @@ public async Task<StreamObject> Read(Stream stream, IObjectRepository objectRepo
         ?? throw new ArgumentException("Invalid length of stream object");
     stream.Position = oldPosition;
 
+    await streamHelper.ReadStreamTo("stream", stream);
+    await streamHelper.SkipWhiteSpaceCharacters(stream);
+
     var buffer = new byte[length];
     var bytesRead = await stream.ReadAsync(buffer);
 

diff --git a/Pdfer/Objects/StreamObjectSerializer.cs b/Pdfer/Objects/StreamObjectSerializer.cs
@@ -5,16 +5,13 @@ namespace Pdfer.Objects;
 
 public class StreamObjectSerializer(PdfDictionaryHelper pdfDictionaryHelper) : IDocumentObjectSerializer<StreamObject>
 {
-  public async Task<byte[]> Serialize(StreamObject documentObject)
+  public async Task Serialize(Stream stream, StreamObject documentObject)
   {
-    using var memoryStream = new MemoryStream();
-
-    await memoryStream.WriteAsync(documentObject.ObjectIdentifier.GetHeaderBytes());
-    await pdfDictionaryHelper.WriteDictionary(memoryStream, documentObject.Dictionary);
-    await memoryStream.WriteAsync(documentObject.Value);
-    await memoryStream.WriteAsync("\nendstream"u8.ToArray());
-    await memoryStream.WriteAsync("\nendobj"u8.ToArray());
-
-    return memoryStream.ToArray();
+    await stream.WriteAsync(documentObject.ObjectIdentifier.GetHeaderBytes());
+    await pdfDictionaryHelper.WriteDictionary(stream, documentObject.Dictionary);
+    await stream.WriteAsync("\nstream\n"u8.ToArray());
+    await stream.WriteAsync(documentObject.Value);
+    await stream.WriteAsync("\nendstream"u8.ToArray());
+    await stream.WriteAsync("\nendobj"u8.ToArray());
   }
 }
diff --git a/Pdfer/Objects/StringObjectSerializer.cs b/Pdfer/Objects/StringObjectSerializer.cs
@@ -6,15 +6,11 @@ namespace Pdfer.Objects;
 
 public class StringObjectSerializer : IDocumentObjectSerializer<StringObject>
 {
-  public async Task<byte[]> Serialize(StringObject documentObject)
+  public async Task Serialize(Stream stream, StringObject documentObject)
   {
-    using var memoryStream = new MemoryStream();
-
-    await memoryStream.WriteAsync(documentObject.ObjectIdentifier.GetHeaderBytes());
-    await memoryStream.WriteAsync("\n"u8.ToArray());
-    await memoryStream.WriteAsync(Encoding.UTF8.GetBytes(documentObject.Value));
-    await memoryStream.WriteAsync("\nendobj"u8.ToArray());
-
-    return memoryStream.ToArray();
+    await stream.WriteAsync(documentObject.ObjectIdentifier.GetHeaderBytes());
+    await stream.WriteAsync("\n"u8.ToArray());
+    await stream.WriteAsync(Encoding.UTF8.GetBytes(documentObject.Value));
+    await stream.WriteAsync("\nendobj"u8.ToArray());
   }
 }
diff --git a/Pdfer/PdfArrayHelper.cs b/Pdfer/PdfArrayHelper.cs
@@ -63,7 +63,7 @@ public async Task WriteArray(Stream stream, string[] array)
 
     foreach (var value in array)
     {
-      await stream.WriteAsync(Encoding.ASCII.GetBytes(value));
+      await stream.WriteAsync(Encoding.UTF8.GetBytes(value));
       await stream.WriteAsync(" "u8.ToArray());
     }
 

diff --git a/Pdfer/PdfDictionaryHelper.cs b/Pdfer/PdfDictionaryHelper.cs
@@ -63,9 +63,13 @@ public class PdfDictionaryHelper(IStreamHelper streamHelper) : IPdfDictionaryHel
       switch (character)
       {
         case '<' when bufferStringBuilder.Length == 0 || bufferStringBuilder[^1] != '\\':
+        case '[' when bufferStringBuilder.Length == 0 || bufferStringBuilder[^1] != '\\':
+        case '(' when bufferStringBuilder.Length == 0 || bufferStringBuilder[^1] != '\\':
           bracketDepth++;
           break;
         case '>' when bufferStringBuilder.Length == 0 || bufferStringBuilder[^1] != '\\':
+        case ']' when bufferStringBuilder.Length == 0 || bufferStringBuilder[^1] != '\\':
+        case ')' when bufferStringBuilder.Length == 0 || bufferStringBuilder[^1] != '\\':
           bracketDepth--;
           break;
       }
@@ -104,9 +108,9 @@ public async Task WriteDictionary(Stream stream, Dictionary<string, string> dict
     foreach (var (key, value) in dictionary)
     {
       await stream.WriteAsync("\n"u8.ToArray());
-      await stream.WriteAsync(Encoding.ASCII.GetBytes(key));
+      await stream.WriteAsync(Encoding.UTF8.GetBytes(key));
       await stream.WriteAsync(" "u8.ToArray());
-      await stream.WriteAsync(Encoding.ASCII.GetBytes(value));
+      await stream.WriteAsync(Encoding.UTF8.GetBytes(value));
     }
 
     await stream.WriteAsync(">>"u8.ToArray());

diff --git a/Pdfer/PdfDocumentWriter.cs b/Pdfer/PdfDocumentWriter.cs
@@ -71,20 +71,34 @@ private async Task<XRefTable> WriteBody(Stream stream, Body pdfDocumentBody)
     return xRefTable;
   }
 
+  // TODO (lena): Write to stream directly
   private async Task WriteObject(Stream stream, DocumentObject value)
   {
-    var bytes = value switch
+    switch (value)
     {
-      DictionaryObject dictionaryObject => await dictionaryObjectSerializer.Serialize(dictionaryObject),
-      NumberObject numberObject => await numberObjectSerializer.Serialize(numberObject),
-      StreamObject streamObject => await streamObjectSerializer.Serialize(streamObject),
-      StringObject stringObject => await stringObjectSerializer.Serialize(stringObject),
-      NameObject nameObject => await nameObjectSerializer.Serialize(nameObject),
-      ArrayObject arrayObject => await arrayObjectSerializer.Serialize(arrayObject),
-      _ => throw new InvalidOperationException($"Unknown object type '{value.GetType()}'")
-    };
+      case DictionaryObject dictionaryObject:
+        await dictionaryObjectSerializer.Serialize(stream, dictionaryObject);
+        break;
+      case NumberObject numberObject:
+        await numberObjectSerializer.Serialize(stream, numberObject);
+        break;
+      case StreamObject streamObject:
+        await streamObjectSerializer.Serialize(stream, streamObject);
+        break;
+      case StringObject stringObject:
+        await stringObjectSerializer.Serialize(stream, stringObject);
+        break;
+      case NameObject nameObject:
+        await nameObjectSerializer.Serialize(stream, nameObject);
+        break;
+      case ArrayObject arrayObject:
+        await arrayObjectSerializer.Serialize(stream, arrayObject);
+        break;
+      default:
+        throw new InvalidOperationException($"Unknown object type '{value.GetType()}'");
+    }
 
-    await stream.WriteAsync(bytes);
+    await stream.FlushAsync();
   }
 
   private long WriteXrefTable(Stream stream, XRefTable xRefTable)
@@ -125,10 +139,10 @@ private void WriteXrefTableSection(Stream stream, List<string> xRefTableSection,
     if (xRefTableSection.Count == 0)
       return;
 
-    stream.Write(Encoding.ASCII.GetBytes($"{firstObjectNumberInSection} {xRefTableSection.Count.ToString()}\n"));
+    stream.Write(Encoding.UTF8.GetBytes($"{firstObjectNumberInSection} {xRefTableSection.Count.ToString()}\n"));
 
     var xRefTableEntries = string.Concat(xRefTableSection);
-    stream.Write(Encoding.ASCII.GetBytes(xRefTableEntries));
+    stream.Write(Encoding.UTF8.GetBytes(xRefTableEntries));
   }
 
   // TODO (lena): Change Size in Trailer
@@ -140,7 +154,7 @@ private async Task WriteTrailer(Stream stream, Trailer pdfDocumentTrailer, long
 
     await stream.WriteAsync("\n"u8.ToArray());
     await stream.WriteAsync("startxref\n"u8.ToArray());
-    await stream.WriteAsync(Encoding.ASCII.GetBytes(xRefTableOffset.ToString()));
+    await stream.WriteAsync(Encoding.UTF8.GetBytes(xRefTableOffset.ToString()));
     await stream.WriteAsync("\n"u8.ToArray());
     await stream.WriteAsync("%%EOF\n"u8.ToArray());
   }