Merge pull request #2251 from kevinbackhouse/basicio-ftell

Change return type of BasicIo::tell() to size_t

Author: kevinbackhouse

include/exiv2/basicio.hpp

@@ -198,10 +198,9 @@ class EXIV2API BasicIo {
   //@{
   /*!
     @brief Get the current IO position.
-    @return Offset from the start of IO if successful;<BR>
-           -1 if failure;
+    @return Offset from the start of IO
    */
-  [[nodiscard]] virtual long tell() const = 0;
+  [[nodiscard]] virtual size_t tell() const = 0;
   /*!
     @brief Get the current size of the IO source in bytes.
     @return Size of the IO source in bytes;<BR>
@@ -439,10 +438,9 @@ class EXIV2API FileIo : public BasicIo {
   //@{
   /*!
     @brief Get the current file position.
-    @return Offset from the start of the file if successful;<BR>
-           -1 if failure;
+    @return Offset from the start of the file
    */
-  [[nodiscard]] long tell() const override;
+  [[nodiscard]] size_t tell() const override;
   /*!
     @brief Flush any buffered writes and get the current file size
         in bytes.
@@ -624,7 +622,7 @@ class EXIV2API MemIo : public BasicIo {
     @brief Get the current IO position.
     @return Offset from the start of the memory block
    */
-  [[nodiscard]] long tell() const override;
+  [[nodiscard]] size_t tell() const override;
   /*!
     @brief Get the current memory buffer size in bytes.
     @return Size of the in memory data in bytes;<BR>
@@ -874,7 +872,7 @@ class EXIV2API RemoteIo : public BasicIo {
     @brief Get the current IO position.
     @return Offset from the start of the memory block
    */
-  [[nodiscard]] long tell() const override;
+  [[nodiscard]] size_t tell() const override;
   /*!
     @brief Get the current memory buffer size in bytes.
     @return Size of the in memory data in bytes;<BR>

include/exiv2/bmffimage.hpp

@@ -122,13 +122,13 @@ class EXIV2API BmffImage : public Image {
     @return address of next box
     @warning This function should only be called by readMetadata()
    */
-  long boxHandler(std::ostream& out, Exiv2::PrintStructureOption option, long pbox_end, int depth);
+  uint64_t boxHandler(std::ostream& out, Exiv2::PrintStructureOption option, uint64_t pbox_end, int depth);
   [[nodiscard]] static std::string indent(int i) {
     return std::string(2 * i, ' ');
   }
 
   uint32_t fileType_{0};
-  std::set<uint64_t> visits_;
+  std::set<size_t> visits_;
   uint64_t visits_max_{0};
   uint16_t unknownID_{0xffff};
   uint16_t exifID_{0xffff};
@@ -140,7 +140,7 @@ class EXIV2API BmffImage : public Image {
   /*!
     @brief box utilities
    */
-  static std::string toAscii(long n);
+  static std::string toAscii(uint32_t n);
   std::string boxName(uint32_t box);
   static bool superBox(uint32_t box);
   static bool fullBox(uint32_t box);

include/exiv2/webpimage.hpp

@@ -63,12 +63,13 @@ class EXIV2API WebPImage : public Image {
 
  private:
   void doWriteMetadata(BasicIo& outIo);
-  //! @name NOT Implemented
-  //@{
-  static long getHeaderOffset(const byte* data, size_t data_size, const byte* header, size_t header_size);
+
+  //! Finds the offset of header in data. Returns std::string::npos if the header isn't found.
+  static size_t getHeaderOffset(const byte* data, size_t data_size, const byte* header, size_t header_size);
+
   static bool equalsWebPTag(Exiv2::DataBuf& buf, const char* str);
-  void debugPrintHex(byte* data, long size);
-  void decodeChunks(long filesize);
+  void debugPrintHex(byte* data, size_t size);
+  void decodeChunks(uint32_t filesize);
   void inject_VP8X(BasicIo& iIo, bool has_xmp, bool has_exif, bool has_alpha, bool has_icc, int width, int height);
   /* Misc. */
   static constexpr byte WEBP_PAD_ODD = 0;

src/basicio.cpp

@@ -458,8 +458,10 @@ int FileIo::seek(int64_t offset, Position pos) {
 #endif
 }
 
-long FileIo::tell() const {
-  return std::ftell(p_->fp_);
+size_t FileIo::tell() const {
+  const long pos = std::ftell(p_->fp_);
+  enforce(pos >= 0, ErrorCode::kerInputDataReadFailed);
+  return static_cast<size_t>(pos);
 }
 
 size_t FileIo::size() const {
@@ -786,8 +788,8 @@ int MemIo::munmap() {
   return 0;
 }
 
-long MemIo::tell() const {
-  return static_cast<long>(p_->idx_);
+size_t MemIo::tell() const {
+  return p_->idx_;
 }
 
 size_t MemIo::size() const {
@@ -1341,8 +1343,8 @@ int RemoteIo::munmap() {
   return 0;
 }
 
-long RemoteIo::tell() const {
-  return static_cast<long>(p_->idx_);
+size_t RemoteIo::tell() const {
+  return p_->idx_;
 }
 
 size_t RemoteIo::size() const {

src/bmffimage.cpp

@@ -74,7 +74,7 @@ BmffImage::BmffImage(BasicIo::UniquePtr io, bool /* create */) :
     Image(ImageType::bmff, mdExif | mdIptc | mdXmp, std::move(io)) {
 }  // BmffImage::BmffImage
 
-std::string BmffImage::toAscii(long n) {
+std::string BmffImage::toAscii(uint32_t n) {
   const auto p = reinterpret_cast<const char*>(&n);
   std::string result;
   for (int i = 0; i < 4; i++) {
@@ -152,9 +152,9 @@ std::string BmffImage::uuidName(Exiv2::DataBuf& uuid) {
   return result;
 }
 
-long BmffImage::boxHandler(std::ostream& out /* = std::cout*/, Exiv2::PrintStructureOption option /* = kpsNone */,
-                           long pbox_end, int depth) {
-  long address = io_->tell();
+uint64_t BmffImage::boxHandler(std::ostream& out /* = std::cout*/, Exiv2::PrintStructureOption option /* = kpsNone */,
+                               uint64_t pbox_end, int depth) {
+  const size_t address = io_->tell();
   // never visit a box twice!
   if (depth == 0)
     visits_.clear();
@@ -198,22 +198,22 @@ long BmffImage::boxHandler(std::ostream& out /* = std::cout*/, Exiv2::PrintStruc
   }
 
   // read data in box and restore file position
-  long restore = io_->tell();
+  const size_t restore = io_->tell();
   enforce(box_length >= hdrsize, Exiv2::ErrorCode::kerCorruptedMetadata);
-  enforce(box_length - hdrsize <= static_cast<uint64_t>(pbox_end - restore), Exiv2::ErrorCode::kerCorruptedMetadata);
+  enforce(box_length - hdrsize <= pbox_end - restore, Exiv2::ErrorCode::kerCorruptedMetadata);
 
-  const auto buffer_size = static_cast<size_t>(box_length - hdrsize);
+  const auto buffer_size = box_length - hdrsize;
   if (skipBox(box_type)) {
     if (bTrace) {
       out << std::endl;
     }
     // The enforce() above checks that restore + buffer_size won't
     // exceed pbox_end, and by implication, won't exceed LONG_MAX
-    return restore + static_cast<long>(buffer_size);
+    return restore + buffer_size;
   }
 
-  DataBuf data(buffer_size);
-  const long box_end = restore + static_cast<long>(data.size());
+  DataBuf data(static_cast<size_t>(buffer_size));
+  const size_t box_end = restore + data.size();
   io_->read(data.data(), data.size());
   io_->seek(restore, BasicIo::beg);
 
@@ -478,26 +478,25 @@ long BmffImage::boxHandler(std::ostream& out /* = std::cout*/, Exiv2::PrintStruc
 void BmffImage::parseTiff(uint32_t root_tag, uint64_t length, uint64_t start) {
   enforce(start <= io_->size(), ErrorCode::kerCorruptedMetadata);
   enforce(length <= io_->size() - start, ErrorCode::kerCorruptedMetadata);
-  enforce(start <= std::numeric_limits<uint64_t>::max(), ErrorCode::kerCorruptedMetadata);
-  enforce(length <= std::numeric_limits<uint64_t>::max(), ErrorCode::kerCorruptedMetadata);
+  enforce(start <= static_cast<uint64_t>(std::numeric_limits<int64_t>::max()), ErrorCode::kerCorruptedMetadata);
+  enforce(length <= std::numeric_limits<size_t>::max(), ErrorCode::kerCorruptedMetadata);
 
   // read and parse exif data
-  long restore = io_->tell();
+  const size_t restore = io_->tell();
   DataBuf exif(static_cast<size_t>(length));
-  io_->seek(static_cast<long>(start), BasicIo::beg);
+  io_->seek(static_cast<int64_t>(start), BasicIo::beg);
   if (exif.size() > 8 && io_->read(exif.data(), exif.size()) == exif.size()) {
     // hunt for "II" or "MM"
-    long eof = 0xffffffff;  // impossible value for punt
-    long punt = eof;
+    const size_t eof = std::numeric_limits<size_t>::max();  // impossible value for punt
+    size_t punt = eof;
     for (size_t i = 0; i < exif.size() - 8 && punt == eof; i += 2) {
       if (exif.read_uint8(i) == exif.read_uint8(i + 1))
         if (exif.read_uint8(i) == 'I' || exif.read_uint8(i) == 'M')
-          punt = static_cast<long>(i);
+          punt = i;
     }
     if (punt != eof) {
-      Internal::TiffParserWorker::decode(exifData(), iptcData(), xmpData(), exif.c_data(punt),
-                                         static_cast<uint32_t>(exif.size() - punt), root_tag,
-                                         Internal::TiffMapping::findDecoder);
+      Internal::TiffParserWorker::decode(exifData(), iptcData(), xmpData(), exif.c_data(punt), exif.size() - punt,
+                                         root_tag, Internal::TiffMapping::findDecoder);
     }
   }
   io_->seek(restore, BasicIo::beg);
@@ -506,7 +505,7 @@ void BmffImage::parseTiff(uint32_t root_tag, uint64_t length, uint64_t start) {
 void BmffImage::parseTiff(uint32_t root_tag, uint64_t length) {
   if (length > 8) {
     enforce(length - 8 <= io_->size() - io_->tell(), ErrorCode::kerCorruptedMetadata);
-    enforce(length - 8 <= std::numeric_limits<uint64_t>::max(), ErrorCode::kerCorruptedMetadata);
+    enforce(length - 8 <= std::numeric_limits<size_t>::max(), ErrorCode::kerCorruptedMetadata);
     DataBuf data(static_cast<size_t>(length - 8u));
     const size_t bufRead = io_->read(data.data(), data.size());
 
@@ -524,8 +523,8 @@ void BmffImage::parseXmp(uint64_t length, uint64_t start) {
   enforce(start <= io_->size(), ErrorCode::kerCorruptedMetadata);
   enforce(length <= io_->size() - start, ErrorCode::kerCorruptedMetadata);
 
-  long restore = io_->tell();
-  io_->seek(static_cast<long>(start), BasicIo::beg);
+  const size_t restore = io_->tell();
+  io_->seek(static_cast<int64_t>(start), BasicIo::beg);
 
   auto lengthSizeT = static_cast<size_t>(length);
   DataBuf xmp(lengthSizeT + 1);
@@ -547,9 +546,8 @@ void BmffImage::parseXmp(uint64_t length, uint64_t start) {
 void BmffImage::parseCr3Preview(DataBuf& data, std::ostream& out, bool bTrace, uint8_t version, size_t width_offset,
                                 size_t height_offset, size_t size_offset, size_t relative_position) {
   // Derived from https://github.com/lclevy/canon_cr3
-  long here = io_->tell();
-  enforce(here >= 0 && here <= std::numeric_limits<long>::max() - static_cast<long>(relative_position),
-          ErrorCode::kerCorruptedMetadata);
+  const size_t here = io_->tell();
+  enforce(here <= std::numeric_limits<size_t>::max() - relative_position, ErrorCode::kerCorruptedMetadata);
   NativePreview nativePreview;
   nativePreview.position_ = here + relative_position;
   nativePreview.width_ = data.read_uint16(width_offset, endian_);
@@ -600,8 +598,8 @@ void BmffImage::readMetadata() {
   exifID_ = unknownID_;
   xmpID_ = unknownID_;
 
-  long address = 0;
-  const auto file_end = static_cast<long>(io_->size());
+  uint64_t address = 0;
+  const auto file_end = io_->size();
   while (address < file_end) {
     io_->seek(address, BasicIo::beg);
     address = boxHandler(std::cout, kpsNone, file_end, 0);
@@ -635,8 +633,8 @@ void BmffImage::printStructure(std::ostream& out, Exiv2::PrintStructureOption op
       openOrThrow();
       IoCloser closer(*io_);
 
-      long address = 0;
-      const auto file_end = static_cast<long>(io_->size());
+      uint64_t address = 0;
+      const auto file_end = io_->size();
       while (address < file_end) {
         io_->seek(address, BasicIo::beg);
         address = boxHandler(out, option, file_end, depth);
@@ -682,7 +680,7 @@ bool isBmffType(BasicIo& iIo, bool advance) {
   bool const is_video = (buf[8] == 'q' && buf[9] == 't' && buf[10] == ' ' && buf[11] == ' ');
   bool matched = is_jxl || (is_ftyp && !is_video);
   if (!advance || !matched) {
-    iIo.seek(static_cast<long>(0), BasicIo::beg);
+    iIo.seek(0, BasicIo::beg);
   }
   return matched;
 }

src/epsimage.cpp

@@ -11,6 +11,7 @@
 #include "config.h"
 
 #include "basicio.hpp"
+#include "enforce.hpp"
 #include "epsimage.hpp"
 #include "error.hpp"
 #include "futils.hpp"
@@ -101,13 +102,8 @@ void writeTemp(BasicIo& tempIo, const std::string& data) {
 
 //! Get the current write position of temp file, taking care of errors
 uint32_t posTemp(const BasicIo& tempIo) {
-  const long pos = tempIo.tell();
-  if (pos == -1) {
-#ifndef SUPPRESS_WARNINGS
-    EXV_WARNING << "Internal error while determining current write position in temporary file.\n";
-#endif
-    throw Error(ErrorCode::kerImageWriteFailed);
-  }
+  const size_t pos = tempIo.tell();
+  enforce(pos <= std::numeric_limits<uint32_t>::max(), ErrorCode::kerImageWriteFailed);
   return static_cast<uint32_t>(pos);
 }
 
@@ -1167,7 +1163,7 @@ bool isEpsType(BasicIo& iIo, bool advance) {
       bufSize = i.size();
     }
   }
-  const long restore = iIo.tell();  // save
+  const size_t restore = iIo.tell();  // save
   DataBuf buf = iIo.read(bufSize);
   if (iIo.error() || buf.size() != bufSize) {
     iIo.seek(restore, BasicIo::beg);

src/image.cpp

@@ -287,7 +287,7 @@ static bool typeValid(uint16_t type) {
   return type >= 1 && type <= 13;
 }
 
-static std::set<long> visits;  // #547
+static std::set<size_t> visits;  // #547
 
 void Image::printIFDStructure(BasicIo& io, std::ostream& out, Exiv2::PrintStructureOption option, size_t start,
                               bool bSwap, char c, int depth) {
@@ -370,7 +370,7 @@ void Image::printIFDStructure(BasicIo& io, std::ostream& out, Exiv2::PrintStruct
       const bool bOffsetIsPointer = count_x_size > 4;
 
       if (bOffsetIsPointer) {                                                       // read into buffer
-        const long restore = io.tell();                                             // save
+        const size_t restore = io.tell();                                           // save
         io.seekOrThrow(offset, BasicIo::beg, ErrorCode::kerCorruptedMetadata);      // position
         io.readOrThrow(buf.data(), count_x_size, ErrorCode::kerCorruptedMetadata);  // read
         io.seekOrThrow(restore, BasicIo::beg, ErrorCode::kerCorruptedMetadata);     // restore
@@ -410,7 +410,7 @@ void Image::printIFDStructure(BasicIo& io, std::ostream& out, Exiv2::PrintStruct
 
         if (option == kpsRecursive && (tag == 0x8769 /* ExifTag */ || tag == 0x014a /*SubIFDs*/ || type == tiffIfd)) {
           for (size_t k = 0; k < count; k++) {
-            const long restore = io.tell();
+            const size_t restore = io.tell();
             offset = byteSwap4(buf, k * size, bSwap);
             printIFDStructure(io, out, option, offset, bSwap, c, depth);
             io.seekOrThrow(restore, BasicIo::beg, ErrorCode::kerCorruptedMetadata);
@@ -421,7 +421,7 @@ void Image::printIFDStructure(BasicIo& io, std::ostream& out, Exiv2::PrintStruct
               throw Error(ErrorCode::kerCorruptedMetadata);
             }
 
-            const long restore = io.tell();
+            const size_t restore = io.tell();
             io.seekOrThrow(offset, BasicIo::beg, ErrorCode::kerCorruptedMetadata);  // position
             std::vector<byte> bytes(count);                                         // allocate memory
             // TODO: once we have C++11 use bytes.data()
@@ -431,7 +431,7 @@ void Image::printIFDStructure(BasicIo& io, std::ostream& out, Exiv2::PrintStruct
             IptcData::printStructure(out, makeSliceUntil(bytes.data(), count), depth);
           }
         } else if (option == kpsRecursive && tag == 0x927c /* MakerNote */ && count > 10) {
-          const long restore = io.tell();  // save
+          const size_t restore = io.tell();  // save
 
           uint32_t jump = 10;
           byte bytes[20];