Merge pull request #1957 from peternewman/e1.33-cherry-pick

E1.33 cherry pick v

Author: peternewman

common/rdm/UIDTest.cpp

@@ -34,6 +34,7 @@ using ola::rdm::UIDSet;
 class UIDTest: public CppUnit::TestFixture {
   CPPUNIT_TEST_SUITE(UIDTest);
   CPPUNIT_TEST(testUID);
+  CPPUNIT_TEST(testRPTUID);
   CPPUNIT_TEST(testUIDInequalities);
   CPPUNIT_TEST(testUIDSet);
   CPPUNIT_TEST(testUIDSetUnion);
@@ -43,6 +44,7 @@ class UIDTest: public CppUnit::TestFixture {
 
  public:
     void testUID();
+    void testRPTUID();
     void testUIDInequalities();
     void testUIDSet();
     void testUIDSetUnion();
@@ -58,6 +60,8 @@ CPPUNIT_TEST_SUITE_REGISTRATION(UIDTest);
  */
 void UIDTest::testUID() {
   UID uid(1, 2);
+  OLA_ASSERT_FALSE(uid.IsBroadcast());
+  OLA_ASSERT_FALSE(uid.IsVendorcast());
   UID uid2 = uid;
   OLA_ASSERT_EQ(uid, uid2);
   OLA_ASSERT_FALSE(uid != uid2);
@@ -84,9 +88,12 @@ void UIDTest::testUID() {
 
   UID all_devices = UID::AllDevices();
   UID manufacturer_devices = UID::VendorcastAddress(0x52);
+  UID manufacturer_devices2 = UID::VendorcastAddress(uid);
   OLA_ASSERT_EQ(string("ffff:ffffffff"), all_devices.ToString());
   OLA_ASSERT_EQ(string("0052:ffffffff"),
                 manufacturer_devices.ToString());
+  OLA_ASSERT_EQ(string("0001:ffffffff"),
+                manufacturer_devices2.ToString());
   OLA_ASSERT_EQ(all_devices.ManufacturerId(),
                 static_cast<uint16_t>(0xffff));
   OLA_ASSERT_EQ(all_devices.DeviceId(),
@@ -95,8 +102,16 @@ void UIDTest::testUID() {
                 static_cast<uint16_t>(0x0052));
   OLA_ASSERT_EQ(manufacturer_devices.DeviceId(),
                 static_cast<uint32_t>(0xffffffff));
+  OLA_ASSERT_EQ(manufacturer_devices2.ManufacturerId(),
+                static_cast<uint16_t>(0x0001));
+  OLA_ASSERT_EQ(manufacturer_devices2.DeviceId(),
+                static_cast<uint32_t>(0xffffffff));
   OLA_ASSERT_TRUE(all_devices.IsBroadcast());
+  OLA_ASSERT_FALSE(all_devices.IsVendorcast());
   OLA_ASSERT_TRUE(manufacturer_devices.IsBroadcast());
+  OLA_ASSERT_TRUE(manufacturer_devices.IsVendorcast());
+  OLA_ASSERT_TRUE(manufacturer_devices2.IsBroadcast());
+  OLA_ASSERT_TRUE(manufacturer_devices2.IsVendorcast());
 
   // now test the packing & unpacking
   unsigned int buffer_size = UID::UID_SIZE;
@@ -118,6 +133,49 @@ void UIDTest::testUID() {
 }
 
 
+/*
+ * Test the RPT UIDs work.
+ */
+void UIDTest::testRPTUID() {
+  UID uid(1, 2);
+  UID rpt_all_controllers = UID::RPTAllControllers();
+  UID rpt_all_devices = UID::RPTAllDevices();
+  UID rpt_manufacturer_devices = UID::RPTVendorcastAddressDevices(0x52);
+  UID rpt_manufacturer_devices2 = UID::RPTVendorcastAddressDevices(uid);
+  OLA_ASSERT_EQ(string("fffc:ffffffff"), rpt_all_controllers.ToString());
+  OLA_ASSERT_EQ(string("fffd:ffffffff"), rpt_all_devices.ToString());
+  OLA_ASSERT_EQ(string("fffd:0052ffff"),
+                rpt_manufacturer_devices.ToString());
+  OLA_ASSERT_EQ(string("fffd:0001ffff"),
+                rpt_manufacturer_devices2.ToString());
+  OLA_ASSERT_EQ(rpt_all_controllers.ManufacturerId(),
+                static_cast<uint16_t>(0xfffc));
+  OLA_ASSERT_EQ(rpt_all_controllers.DeviceId(),
+                static_cast<uint32_t>(0xffffffff));
+  OLA_ASSERT_EQ(rpt_all_devices.ManufacturerId(),
+                static_cast<uint16_t>(0xfffd));
+  OLA_ASSERT_EQ(rpt_all_devices.DeviceId(),
+                static_cast<uint32_t>(0xffffffff));
+  OLA_ASSERT_EQ(rpt_manufacturer_devices.ManufacturerId(),
+                static_cast<uint16_t>(0xfffd));
+  OLA_ASSERT_EQ(rpt_manufacturer_devices.DeviceId(),
+                static_cast<uint32_t>(0x0052ffff));
+  OLA_ASSERT_EQ(rpt_manufacturer_devices2.ManufacturerId(),
+                static_cast<uint16_t>(0xfffd));
+  OLA_ASSERT_EQ(rpt_manufacturer_devices2.DeviceId(),
+                static_cast<uint32_t>(0x0001ffff));
+  // TODO(Peter): Handle the more complicated RPT vendorcast tests
+  OLA_ASSERT_TRUE(rpt_all_controllers.IsBroadcast());
+  // OLA_ASSERT_FALSE(rpt_all_controllers.IsVendorcast());
+  OLA_ASSERT_TRUE(rpt_all_devices.IsBroadcast());
+  // OLA_ASSERT_FALSE(rpt_all_devices.IsVendorcast());
+  // OLA_ASSERT_TRUE(rpt_manufacturer_devices.IsBroadcast());
+  // OLA_ASSERT_TRUE(rpt_manufacturer_devices.IsVendorcast());
+  // OLA_ASSERT_TRUE(rpt_manufacturer_devices2.IsBroadcast());
+  // OLA_ASSERT_TRUE(rpt_manufacturer_devices2.IsVendorcast());
+}
+
+
 /*
  * Test the UIDs inequalities work
  */

include/ola/e133/E133Enums.h

@@ -21,9 +21,17 @@
 #ifndef INCLUDE_OLA_E133_E133ENUMS_H_
 #define INCLUDE_OLA_E133_E133ENUMS_H_
 
+#include <stdint.h>
+
 namespace ola {
 namespace e133 {
 
+// Appendix A - Endpoints and Table 3-1: Endpoint ID Allocation
+static const uint16_t NULL_ENDPOINT = 0x0000;
+static const uint16_t MIN_DEVICE_ENDPOINT = 0x0001;
+static const uint16_t MAX_DEVICE_ENDPOINT = 0xF9FF;
+static const uint16_t BROADCAST_ENDPOINT = 0xFFFF;
+
 // Table A-6, Discovery Stats
 enum DiscoveryState {
   DISCOVERY_INCOMPLETE = 0,

include/ola/e133/E133StatusHelper.h

@@ -22,22 +22,32 @@
 #define INCLUDE_OLA_E133_E133STATUSHELPER_H_
 
 #include <stdint.h>
+#include <ola/acn/ACNVectors.h>
 #include <ola/e133/E133Enums.h>
+#include <ola/rdm/RDMResponseCodes.h>
 #include <string>
 
 namespace ola {
 namespace e133 {
 
 using std::string;
+using ola::acn::RPTStatusVector;
 using ola::e133::E133StatusCode;
 using ola::e133::E133ConnectStatusCode;
+using ola::rdm::RDMStatusCode;
 
 bool IntToStatusCode(uint16_t input, E133StatusCode *status_code);
 string StatusCodeToString(E133StatusCode status_code);
 
 bool IntToConnectStatusCode(uint16_t input,
                             E133ConnectStatusCode *connect_status_code);
 string ConnectStatusCodeToString(E133ConnectStatusCode connect_status_code);
+
+bool IntToRPTStatusCode(uint16_t input,
+                        RPTStatusVector *rpt_status_code);
+string RPTStatusCodeToString(RPTStatusVector rpt_status_code);
+bool RPTStatusCodeToRDMStatusCode(RPTStatusVector rpt_status_code,
+                                  RDMStatusCode *rdm_status_code);
 }  // namespace e133
 }  // namespace ola
 #endif  // INCLUDE_OLA_E133_E133STATUSHELPER_H_

include/ola/rdm/UID.h

@@ -174,6 +174,16 @@ class UID {
      */
     bool IsBroadcast() const { return m_uid.device_id == ALL_DEVICES; }
 
+    /**
+     * @brief Check if this UID is a vendorcast UID.
+     * @returns true if the manufacturer id is not 0xffff and the device id is
+     * 0xffffffff.
+     */
+    bool IsVendorcast() const {
+      return ((m_uid.esta_id != ALL_MANUFACTURERS) &&
+              (m_uid.device_id == ALL_DEVICES));
+    }
+
     /**
      * @brief Check if this UID matches against another.
      * @param uid the UID to check against
@@ -260,7 +270,7 @@ class UID {
 
     /**
      * @brief Returns a UID that matches all devices for a particular
-     * manufacturer.
+     *     manufacturer.
      * @param esta_id the manufacturer id of the devices to match.
      * @returns a UID(X, 0xffffffff).
      */
@@ -278,6 +288,44 @@ class UID {
       return UID(uid.ManufacturerId(), ALL_DEVICES);
     }
 
+    /**
+     * @brief Returns a UID that matches all RPT controllers (fffc:ffffffff).
+     * @returns a UID(0xfffc, 0xffffffff).
+     */
+    static UID RPTAllControllers() {
+      return UID(RPT_ALL_CONTROLLERS_MANUFACTURER, ALL_DEVICES);
+    }
+
+    /**
+     * @brief Returns a UID that matches all RPT devices (fffd:ffffffff).
+     * @returns a UID(0xfffd, 0xffffffff).
+     */
+    static UID RPTAllDevices() {
+      return UID(RPT_ALL_DEVICES_MANUFACTURER, ALL_DEVICES);
+    }
+
+    /**
+     * @brief Returns a UID that matches all RPT devices for a particular
+     *     manufacturer.
+     * @param esta_id the manufacturer id of the devices to match.
+     * @returns a UID(0xfffd, 0xXXXXffff).
+     */
+    static UID RPTVendorcastAddressDevices(uint16_t esta_id) {
+      return UID(RPT_ALL_DEVICES_MANUFACTURER,
+                 RPTVendorcastDevicesDeviceId(esta_id));
+    }
+
+    /**
+     * @brief Returns a UID that matches all RPT devices for a particular
+     *     manufacturer.
+     * @param uid a UID whose manufacturer id you want to match.
+     * @returns a UID(0xfffd, 0xXXXXffff).
+     */
+    static UID RPTVendorcastAddressDevices(UID uid) {
+      return UID(RPT_ALL_DEVICES_MANUFACTURER,
+                 RPTVendorcastDevicesDeviceId(uid.ManufacturerId()));
+    }
+
     /**
      * @brief Return a new UID from a string.
      * @param uid the UID as a string i.e. XXXX:YYYYYYYY.
@@ -300,9 +348,21 @@ class UID {
 
     /**
      * @brief The value for the 'all devices' id.
+     *
+     * This is also the value for RPT all controllers and all devices.
      */
     static const uint32_t ALL_DEVICES = 0xffffffff;
 
+    /**
+     * @brief The value for the RPT 'all controllers' manufacturer.
+     */
+    static const uint16_t RPT_ALL_CONTROLLERS_MANUFACTURER = 0xfffc;
+
+    /**
+     * @brief The value for the RPT 'all devices' manufacturer.
+     */
+    static const uint16_t RPT_ALL_DEVICES_MANUFACTURER = 0xfffd;
+
  private:
     struct rdm_uid {
       uint16_t esta_id;
@@ -324,6 +384,10 @@ class UID {
       }
       return a < b ? -1 : 1;
     }
+
+    static uint32_t RPTVendorcastDevicesDeviceId(uint16_t esta_id) {
+      return ((static_cast<uint32_t>(esta_id) << 16) | 0xffff);
+    }
 };
 }  // namespace rdm
 }  // namespace ola

libs/acn/BrokerClientEntryRPTInflator.cpp

@@ -0,0 +1,89 @@
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * BrokerClientEntryRPTInflator.cpp
+ * The Inflator for BrokerClientEntryRPT PDU
+ * Copyright (C) 2023 Peter Newman
+ */
+
+#include <iostream>
+#include <memory>
+
+#include "ola/Logging.h"
+#include "ola/acn/CID.h"
+#include "ola/e133/E133Helper.h"
+#include "ola/network/NetworkUtils.h"
+#include "ola/rdm/UID.h"
+#include "include/ola/strings/Format.h"
+#include "libs/acn/BrokerClientEntryRPTInflator.h"
+
+namespace ola {
+namespace acn {
+
+using ola::acn::CID;
+using ola::network::NetworkToHost;
+using ola::rdm::UID;
+using ola::strings::IntToString;
+
+/**
+ * Set a BrokerClientEntryRPTHandler to run when receiving a Broker Client
+ * Entry RPT message.
+ * @param handler the callback to invoke when there is a Broker Client Entry
+ * RPT.
+ */
+void BrokerClientEntryRPTInflator::SetBrokerClientEntryRPTHandler(
+    BrokerClientEntryRPTHandler *handler) {
+  m_broker_client_entry_rpt_handler.reset(handler);
+}
+
+
+unsigned int BrokerClientEntryRPTInflator::InflatePDUBlock(
+    OLA_UNUSED HeaderSet *headers,
+    const uint8_t *data,
+    unsigned int len) {
+  broker_client_entry_rpt_pdu_data pdu_data;
+  if (len > sizeof(pdu_data)) {
+    OLA_WARN << "Got too much data, received " << len << " only expecting "
+             << sizeof(pdu_data);
+    return 0;
+  }
+
+  memcpy(reinterpret_cast<uint8_t*>(&pdu_data), data, sizeof(pdu_data));
+
+  OLA_DEBUG << "Client Entry RPT from " << CID::FromData(pdu_data.client_cid)
+            << " (" << UID(pdu_data.client_uid) << ") of RPT Client Type "
+            << IntToString(pdu_data.rpt_client_type);
+
+  ola::e133::E133RPTClientTypeCode client_type;
+  if (!ola::e133::IntToRPTClientType(pdu_data.rpt_client_type, &client_type)) {
+    OLA_WARN << "Unknown E1.33 RPT Client Type code "
+             << IntToString(pdu_data.rpt_client_type);
+  }
+
+  BrokerClientEntryRPT client_entry(CID::FromData(pdu_data.client_cid),
+                                    UID(pdu_data.client_uid),
+                                    client_type,
+                                    CID::FromData(pdu_data.binding_cid));
+
+  if (m_broker_client_entry_rpt_handler.get()) {
+    m_broker_client_entry_rpt_handler->Run(headers,
+                                           client_entry);
+  } else {
+    OLA_WARN << "No Broker Client Entry RPT handler defined!";
+  }
+  return sizeof(pdu_data);
+}
+}  // namespace acn
+}  // namespace ola