WIP Replace ASSERT by real check

meson.build

@@ -1,7 +1,7 @@
 project('libzim', ['c', 'cpp'],
   version : '7.2.2',
   license : 'GPL2',
-  default_options : ['c_std=c11', 'cpp_std=c++11'])
+  default_options : ['c_std=c11', 'cpp_std=c++11', 'b_ndebug=if-release'])
 
 if build_machine.system() != 'windows'
   add_project_arguments('-D_LARGEFILE64_SOURCE=1', '-D_FILE_OFFSET_BITS=64', language: 'cpp')

src/cluster.cpp

@@ -120,7 +120,9 @@ getClusterReader(const Reader& zimReader, offset_t offset, Cluster::Compression*
     while (--n_offset)
     {
       OFFSET_TYPE new_offset = seqReader.read<OFFSET_TYPE>();
-      ASSERT(new_offset, >=, offset);
+      if (new_offset < offset) {
+        throw ZimFileFormatError("Offsets in cluster must be increasing.")
+      }
 
       m_blobOffsets.push_back(offset_t(new_offset));
       offset = new_offset;
@@ -142,6 +144,7 @@ getClusterReader(const Reader& zimReader, offset_t offset, Cluster::Compression*
       auto blobSize = getBlobSize(blob_index_t(current));
       if (blobSize.v > SIZE_MAX) {
         m_blobReaders.push_back(std::unique_ptr<Reader>(new BufferReader(Buffer::makeBuffer(zsize_t(0)))));
+        m_reader->skip(blobSize.v);
       } else {
         m_blobReaders.push_back(m_reader->sub_reader(blobSize));
       }

src/debug.h

@@ -25,7 +25,7 @@
 #include <stdexcept>
 #include <stdlib.h>
 
-#if defined (NDEBUG)
+#if 1
 # define ASSERT(left, operator, right) (void(0))
 #else
 

src/file_reader.cpp

@@ -63,6 +63,9 @@ MultiPartFileReader::MultiPartFileReader(std::shared_ptr<const FileCompound> sou
 
 char MultiPartFileReader::read(offset_t offset) const {
   ASSERT(offset.v, <, _size.v);
+  if (offset.v >= _size.v) {
+    throw std::runtime_error("Error while reading out of reader");
+  }
   offset += _offset;
   auto part_pair = source->locate(offset);
   auto& fhandle = part_pair->second->fhandle();

src/fs_unix.cpp

@@ -49,7 +49,10 @@ zsize_t FD::readAt(char* dest, zsize_t size, offset_t offset) const
   while (size_to_read > 0) {
     auto size_read = PREAD(m_fd, dest, size_to_read, current_offset);
     if (size_read == -1) {
-      return zsize_t(-1);
+      throw std::runtime_error("Error while reading.");
+    }
+    if (size_read == 0) {
+      throw std::runtime_error("Error reading after the end of file.");
     }
     size_to_read -= size_read;
     current_offset += size_read;

src/istreamreader.h

@@ -60,6 +60,9 @@ class IStreamReader
   // Reads a blob of the specified size from the stream
   virtual std::unique_ptr<const Reader> sub_reader(zsize_t size);
 
+  // Skip a amount of bytes in the stream
+  virtual void skip(zsize_t size);
+
 private: // virtual methods
   // Reads exactly 'nbytes' bytes into the provided buffer 'buf'
   // (which must be at least that big). Throws an exception if

src/writer/creator.cpp

@@ -396,6 +396,7 @@ namespace zim
         clusterSize(clusterSize),
         withIndex(withIndex),
         indexingLanguage(language),
+        mimeTypeLeftSpace(CLUSTER_BASE_OFFSET-80),
         verbose(verbose),
         nbRedirectItems(0),
         nbCompItems(0),
@@ -660,8 +661,13 @@ namespace zim
       auto it = mimeTypesMap.find(mimeType);
       if (it == mimeTypesMap.end())
       {
-        if (nextMimeIdx >= std::numeric_limits<uint16_t>::max())
+        if (nextMimeIdx >= std::numeric_limits<uint16_t>::max()) {
           throw std::runtime_error("too many distinct mime types");
+        }
+        if (mimeType.size() >= mimeTypeLeftSpace) {
+          throw std::runtime_error("Too many mime types for the space we have allocated");
+        }
+        mimeTypeLeftSpace -= mimeType.size() - 1;
         mimeTypesMap[mimeType] = nextMimeIdx;
         rmimeTypesMap[nextMimeIdx] = mimeType;
         return nextMimeIdx++;

test/reader.cpp

@@ -93,7 +93,9 @@ TEST(FileReader, shouldJustWork)
     ASSERT_THROW(reader->read(offset_t(26)), std::runtime_error);
     ASSERT_THROW(reader->read(out, offset_t(25), zsize_t(4)), std::runtime_error);
     ASSERT_THROW(reader->read(out, offset_t(30), zsize_t(4)), std::runtime_error);
-    ASSERT_THROW(reader->read(out, offset_t(30), zsize_t(0)), std::runtime_error);
+    // Reading 0 bytes is a no op. The (debug) ASSERT is catching the wrong offset first,
+    // but in release, without assert, this is really a noop and no error must be checked.
+    //ASSERT_THROW(reader->read(out, offset_t(30), zsize_t(0)), std::runtime_error);
   }
 }