Enhance ELF API the DynamicEntryArray

Author: romainthomas

api/python/ELF/objects/pyDynamicEntryArray.cpp

@@ -45,6 +45,36 @@ void init_ELF_DynamicEntryArray_class(py::module& m) {
         "Return the array",
         py::return_value_policy::reference)
 
+    .def("insert",
+        &DynamicEntryArray::insert,
+        "Insert a ``callback`` at the given ``position``",
+        "position"_a, "callback"_a,
+        py::return_value_policy::reference)
+
+    .def("append",
+        &DynamicEntryArray::append,
+        "Append the given ``callback`` ",
+        "callback"_a,
+        py::return_value_policy::reference)
+
+    .def("remove",
+        &DynamicEntryArray::remove,
+        "Remove the given ``callback`` ",
+        "callback"_a,
+        py::return_value_policy::reference)
+
+
+    .def(py::self += uint64_t())
+    .def(py::self -= uint64_t())
+
+
+    .def("__getitem__",
+        static_cast<uint64_t& (DynamicEntryArray::*)(size_t)>(&DynamicEntryArray::operator[]),
+        py::return_value_policy::reference)
+
+    .def("__len__",
+        &DynamicEntryArray::size)
+
     .def("__eq__", &DynamicEntryArray::operator==)
     .def("__ne__", &DynamicEntryArray::operator!=)
     .def("__hash__",

include/LIEF/ELF/DynamicEntryArray.hpp

@@ -39,6 +39,24 @@ class DLL_PUBLIC DynamicEntryArray : public DynamicEntry {
     const std::vector<uint64_t>& array(void) const;
     virtual void array(const std::vector<uint64_t>& array) override;
 
+    //! @brief Insert the given callback at ``pos``
+    DynamicEntryArray& insert(size_t pos, uint64_t callback);
+
+    //! @brief Append the given callback
+    DynamicEntryArray& append(uint64_t callback);
+
+    //! @brief Remove the given callback
+    DynamicEntryArray& remove(uint64_t callback);
+
+    //! @brief Number of callback registred
+    size_t size(void) const;
+
+    DynamicEntryArray& operator+=(uint64_t value);
+    DynamicEntryArray& operator-=(uint64_t value);
+
+    const uint64_t& operator[](size_t idx) const;
+    uint64_t&       operator[](size_t idx);
+
     //! @brief Method so that the ``visitor`` can visit us
     virtual void accept(Visitor& visitor) const override;
 

src/ELF/DynamicEntryArray.cpp

@@ -46,6 +46,57 @@ void DynamicEntryArray::array(const std::vector<uint64_t>& array) {
   this->array_ = array;
 }
 
+DynamicEntryArray& DynamicEntryArray::append(uint64_t value) {
+  this->array_.push_back(value);
+  return *this;
+}
+
+DynamicEntryArray& DynamicEntryArray::remove(uint64_t callback) {
+  this->array_.erase(std::remove_if(
+        std::begin(this->array_),
+        std::end(this->array_),
+        [callback] (uint64_t v) {
+          return v == callback;
+        }), std::end(this->array_));
+  return *this;
+}
+
+DynamicEntryArray& DynamicEntryArray::insert(size_t pos, uint64_t value) {
+  if (pos == this->array_.size()) {
+    return this->append(value);
+  }
+
+  if (pos > this->array_.size()) {
+    throw corrupted(std::to_string(pos) + " is out of ranges");
+  }
+  this->array_.insert(std::begin(this->array_) + pos, value);
+  return *this;
+}
+
+
+size_t DynamicEntryArray::size(void) const {
+  return this->array_.size();
+}
+
+DynamicEntryArray& DynamicEntryArray::operator+=(uint64_t value) {
+  return this->append(value);
+}
+
+DynamicEntryArray& DynamicEntryArray::operator-=(uint64_t value) {
+  return this->remove(value);
+}
+
+const uint64_t& DynamicEntryArray::operator[](size_t idx) const {
+  if (idx >= this->array_.size()) {
+    throw corrupted(std::to_string(idx) + " is out of ranges");
+  }
+  return this->array_[idx];
+}
+
+uint64_t& DynamicEntryArray::operator[](size_t idx) {
+  return const_cast<uint64_t&>(static_cast<const DynamicEntryArray*>(this)->operator[](idx));
+}
+
 void DynamicEntryArray::accept(Visitor& visitor) const {
   DynamicEntry::accept(visitor);
   visitor(*this); // Double dispatch to avoid down-casting

tests/elf/test_dynamic.py

@@ -132,6 +132,7 @@ def setUp(self):
         self.logger = logging.getLogger(__name__)
 
 
+    @unittest.skipUnless(sys.platform.startswith("linux"), "requires Linux")
     def test_remove_library(self):
         sample = LibAddSample()
         libadd = lief.parse(sample.libadd)
@@ -142,6 +143,7 @@ def test_remove_library(self):
         self.assertFalse(binadd.has_library("libadd.so"))
 
 
+    @unittest.skipUnless(sys.platform.startswith("linux"), "requires Linux")
     def test_remove_tag(self):
         sample = LibAddSample()
         libadd = lief.parse(sample.libadd)
@@ -157,6 +159,7 @@ def test_remove_tag(self):
 
         self.assertTrue(all(e.tag != lief.ELF.DYNAMIC_TAGS.NEEDED for e in binadd.dynamic_entries))
 
+    @unittest.skipUnless(sys.platform.startswith("linux"), "requires Linux")
     def test_runpath_api(self):
         sample = LibAddSample()
         libadd = lief.parse(sample.libadd)
@@ -196,8 +199,6 @@ def test_runpath_api(self):
 
         self.assertEqual(rpath.runpath, "")
 
-
-
         self.logger.debug(rpath)