Skip to content
Snippets Groups Projects
Select Git revision
  • 9f787c8217f2f3e00142aaa340515bc857a841c6
  • master default protected
  • image_support_for_boolean
  • image_support_lofar_fixes
  • image_support
  • moved-to-gitlab
  • remove-libpqxx-submodule
  • v0.11.2
  • v0.11.1
  • v0.11.0
  • v0.10.0
  • v0.9.1
  • v0.9.0
13 results

AttributeName.cpp

Blame
    • Reynald Bourtembourg's avatar
      9f787c82
      Fix potential crash in AttributeName::tangoHostWithDomain() · 9f787c82
      Reynald Bourtembourg authored
      Fix crash when getaddrinfo is returning several struct addrinfo
      (tango-controls-hdbpp/hdbpp-cm#6 (comment))
      The second struct addrinfo contains a field ai-canonname which is NULL.
      This could cause a crash because some code is attempting to create a string from a null pointer.
      
      getaddrinfo man page (on Debian Buster) says the following:
      
              If hints.ai_flags includes the AI_CANONNAME flag, then the ai_canon-
              name field of the first of the addrinfo structures in the returned
              list is set to point to the official name of the host.
      
      So there is no need to look at the following addrinfo returned structures.
      9f787c82
      History
      Fix potential crash in AttributeName::tangoHostWithDomain()
      Reynald Bourtembourg authored
      Fix crash when getaddrinfo is returning several struct addrinfo
      (tango-controls-hdbpp/hdbpp-cm#6 (comment))
      The second struct addrinfo contains a field ai-canonname which is NULL.
      This could cause a crash because some code is attempting to create a string from a null pointer.
      
      getaddrinfo man page (on Debian Buster) says the following:
      
              If hints.ai_flags includes the AI_CANONNAME flag, then the ai_canon-
              name field of the first of the addrinfo structures in the returned
              list is set to point to the official name of the host.
      
      So there is no need to look at the following addrinfo returned structures.
    Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    compressed_mask_data.h 8.56 KiB
    // SPDX-License-Identifier: LGPL-3.0-only
    
    #ifndef RADLER_UTILS_COMPRESSED_MASK_DATA_H_
    #define RADLER_UTILS_COMPRESSED_MASK_DATA_H_
    
    #include <algorithm>
    #include <cassert>
    #include <cstdint>
    #include <string>
    #include <vector>
    
    namespace radler::utils::implementation {
    
    /**
     * Helper class for @ref CompressedData. This class holds the compressed
     * data counts, and provides low-level operations on this count. This class
     * makes it possible to test these low-level operations while the interface
     * CompressedData can remain simple.
     */
    class CompressedMaskData {
     public:
      using iterator = std::vector<unsigned char>::iterator;
      using const_iterator = std::vector<unsigned char>::const_iterator;
    
      CompressedMaskData() noexcept = default;
      CompressedMaskData(CompressedMaskData&&) noexcept = default;
      CompressedMaskData(std::vector<unsigned char>&& data)
          : data_(std::move(data)) {}
      CompressedMaskData& operator=(CompressedMaskData&&) noexcept = default;
    
      const std::vector<unsigned char>& Data() const { return data_; }
      const_iterator begin() const { return data_.begin(); }
      iterator begin() { return data_.begin(); }
      const_iterator end() const { return data_.end(); }
      iterator end() { return data_.end(); }
    
      void Clear() { data_.clear(); }
    
      /** Sum of all compressed values, i.e., size of the uncompressed data. */
      size_t SumCount() const {
        size_t sum = 0;
        const_iterator iterator = data_.begin();
        while (iterator != data_.end()) {
          sum += GetCount(iterator);
        }
        return sum;
      }
    
      /**
       * Add a given number of samples with constant value add the end of the
       * compressed data. Values smaller than 255 take up 1 byte, whereas values >=
       * 256 take up 9 bytes (1 byte of value zero to indicate this is a long value,
       * then 8 bytes of data).
       * @param count should be larger than zero.
       */
      void PushBackCount(uint64_t count) {
        assert(count != 0);
        if (count < 255)
          data_.emplace_back(count);
        else if (count < 65536) {
          data_.emplace_back(255);
          data_.emplace_back(count % 256u);
          data_.emplace_back(count / 256u);
        } else {
          data_.emplace_back(0);
          const char* count_data = reinterpret_cast<char*>(&count);
          for (size_t i = 0; i != 8; ++i) data_.emplace_back(count_data[i]);
        }
      }
    
      /**
       * Compress a sequence of values and push them to the back of the data array.
       * @param [in] size Number of samples to compress in sequence
       * @param [in,out] sequence The data to compress of the specified size. The
       * pointer is moved to the end of the sequence.
       * @param [in,out] residual_count The number of samples with value
       * 'current_value' that needs to be added to the next pushed value.
       * @param [in,out] current_value The value associated to the next pushed count
       * (so the negation of the value associated to the previous pushed count).
       */
      void PushBackSequence(size_t size, const bool*& sequence,
                            size_t& residual_count, bool& current_value) {
        for (size_t i = 0; i != size; ++i) {
          if (*sequence != current_value) {
            PushBackCount(residual_count);
            residual_count = 0;
          }
          current_value = *sequence;
          ++residual_count;
          ++sequence;
        }
      }
    
      /**
       * Add a sequence from one compressed mask to this compressed mask.
       * @param [in,out] residual_count number of samples still available from
       * the source mask until the next read is required.
       * @return The number of samples with value 'current_value' that needs
       * to be added to the next pushed value.
       */
      size_t PushBackCompressedSequence(
          size_t size, const CompressedMaskData& source,
          std::vector<unsigned char>::const_iterator& source_iterator,
          size_t& residual_count, bool& current_value) {
        while (residual_count < size) {
          size -= residual_count;
          PushBackCount(residual_count);
          current_value = !current_value;
          // because we are inside while(residual_count < size), the iterator can
          // never be at the end, because then we would be asked more values than
          // available (which is considered undefined behaviour).
          residual_count = source.GetCount(source_iterator);
        }
        residual_count -= size;
        return size;
      }
    
      /**
       * Move the iterator one count value forward.
       */
      void SkipCount(std::vector<unsigned char>::const_iterator& iter) const {
        assert(iter != data_.end());
        const unsigned char value = *iter;
        ++iter;
        if (value == 255) {
          iter += 2;
        } else if (value == 0) {
          iter += 8;
        }
      }
    
      /**
       * Decode the count value of the iterator and move the iterator forward.
       * Behaviour is undefined when iter is at end.
       * @returns the decoded value (> 0).
       */
      uint64_t GetCount(std::vector<unsigned char>::const_iterator& iter) const {
        assert(iter != data_.end());
        const unsigned char value = *iter;
        ++iter;
        if (value == 0) {
          uint64_t u64_value;
          // The uint64_t is not stored aligned inside the vector, so it can not be
          // directly copied. Instead, copy it byte by byte.
          char* value_ptr = reinterpret_cast<char*>(&u64_value);
          std::copy_n(iter, 8, value_ptr);
          iter += 8;
          return u64_value;
        } else if (value == 255) {
          uint16_t u16_value = *iter;
          ++iter;
          u16_value += *iter << 8;
          ++iter;
          return u16_value;
        } else {
          return value;
        }
      }
    
      /**
       * Move iterator and update counters to skip a given number of uncompressed
       * samples.
       * @param [in] offset amount of uncompressed samples to skip
       * @param [in,out] iterator iterator into data pointing to the next compressed
       * count that needs to be read, or end when all values have been read.
       * @param [in,out] residual_count number of samples of the current count
       * available from the last read count, until the next change of value.
       * @param [in,out] value the value of the current serie of values. The next
       * uncompressed value has this value. Everytime a new count is read and the
       * iterator is increased, the value is negated.
       */
      void MoveIterator(size_t offset,
                        std::vector<unsigned char>::const_iterator& iterator,
                        size_t& residual_count, bool& value) const {
        while (offset >= residual_count) {
          offset -= residual_count;
          value = !value;
          if (iterator == data_.end()) {
            assert(offset == 0);
            residual_count = 0;
            break;
          } else {
            residual_count = GetCount(iterator);
          }
        }
        residual_count -= offset;
      }
    
      /**
       * Similar as @ref MoveIterator(), but will leave the iterator before the last
       * compressed value. On input, iterator should also point before the count
       * that is already in residual_count, i.e. it should lag one value behind
       * compared to @ref MoveIterator. Also, unlike MoveIterator, it will return
       * residual_count = 0 (and not read the next value already) in case offset
       * falls exactly after a compressed count value.
       */
      void MoveIteratorBefore(size_t offset,
                              std::vector<unsigned char>::const_iterator& iterator,
                              size_t& residual_count, bool& value) const {
        std::vector<unsigned char>::const_iterator next_iterator = iterator;
        SkipCount(next_iterator);
    
        while (offset > residual_count) {
          offset -= residual_count;
          value = !value;
          iterator = next_iterator;
          residual_count = GetCount(next_iterator);
        }
        residual_count -= offset;
      }
    
      /**
       * Decode a consecutive sequence of values and stop after a given number of
       * samples was decoded.
       * @param [in] size The number of uncompressed values to extract.
       * @param [in,out] destination Place for storing @c size values. The pointer
       * is moved to point the end of the sequence.
       * @param [in,out] iterator Position for the next read.
       * @param [in,out] residual_count How many values are still to be read with
       * the given value.
       * @param [in,out] value Value of the current read sequence.
       */
      void ExtractSequence(size_t size, bool*& destination,
                           std::vector<unsigned char>::const_iterator& iterator,
                           size_t& residual_count, bool& value) const {
        while (residual_count < size) {
          destination = std::fill_n(destination, residual_count, value);
          value = !value;
          size -= residual_count;
          residual_count = GetCount(iterator);
        }
        destination = std::fill_n(destination, size, value);
        residual_count -= size;
      }
    
      std::string ToString(bool first_value, size_t width) const;
    
     private:
      std::vector<unsigned char> data_;
    };
    
    }  // namespace radler::utils::implementation
    
    #endif