Revert "LLAMA-17374: Logs indicate missing receiver ID (#85)"

CMakeLists.txt

@@ -216,6 +216,7 @@ if(AUTH_ENABLED)
          add_compile_definitions(AUTH_ACTIVATION_STATUS)
       endif()
       #By default disabled but can be enabled
+      #add_compile_definitions(AUTH_RECEIVER_ID)
       #add_compile_definitions(AUTH_EXPERIENCE)
       target_link_libraries(controlMgr ctrlm-hal-certificate)
    else()

include/ctrlm_ipc.h

@@ -1,5 +1,5 @@
 /*
  * If not stated otherwise in this file or this component's license file the
  * following copyright and licenses apply:
  *
  * Copyright 2014 RDK Management
@@ -156,6 +156,7 @@
 #define CTRLM_MAIN_MAX_BOUND_CONTROLLERS                          (9) ///< Maximum number of bound controllers
 #define CTRLM_MAIN_MAX_CHIPSET_LENGTH                            (16) ///< Maximum length of chipset name string (including null termination)
 #define CTRLM_MAIN_COMMIT_ID_MAX_LENGTH                          (48) ///< Maximum length of commit ID string (including null termination)
+#define CTRLM_MAIN_RECEIVER_ID_MAX_LENGTH                        (40) ///< Maximum length of receiver ID string (including null termination)
 #define CTRLM_MAIN_DEVICE_ID_MAX_LENGTH                          (24) ///< Maximum length of device ID string (including null termination)
 
 #define CTRLM_PROPERTY_ACTIVE_PERIOD_BUTTON_VALUE_MIN               (5000) ///< Minimum active period (in ms) for button binding.
@@ -499,6 +500,7 @@
    char                     ctrlm_version[CTRLM_MAIN_VERSION_LENGTH];           ///< OUT - Software version of Control Manager
    char                     ctrlm_commit_id[CTRLM_MAIN_COMMIT_ID_MAX_LENGTH];   ///< OUT - Last commit ID of Control Manager
    char                     stb_device_id[CTRLM_MAIN_DEVICE_ID_MAX_LENGTH];     ///< OUT - Device ID obtained from the Set-Top Box
+   char                     stb_receiver_id[CTRLM_MAIN_RECEIVER_ID_MAX_LENGTH]; ///< OUT - Receiver ID obtained from the Set-Top Box
 } ctrlm_main_iarm_call_status_t;
 
 /// @brief RF Channel Structure

include/ctrlm_ipc_voice.h

@@ -119,7 +119,7 @@ typedef enum {
    CTRLM_VOICE_SESSION_ABORT_REASON_FAILURE               =  3, ///< Session aborted for any other reason
    CTRLM_VOICE_SESSION_ABORT_REASON_VOICE_DISABLED        =  4, ///< Session aborted because the voice feature is disabled
    CTRLM_VOICE_SESSION_ABORT_REASON_DEVICE_UPDATE         =  5, ///< Session aborted due to device update in progress
-   CTRLM_VOICE_SESSION_ABORT_REASON_NO_AUTH_DATA          =  6, ///< Session aborted due to missing authorization data
+   CTRLM_VOICE_SESSION_ABORT_REASON_NO_RECEIVER_ID        =  6, ///< Session aborted because there is no receiver id
    CTRLM_VOICE_SESSION_ABORT_REASON_NEW_SESSION           =  7, ///< Session aborted because the remote's previous session is still active
    CTRLM_VOICE_SESSION_ABORT_REASON_INVALID_CONTROLLER_ID =  8, ///< Session aborted because the controller id isn't valid
    CTRLM_VOICE_SESSION_ABORT_REASON_APPLICATION_RESTART   =  9, ///< Session aborted due to restarting controlMgr.

src/auth/ctrlm_auth.h

@@ -31,6 +31,7 @@ class ctrlm_auth_t {
    virtual ~ctrlm_auth_t();
 
    virtual bool is_ready()                                    = 0;
+   virtual bool get_receiver_id(std::string &receiver_id)     = 0;
    virtual bool get_device_id(std::string &device_id)         = 0;
    virtual bool get_account_id(std::string &account_id)       = 0;
    virtual bool get_partner_id(std::string &partner_id)       = 0;

src/auth/ctrlm_auth_thunder.cpp

@@ -33,6 +33,11 @@ bool ctrlm_auth_thunder_t::is_ready() {
    return(ret);
 }
 
+bool ctrlm_auth_thunder_t::get_receiver_id(std::string &receiver_id) {
+   bool ret = this->plugin->get_receiver_id(receiver_id);
+   return(ret);
+}
+
 bool ctrlm_auth_thunder_t::get_device_id(std::string &device_id) {
    bool ret = this->plugin->get_device_id(device_id);
    return(ret);

src/auth/ctrlm_auth_thunder.h

@@ -10,6 +10,7 @@ class ctrlm_auth_thunder_t : public ctrlm_auth_t {
    virtual ~ctrlm_auth_thunder_t();
 
    virtual bool is_ready();
+   virtual bool get_receiver_id(std::string &receiver_id);
    virtual bool get_device_id(std::string &device_id);
    virtual bool get_account_id(std::string &account_id);
    virtual bool get_partner_id(std::string &partner_id);

src/auth/ctrlm_thunder_plugin_authservice.cpp

@@ -73,6 +73,24 @@ bool ctrlm_thunder_plugin_authservice_t::is_device_activated() {
     return(ret);
 }
 
+bool ctrlm_thunder_plugin_authservice_t::get_receiver_id(std::string &receiver_id) {
+    bool ret = false;
+    JsonObject params, response;
+    if(this->call_plugin("getDeviceId", (void *)&params, (void *)&response)) {
+        if(response["success"].Boolean()) { // If success doesn't exist, it defaults to false which is fine.
+            receiver_id = response["deviceId"].String();
+            if(!receiver_id.empty()) {
+                ret = true;
+            }
+        } else {
+            XLOGD_WARN("Success for getDeviceId was false");
+        }
+    } else {
+        XLOGD_WARN("Call for getDeviceId failed");
+    }
+    return(ret);
+}
+
 bool ctrlm_thunder_plugin_authservice_t::get_device_id(std::string &device_id) {
     bool ret = false;
     JsonObject params, response;

src/auth/ctrlm_thunder_plugin_authservice.h

@@ -54,6 +54,13 @@ class ctrlm_thunder_plugin_authservice_t : public Thunder::Plugin::ctrlm_thunder
      */
     bool is_device_activated();
 
+    /**
+     * Function that retrieves the Receiver ID from Authservice.
+     * @param receiver_id The reference to a string which will contain the Receiver ID.
+     * @return True on success otherwise False.
+     */
+    bool get_receiver_id(std::string &receiver_id);
+
     /**
      * Function that retrieves the Device ID from Authservice.
      * @param device_id The reference to a string which will contain the Device ID.

src/ctrlm.h

@@ -452,6 +452,7 @@ gboolean                           ctrlm_is_one_touch_autobind_active(void);
 gboolean                           ctrlm_is_binding_table_empty(void);
 gboolean                           ctrlm_is_binding_table_full(void);
 bool                               ctrlm_is_pii_mask_enabled(void);
+gboolean                           ctrlm_main_has_receiver_id_get(void);
 gboolean                           ctrlm_main_has_device_id_get(void);
 gboolean                           ctrlm_main_has_device_type_get(void);
 gboolean                           ctrlm_main_has_service_account_id_get(void);
@@ -506,6 +507,7 @@ void        ctrlm_update_last_key_info(int controller_id, ctrlm_key_source_t sou
 ctrlm_irdb_interface_t* ctrlm_main_irdb_get();
 ctrlm_auth_t* ctrlm_main_auth_get();
 void          ctrlm_main_auth_start_poll();
+std::string ctrlm_receiver_id_get();
 std::string ctrlm_device_id_get();
 std::string ctrlm_stb_name_get();
 std::string ctrlm_device_mac_get();

src/ctrlm_controller.cpp

@@ -106,6 +106,10 @@ ctrlm_network_id_t ctrlm_obj_controller_t::network_id_get() const {
    return(obj_network_->network_id_get());
 }
 
+string ctrlm_obj_controller_t::receiver_id_get() const {
+   return(obj_network_->receiver_id_get());
+}
+
 string ctrlm_obj_controller_t::device_id_get() const {
    return(obj_network_->device_id_get());
 }

src/ctrlm_controller.h

@@ -60,6 +60,7 @@ class ctrlm_obj_controller_t
 
    ctrlm_controller_id_t   controller_id_get() const;
    ctrlm_network_id_t      network_id_get() const;
+   std::string             receiver_id_get() const;
    std::string             device_id_get() const;
    std::string             service_account_id_get() const;
    std::string             partner_id_get() const;

src/ctrlm_main.cpp

@@ -189,6 +189,7 @@ typedef struct {
    sem_t                              ctrlm_utils_sem;
    GAsyncQueue *                      queue;
    string                             stb_name;
+   string                             receiver_id;
    string                             device_id;
    ctrlm_device_type_t                device_type;
    string                             service_account_id;
@@ -205,6 +206,7 @@ typedef struct {
    string                             image_build_time;
    string                             db_path;
    string                             minidump_path;
+   gboolean                           has_receiver_id;
    gboolean                           has_device_id;
    gboolean                           has_device_type;
    gboolean                           has_service_account_id;
@@ -291,6 +293,10 @@ static ctrlm_global_t g_ctrlm;
 #ifdef AUTH_ENABLED
 static gboolean ctrlm_has_authservice_data(void);
 static gboolean ctrlm_load_authservice_data(void);
+#ifdef AUTH_RECEIVER_ID
+static gboolean ctrlm_load_receiver_id(void);
+static void     ctrlm_main_has_receiver_id_set(gboolean has_id);
+#endif
 #ifdef AUTH_DEVICE_ID
 static gboolean ctrlm_load_device_id(void);
 static void     ctrlm_main_has_device_id_set(gboolean has_id);
@@ -573,6 +579,7 @@ int main(int argc, char *argv[]) {
    g_ctrlm.telemetry                      = NULL;
    g_ctrlm.telemetry_report_interval      = JSON_INT_VALUE_CTRLM_GLOBAL_TELEMETRY_REPORT_INTERVAL;
    g_ctrlm.service_access_token.clear();
+   g_ctrlm.has_receiver_id                = false;
    g_ctrlm.has_device_id                  = false;
    g_ctrlm.has_device_type                = false;
    g_ctrlm.has_service_account_id         = false;
@@ -1371,6 +1378,31 @@ void ctrlm_main_auth_start_poll() {
                                                          NULL);
 }
 
+#ifdef AUTH_RECEIVER_ID
+gboolean ctrlm_main_has_receiver_id_get(void) {
+   return(g_ctrlm.has_receiver_id);
+}
+
+void ctrlm_main_has_receiver_id_set(gboolean has_id) {
+   g_ctrlm.has_receiver_id = has_id;
+}
+
+gboolean ctrlm_load_receiver_id(void) {
+   if(!g_ctrlm.authservice->get_receiver_id(g_ctrlm.receiver_id)) {
+      ctrlm_main_has_receiver_id_set(false);
+      return(false);
+   }
+
+   g_ctrlm.voice_session->voice_stb_data_receiver_id_set(g_ctrlm.receiver_id);
+
+   for(auto const &itr : g_ctrlm.networks) {
+      itr.second->receiver_id_set(g_ctrlm.receiver_id);
+   }
+   ctrlm_main_has_receiver_id_set(true);
+   return(true);
+}
+#endif
+
 #ifdef AUTH_DEVICE_ID
 void ctrlm_main_has_device_id_set(gboolean has_id) {
    g_ctrlm.has_device_id   = has_id;
@@ -1518,6 +1550,12 @@ gboolean ctrlm_load_service_access_token(void) {
 gboolean ctrlm_has_authservice_data(void) {
    gboolean ret = TRUE;
 #ifdef AUTH_ENABLED
+#ifdef AUTH_RECEIVER_ID
+   if(!ctrlm_main_has_receiver_id_get()) {
+      ret = FALSE;
+   }
+#endif
+
 #ifdef AUTH_DEVICE_ID
    if(!ctrlm_main_has_device_id_get()) {
       ret = FALSE;
@@ -1556,6 +1594,18 @@ gboolean ctrlm_load_authservice_data(void) {
    gboolean ret = TRUE;
 #ifdef AUTH_ENABLED
    if(g_ctrlm.authservice->is_ready()) {
+#ifdef AUTH_RECEIVER_ID
+   if(!ctrlm_main_has_receiver_id_get()) {
+      XLOGD_INFO("load receiver id");
+      if(!ctrlm_load_receiver_id()) {
+         XLOGD_TELEMETRY("failed to load receiver id");
+         ret = FALSE;
+      } else {
+         XLOGD_INFO("load receiver id successfully <%s>", ctrlm_is_pii_mask_enabled() ? "***" : g_ctrlm.receiver_id.c_str());
+      }
+   }
+#endif
+
 #ifdef AUTH_DEVICE_ID
    if(!ctrlm_main_has_device_id_get()) {
       XLOGD_INFO("load device id");
@@ -3239,6 +3289,10 @@ void ctrlm_main_iarm_call_status_get_(ctrlm_main_iarm_call_status_t *status) {
    safec_rc = strncpy_s(status->stb_device_id, sizeof(status->stb_device_id), g_ctrlm.device_id.c_str(), CTRLM_MAIN_DEVICE_ID_MAX_LENGTH - 1);
    ERR_CHK(safec_rc);
    status->stb_device_id[CTRLM_MAIN_DEVICE_ID_MAX_LENGTH - 1] = '\0';
+
+   safec_rc = strncpy_s(status->stb_receiver_id, sizeof(status->stb_receiver_id), g_ctrlm.receiver_id.c_str(), CTRLM_MAIN_RECEIVER_ID_MAX_LENGTH - 1);
+   ERR_CHK(safec_rc);
+   status->stb_receiver_id[CTRLM_MAIN_RECEIVER_ID_MAX_LENGTH - 1] = '\0';
 }
 
 gboolean ctrlm_main_iarm_call_ir_remote_usage_get(ctrlm_main_iarm_call_ir_remote_usage_t *ir_remote_usage) {
@@ -4763,6 +4817,10 @@ ctrlm_auth_t* ctrlm_main_auth_get() {
 #endif
 }
 
+string ctrlm_receiver_id_get(){
+   return g_ctrlm.receiver_id;
+}
+
 string ctrlm_device_id_get(){
    return g_ctrlm.device_id;
 }
@@ -6068,4 +6126,4 @@ void *ctrlm_load_hal_rf4ce(void) {
 
 gboolean ctrlm_is_rf4ce_enabled(void) {
    return(g_ctrlm.rf4ce_enabled);
-}
+}

src/ctrlm_network.cpp

@@ -155,6 +155,16 @@ const char * ctrlm_obj_network_t::version_get() const {
    return(version_.c_str());
 }
 
+void ctrlm_obj_network_t::receiver_id_set(const string& receiver_id) {
+   THREAD_ID_VALIDATE();
+   receiver_id_ = receiver_id;
+}
+
+string ctrlm_obj_network_t::receiver_id_get() const {
+   THREAD_ID_VALIDATE();
+   return(receiver_id_);
+}
+
 void ctrlm_obj_network_t::device_id_set(const string& device_id) {
    THREAD_ID_VALIDATE();
     device_id_ = device_id;

src/ctrlm_network.h

@@ -167,6 +167,8 @@ class ctrlm_obj_network_t
    const char *         name_get() const;
    const char *         version_get() const;
    virtual std::string  db_name_get() const;
+   void                 receiver_id_set(const std::string& receiver_id);
+   std::string          receiver_id_get()  const;
    virtual void         device_id_set(const std::string& device_id);
    std::string          device_id_get()  const;
    void                 service_account_id_set(const std::string& service_account_id);
@@ -294,6 +296,7 @@ class ctrlm_obj_network_t
 
 private:
    gboolean                     mask_key_codes_ = true;
+   std::string                  receiver_id_;
    std::string                  device_id_;
    std::string                  service_account_id_;
    std::string                  partner_id_;

src/ctrlm_utils.cpp

@@ -690,7 +690,7 @@ const char *ctrlm_voice_session_abort_reason_str(ctrlm_voice_session_abort_reaso
       case CTRLM_VOICE_SESSION_ABORT_REASON_DEVICE_UPDATE:         return("DEVICE_UPDATE");
       case CTRLM_VOICE_SESSION_ABORT_REASON_FAILURE:               return("FAILURE");
       case CTRLM_VOICE_SESSION_ABORT_REASON_VOICE_DISABLED:        return("VOICE_DISABLED");
-      case CTRLM_VOICE_SESSION_ABORT_REASON_NO_AUTH_DATA:          return("NO_AUTH_DATA");
+      case CTRLM_VOICE_SESSION_ABORT_REASON_NO_RECEIVER_ID:        return("NO RECEIVER_ID");
       case CTRLM_VOICE_SESSION_ABORT_REASON_NEW_SESSION:           return("NEW_SESSION");
       case CTRLM_VOICE_SESSION_ABORT_REASON_INVALID_CONTROLLER_ID: return("INVALID_CONTROLLER_ID");
       case CTRLM_VOICE_SESSION_ABORT_REASON_APPLICATION_RESTART:   return("APPLICATION_RESTART");

src/rf4ce/ctrlm_rf4ce_controller.cpp

@@ -2167,13 +2167,44 @@ void ctrlm_obj_controller_rf4ce_t::irdb_entry_id_name_set(ctrlm_irdb_dev_type_t
    }
 }
 
+guchar ctrlm_obj_controller_rf4ce_t::property_write_receiver_id(guchar *data, guchar length) {
+   if(length != CTRLM_RF4CE_RIB_ATTR_LEN_TARGET_ID_DATA) {
+      XLOGD_ERROR("INVALID PARAMETERS");
+      return(0);
+   }
+
+   // We do not want to support overwriting the receiver id
+   XLOGD_WARN("Wrting the receiver id is NOT allowed");
+   return(0);
+}
+
+guchar ctrlm_obj_controller_rf4ce_t::property_read_receiver_id(guchar *data, guchar length) {
+   std::string receiver_id;
+   guchar      len;
+
+   if(length != CTRLM_RF4CE_RIB_ATTR_LEN_TARGET_ID_DATA) {
+      XLOGD_ERROR("INVALID PARAMETERS");
+      return(0);
+   }
+
+   receiver_id = receiver_id_get();
+   len = (receiver_id.length() > length ? length : receiver_id.length());
+
+   // Copy receiver id to data buf
+   errno_t safec_rc = strncpy_s((gchar *)data, CTRLM_HAL_RF4CE_CONST_MAX_RIB_ATTRIBUTE_SIZE, receiver_id.c_str(),len);
+   ERR_CHK(safec_rc);
+
+   return(len);
+
+}
+
 guchar ctrlm_obj_controller_rf4ce_t::property_write_device_id(guchar *data, guchar length) {
    if(length != CTRLM_RF4CE_RIB_ATTR_LEN_TARGET_ID_DATA) {
       XLOGD_ERROR("INVALID PARAMETERS");
       return(0);
    }
 
-   // We do not want to support overwriting the device id
+   // We do not want to support overwriting the receiver id
    XLOGD_WARN("Wrting the device id is NOT allowed");
    return(0);
 }
@@ -2190,7 +2221,7 @@ guchar ctrlm_obj_controller_rf4ce_t::property_read_device_id(guchar *data, gucha
    device_id = device_id_get();
    len = (device_id.length() > length ? length : device_id.length());
 
-   // Copy device id to data buf
+   // Copy receiver id to data buf
    errno_t safec_rc = strncpy_s((gchar *)data, CTRLM_HAL_RF4CE_CONST_MAX_RIB_ATTRIBUTE_SIZE, device_id.c_str(),len);
    ERR_CHK(safec_rc);