Feat/ldax control block

cbxp/control_block_explorer.cpp

@@ -13,6 +13,7 @@
 #include "control_blocks/control_block.hpp"
 #include "control_blocks/cvt.hpp"
 #include "control_blocks/ecvt.hpp"
+#include "control_blocks/ldax.hpp"
 #include "control_blocks/oucb.hpp"
 #include "control_blocks/psa.hpp"
 #include "logger.hpp"
@@ -112,6 +113,10 @@ void ControlBlockExplorer::processControlBlock(
     } else if (control_block_name == "oucb") {
       control_block_json =
           OUCB(cbxp_options_).get(p_control_block_, control_block_data_length_);
+    } else if (control_block_name == "ldax") {
+      control_block_json =
+          LDAX(cbxp_options_).get(p_control_block_, control_block_data_length_);
+
     } else {
       throw ControlBlockError();
     }

cbxp/control_blocks/assb.cpp

@@ -10,6 +10,7 @@
 
 #include "ascb.hpp"
 #include "asvt.hpp"
+#include "ldax.hpp"
 #include "logger.hpp"
 
 namespace CBXP {
@@ -63,6 +64,19 @@ nlohmann::json ASSB::get(const void* p_control_block,
   Logger::getInstance().hexDump(reinterpret_cast<const char*>(p_assb),
                                 sizeof(struct assb));
 
+  assb_json["assbldax"] = formatter_.getHex<uint64_t>(&(p_assb->assbldax));
+
+  for (const auto& [include, cbxp_options] : options_map_) {
+    if (include == "ldax") {
+      assb_json["assbldax"] =
+          CBXP::LDAX(cbxp_options)
+              .get(*reinterpret_cast<const void* const*>(p_assb->assbldax));
+      if (assb_json["assbldax"].is_null()) {
+        return {};
+      }
+    }
+  }
+
   assb_json["assb_cms_lockinst_addr"] =
       formatter_.getHex<uint32_t>(&(p_assb->assb_cms_lockinst_addr));
   assb_json["assb_enqdeq_cms_lockinst_addr"] =
@@ -78,7 +92,6 @@ nlohmann::json ASSB::get(const void* p_control_block,
   assb_json["assboasb"] = formatter_.getHex<uint32_t>(&(p_assb->assboasb));
   assb_json["assbtasb"] = formatter_.getHex<uint32_t>(&(p_assb->assbtasb));
   assb_json["assbvab"]  = formatter_.getHex<uint32_t>(&(p_assb->assbvab));
-  assb_json["assbldax"] = formatter_.getHex<uint32_t>(&(p_assb->assbldax));
   assb_json["assbisqn"] = p_assb->assbisqn;
   assb_json["assbjbni"] = formatter_.getString(p_assb->assbjbni, 8);
   assb_json["assbjbns"] = formatter_.getString(p_assb->assbjbns, 8);

cbxp/control_blocks/assb.hpp

@@ -12,7 +12,7 @@ class ASSB : public ControlBlock {
   nlohmann::json get(const void* p_control_block = nullptr,
                      const size_t buffer_length  = 0) override;
   explicit ASSB(const cbxp_options_t& cbxp_options)
-      : ControlBlock("assb", {}, cbxp_options, sizeof(struct assb)) {}
+      : ControlBlock("assb", {"ldax"}, cbxp_options, sizeof(struct assb)) {}
 };
 
 }  // namespace CBXP

cbxp/control_blocks/control_block.cpp

@@ -195,7 +195,7 @@ bool ControlBlock::compare(const nlohmann::json& json_value,
   uint64_t value_uint;
 
   if (json_value.is_number()) {
-    value_uint = json_value.get<int>();
+    value_uint = json_value.get<uint64_t>();
   } else {
     value_str       = json_value.get<std::string>();
     value_is_string = true;

cbxp/control_blocks/ldax.cpp

@@ -0,0 +1,130 @@
+#include "ldax.hpp"
+
+#include <cvt.h>
+#include <ihaascb.h>
+#include <ihaassb.h>
+#include <ihaldax.h>
+#include <ihapsa.h>
+
+#include <cstdint>
+#include <nlohmann/json.hpp>
+#include <string>
+#include <vector>
+
+#include "asvt.hpp"
+#include "logger.hpp"
+
+namespace CBXP {
+
+nlohmann::json LDAX::get(const void* p_control_block,
+                         const size_t buffer_length) {
+  LDAX::checkDataLength(buffer_length);
+  const struct ldax* p_ldax;
+  nlohmann::json ldax_json = {};
+  if (p_control_block == nullptr) {
+    // PSA starts at address 0
+    const struct psa* __ptr32 p_psa = 0;
+
+    const struct cvtmap* __ptr32 p_cvtmap =
+        // cppcheck-suppress nullPointer
+        static_cast<struct cvtmap* __ptr32>(p_psa->flccvt);
+
+    const asvt_t* __ptr32 p_asvt =
+        static_cast<asvt_t* __ptr32>(p_cvtmap->cvtasvt);
+
+    ldax_json["ldaxs"] = std::vector<nlohmann::json>();
+    std::vector<nlohmann::json>& ldaxs =
+        ldax_json["ldaxs"].get_ref<std::vector<nlohmann::json>&>();
+
+    ldaxs.reserve(p_asvt->asvtmaxu);
+
+    const uint32_t* __ptr32 p_ascb_addr =
+        reinterpret_cast<const uint32_t* __ptr32>(&(p_asvt->asvtenty));
+
+    for (int i = 0; i < p_asvt->asvtmaxu; i++) {
+      if (0x80000000 & *p_ascb_addr) {
+        Logger::getInstance().debug(formatter_.getHex<uint32_t>(p_ascb_addr) +
+                                    " is not a valid ASCB address");
+        p_ascb_addr++;
+        continue;
+      }
+
+      // Cast ASCB address into ASCB pointer
+      const struct ascb* __ptr32 p_ascb =
+          reinterpret_cast<const struct ascb* __ptr32>(*p_ascb_addr);
+
+      // Get ASSB from ASCB
+      const struct assb* __ptr32 p_assb =
+          reinterpret_cast<const struct assb* __ptr32>(p_ascb->ascbassb);
+
+      nlohmann::json next_ldax =
+          LDAX::get(*reinterpret_cast<const void* const*>(p_assb->assbldax));
+      if (!next_ldax.is_null()) {
+        ldaxs.push_back(next_ldax);
+      }
+
+      p_ascb_addr++;
+    }
+
+    return ldaxs;
+  } else {
+    p_ldax = static_cast<const struct ldax*>(p_control_block);
+  }
+
+  Logger::getInstance().debug("ldax hex dump:");
+  Logger::getInstance().hexDump(reinterpret_cast<const char*>(p_ldax),
+                                sizeof(struct ldax));
+
+  ldax_json["ldax_id"] = formatter_.getString(p_ldax->ldax_id, 4);
+  ldax_json["ldax_version"] =
+      formatter_.getBitmap<uint8_t>(p_ldax->ldax_version);
+  ldax_json["ldax_ldaascb"] =
+      formatter_.getHex<uint32_t>(&(p_ldax->ldax_ldaascb));
+  ldax_json["ldax_ldastrta"] =
+      formatter_.getHex<uint32_t>(&(p_ldax->ldax_ldastrta));
+  ldax_json["ldax_ldasiza"] = p_ldax->ldax_ldasiza;
+  ldax_json["ldax_ldaestra"] =
+      formatter_.getHex<uint32_t>(&(p_ldax->ldax_ldaestra));
+  ldax_json["ldax_ldaesiza"] = p_ldax->ldax_ldaesiza;
+  ldax_json["ldax_ldacrgtp"] =
+      formatter_.getHex<uint32_t>(&(p_ldax->ldax_ldacrgtp));
+  ldax_json["ldax_ldaergtp"] =
+      formatter_.getHex<uint32_t>(&(p_ldax->ldax_ldaergtp));
+  ldax_json["ldax_ldalimit"] =
+      formatter_.getHex<uint32_t>(&(p_ldax->ldax_ldalimit));
+  ldax_json["ldax_ldavvrg"] =
+      formatter_.getHex<uint32_t>(&(p_ldax->ldax_ldavvrg));
+  ldax_json["ldax_ldaelim"] =
+      formatter_.getHex<uint32_t>(&(p_ldax->ldax_ldaelim));
+  ldax_json["ldax_ldaevvrg"] =
+      formatter_.getHex<uint32_t>(&(p_ldax->ldax_ldaevvrg));
+  ldax_json["ldax_ldaloal"] =
+      formatter_.getBitmap<uint32_t>(p_ldax->ldax_ldaloal);
+  ldax_json["ldax_ldahial"] =
+      formatter_.getBitmap<uint32_t>(p_ldax->ldax_ldahial);
+  ldax_json["ldax_ldaeloal"] =
+      formatter_.getBitmap<uint32_t>(p_ldax->ldax_ldaeloal);
+  ldax_json["ldax_ldaehial"] =
+      formatter_.getBitmap<uint32_t>(p_ldax->ldax_ldaehial);
+  ldax_json["ldax_tcthwm"]  = p_ldax->ldax_tcthwm;
+  ldax_json["ldax_tctlwm"]  = p_ldax->ldax_tctlwm;
+  ldax_json["ldax_tctehwm"] = p_ldax->ldax_tctehwm;
+  ldax_json["ldax_tctelwm"] = p_ldax->ldax_tctelwm;
+  ldax_json["ldax_curhighbot"] =
+      formatter_.getHex<uint32_t>(&(p_ldax->ldax_curhighbot));
+  ldax_json["ldax_curehighbot"] =
+      formatter_.getHex<uint32_t>(&(p_ldax->ldax_curehighbot));
+  ldax_json["ldax_ldasmad"] =
+      formatter_.getHex<uint32_t>(&(p_ldax->ldax_ldasmad));
+  ldax_json["ldax_ldasmsz"] =
+      formatter_.getHex<uint32_t>(&(p_ldax->ldax_ldasmsz));
+  ldax_json["ldax_obtainshomespace"] = p_ldax->ldax_obtainshomespace;
+
+  if (LDAX::matchFilter(ldax_json)) {
+    return ldax_json;
+  } else {
+    return {};
+  }
+}
+
+}  // namespace CBXP

cbxp/control_blocks/ldax.hpp

@@ -0,0 +1,20 @@
+#ifndef __LDAX_H_
+#define __LDAX_H_
+
+#include <ihaldax.h>
+
+#include "control_block.hpp"
+
+namespace CBXP {
+
+class LDAX : public ControlBlock {
+ public:
+  nlohmann::json get(const void* p_control_block = nullptr,
+                     const size_t buffer_length  = 0) override;
+  explicit LDAX(const cbxp_options_t& cbxp_options)
+      : ControlBlock("ldax", {}, cbxp_options, sizeof(struct ldax)) {}
+};
+
+}  // namespace CBXP
+
+#endif

tests/test.py

@@ -57,6 +57,12 @@ def test_cbxp_extract_oucb(self):
         for entry in cbdata:
             self.assertIs(type(entry), dict)
 
+    def test_cbxp_extract_ldax(self):
+        cbdata = cbxp.extract("ldax")
+        self.assertIs(type(cbdata), list)
+        for entry in cbdata:
+            self.assertIs(type(entry), dict)
+
     # ============================================================================
     # Extract -- Debug Mode
     # ============================================================================
@@ -106,6 +112,41 @@ def test_cbxp_extract_ascb_and_include_oucb(self):
             self.assertIs(type(entry), dict)
             self.assertIs(type(entry["ascboucb"]), dict)
 
+    def test_cbxp_extract_asvt_and_include_ascb_assb_ldax(self):
+        cbdata = cbxp.extract("asvt", includes=["ascb.assb.ldax"])
+        self.assertIs(type(cbdata), dict)
+        self.assertIs(type(cbdata["asvtenty"]), list)
+        for entry in cbdata["asvtenty"]:
+            self.assertIs(type(entry), dict)
+            self.assertIs(type(entry["ascbassb"]), dict)
+            self.assertIs(type(entry["ascbassb"]["assbldax"]), dict)
+
+    def test_cbxp_extract_psa_and_include_cvt_asvt_ascb_assb_ldax(self):
+        cbdata = cbxp.extract("psa", includes=["cvt.asvt.ascb.assb.ldax"])
+        self.assertIs(type(cbdata), dict)
+        self.assertIs(type(cbdata["flccvt"]), dict)
+        self.assertIs(type(cbdata["flccvt"]["cvtasvt"]), dict)
+        self.assertIs(type(cbdata["flccvt"]["cvtasvt"]["asvtenty"]), list)
+        for entry in cbdata["flccvt"]["cvtasvt"]["asvtenty"]:
+            self.assertIs(type(entry), dict)
+            self.assertIs(type(entry["ascbassb"]), dict)
+            self.assertIs(type(entry["ascbassb"]["assbldax"]), dict)
+
+    def test_cbxp_extract_assb_and_include_ldax(self):
+        cbdata = cbxp.extract("assb", includes=["ldax"])
+        self.assertIs(type(cbdata), list)
+        for entry in cbdata:
+            self.assertIs(type(entry), dict)
+            self.assertIs(type(entry["assbldax"]), dict)
+
+    def test_cbxp_extract_ascb_and_include_assb_ldax(self):
+        cbdata = cbxp.extract("ascb", includes=["assb.ldax"])
+        self.assertIs(type(cbdata), list)
+        for entry in cbdata:
+            self.assertIs(type(entry), dict)
+            self.assertIs(type(entry["ascbassb"]), dict)
+            self.assertIs(type(entry["ascbassb"]["assbldax"]), dict)
+
     def test_cbxp_extract_psa_and_include_cvt_ecvt(self):
         cbdata = cbxp.extract("psa", includes=["cvt.ecvt"])
         self.assertIs(type(cbdata), dict)
@@ -186,6 +227,7 @@ def test_cbxp_extract_psa_and_include_cvt_recursive_wildcard(self):
         for entry in cbdata["flccvt"]["cvtasvt"]["asvtenty"]:
             self.assertIs(type(entry), dict)
             self.assertIs(type(entry["ascbassb"]), dict)
+            self.assertIs(type(entry["ascbassb"]["assbldax"]), dict)
             self.assertIs(type(entry["ascboucb"]), dict)
 
     def test_cbxp_extract_psa_and_include_cvt_wildcard(self):
@@ -220,6 +262,23 @@ def test_cbxp_extract_cvt_and_include_wildcard_and_asvt_recursive_wildcard(
             self.assertIs(type(entry["ascbassb"]), dict)
             self.assertIs(type(entry["ascboucb"]), dict)
 
+    def test_cbxp_extract_ascb_and_include_assb_recursive_wildcard(self):
+        cbdata = cbxp.extract("ascb", includes=["assb.**"])
+        self.assertIs(type(cbdata), list)
+        for entry in cbdata:
+            self.assertIs(type(entry), dict)
+            self.assertIs(type(entry["ascbassb"]), dict)
+            self.assertIs(type(entry["ascbassb"]["assbldax"]), dict)
+
+    def test_cbxp_extract_ascb_and_include_oucb_and_assb_recursive_wildcard(self):
+        cbdata = cbxp.extract("ascb", includes=["oucb", "assb.**"])
+        self.assertIs(type(cbdata), list)
+        for entry in cbdata:
+            self.assertIs(type(entry), dict)
+            self.assertIs(type(entry["ascbassb"]), dict)
+            self.assertIs(type(entry["ascbassb"]["assbldax"]), dict)
+            self.assertIs(type(entry["ascboucb"]), dict)
+
     # ============================================================================
     # Extract -- Filters
     # ============================================================================
@@ -489,6 +548,55 @@ def test_cbxp_extract_filter_on_ascb_oucb_oucbtrxn_with_explicit_include_oucb(se
             self.assertIs(type(entry["ascboucb"]), dict)
             self.assertEqual(entry["ascboucb"]["oucbtrxn"], "OMVS")
 
+    def test_cbxp_extract_filter_on_ldax_tcthwm_equal(self):
+        cbdata = cbxp.extract(
+            "ldax",
+            filters=[
+                CBXPFilter(
+                    "ldax_tcthwm",
+                    CBXPFilterOperation.EQUAL,
+                    0,
+                ),
+            ],
+        )
+        self.assertIs(type(cbdata), list)
+        for entry in cbdata:
+            self.assertIs(type(entry), dict)
+            self.assertEqual(entry["ldax_tcthwm"], 0)
+
+    def test_cbxp_extract_filter_on_psa_cvt_asvt_ascb_assb_ldax_tcthwm_with_include(
+        self,
+    ):
+        cbdata = cbxp.extract(
+            "psa",
+            filters=[
+                CBXPFilter(
+                    "cvt.asvt.ascb.assb.ldax.ldax_tcthwm",
+                    CBXPFilterOperation.EQUAL,
+                    0,
+                ),
+            ],
+            includes=["cvt.asvt.ascb.assb.ldax"],
+        )
+        self.assertIs(type(cbdata), dict)
+        self.assertIn("flccvt", cbdata)
+        self.assertIs(type(cbdata["flccvt"]), dict)
+        self.assertIn("cvtasvt", cbdata["flccvt"])
+        self.assertIs(type(cbdata["flccvt"]["cvtasvt"]), dict)
+        self.assertIn("asvtenty", cbdata["flccvt"]["cvtasvt"])
+        self.assertIs(type(cbdata["flccvt"]["cvtasvt"]["asvtenty"]), list)
+        # Verify at least one entry matches the filter
+        self.assertGreater(len(cbdata["flccvt"]["cvtasvt"]["asvtenty"]), 0)
+        for entry in cbdata["flccvt"]["cvtasvt"]["asvtenty"]:
+            self.assertIs(type(entry), dict)
+            self.assertIn("ascbassb", entry)
+            self.assertIs(type(entry["ascbassb"]), dict)
+            self.assertIn("assbldax", entry["ascbassb"])
+            self.assertIs(type(entry["ascbassb"]["assbldax"]), dict)
+            self.assertEqual(
+                entry["ascbassb"]["assbldax"]["ldax_tcthwm"], 0,
+            )
+
     def test_cbxp_extract_null_filter_string(
         self,
     ):
@@ -657,6 +765,20 @@ def test_cbxp_extract_raises_cbxp_error_if_filter_has_comma(
             )
         self.assertEqual("Filters cannot contain commas", str(e.exception))
 
+    def test_cbxp_extract_raises_cbxp_error_if_ldax_included_with_psa(self):
+        with self.assertRaises(CBXPError) as e:
+            cbxp.extract("psa", includes=["ldax"])
+        self.assertEqual("A bad include pattern was provided", str(e.exception))
+
+    def test_cbxp_extract_raises_cbxp_error_if_ldax_included_with_cvt(self):
+        with self.assertRaises(CBXPError) as e:
+            cbxp.extract("cvt", includes=["ldax"])
+        self.assertEqual("A bad include pattern was provided", str(e.exception))
+
+    def test_cbxp_extract_raises_cbxp_error_if_ldax_included_with_ascb(self):
+        with self.assertRaises(CBXPError) as e:
+            cbxp.extract("ascb", includes=["ldax"])
+        self.assertEqual("A bad include pattern was provided", str(e.exception))
     # ============================================================================
     # Format -- Basic Usage
     # ============================================================================