RDKEMW-15146 : Introduce mechanism to unlock debug service - read /opt/swupdate.conf

src/deviceutils/device_api.c

@@ -40,6 +40,65 @@
 
 #define MAC_ADDRESS_LEN 17
 
+/* function isSecureDbgSrvUnlocked - determines whether secure debug services may be enabled for the given build type.
+ *       Usage: bool isSecureDbgSrvUnlocked(BUILDTYPE eBuildType)
+ *
+ *       For non-prod builds, debug services are always unlocked.
+ *
+ *       For ePROD builds, debug services are unlocked only when all of the following are true:
+ *           - debug services are enabled via isDebugServicesEnabled() (RFC-controlled),
+ *           - the LABSIGNED_ENABLED device property indicates a labsigned image, and
+ *           - the deviceType value from RFC allows test devices (for example "test").
+ *
+ *       RETURN - true if secure debug services are allowed to run for the given build type; false otherwise.
+ */
+bool isSecureDbgSrvUnlocked(BUILDTYPE eBuildType)
+{ 
+	char deviceType[16] = {0};
+    bool isDebugServicesUnlocked = false;
+	char labsigned[8] = {0};
+	int ret = -1;
+
+    if ((eBuildType != ePROD) && (eBuildType != eUNKNOWN)) {
+        isDebugServicesUnlocked = true;
+    }
+
+    else if (eBuildType == ePROD) 
+	{
+		bool dbgServices = isDebugServicesEnabled();
+		getDeviceTypeRFC(deviceType, sizeof(deviceType));
+        ret = getDevicePropertyData("LABSIGNED_ENABLED", labsigned, sizeof(labsigned));
+        if (ret == UTILS_SUCCESS)
+	    {
+            if (0 == strncmp(labsigned, "true", 4))
+		    {
+		        if ((strcmp(deviceType, "test") == 0) && dbgServices)
+		        {
+                     isDebugServicesUnlocked = true;
+                }   
+		        else
+		        {
+		             SWLOG_INFO("isSecureDbgSrvUnlocked: unable to enable debug services...\n");
+                }
+            }
+            else
+            {
+                SWLOG_INFO("LABSIGNED_ENABLED not enabled (value: %s); debug services remain locked\n", labsigned);
+            }
+        } 
+	    else 
+	    {
+            SWLOG_ERROR("%s: getDevicePropertyData() for LABSIGNED_ENABLED failed\n", __FUNCTION__);
+        }
+		SWLOG_INFO("isSecureDbgSrvUnlocked: dbgServices=%s, deviceType=%s, LABSIGNED_ENABLED=%s\n", dbgServices ? "true" : "false", deviceType, labsigned);	
+	}
+	if(isDebugServicesUnlocked){
+		SWLOG_INFO("isSecureDbgSrvUnlocked: Enabling debug services...\n");
+		t2ValNotify("SYST_INFO_FW_DbgSrv", "true");
+	}
+    return isDebugServicesUnlocked;
+}
+
 /* function GetServerUrlFile - scans a file for a URL. 
         Usage: size_t GetServerUrlFile <char *pServUrl> <size_t szBufSize> <char *pFileName>
 
@@ -891,15 +950,14 @@ size_t GetServURL( char *pServURL, size_t szBufSize )
     BUILDTYPE eBuildType;
     char buf[URL_MAX_LEN];
     bool skip = false;
-    bool dbgServices = isDebugServicesEnabled(); //check debug services enabled
 
     if( pServURL != NULL )
     {
         *pServURL = 0;
         GetBuildType( buf, sizeof(buf), &eBuildType );
         if( isInStateRed() )
         {
-            if(( eBuildType != ePROD )  || ( dbgServices == true ))
+            if(isSecureDbgSrvUnlocked(eBuildType))
             {
                 len = GetServerUrlFile( pServURL, szBufSize, STATE_RED_CONF );
             }
@@ -910,7 +968,7 @@ size_t GetServURL( char *pServURL, size_t szBufSize )
         }
         else
         {
-            if(( eBuildType != ePROD )  || ( dbgServices == true ))
+            if(isSecureDbgSrvUnlocked(eBuildType))
             {
                 if( (filePresentCheck( SWUPDATE_CONF ) == RDK_API_SUCCESS) )    // if the file exists
                 {

src/deviceutils/device_api.h

@@ -23,6 +23,10 @@
     #define GETRDMMANIFESTVERSION_IN_SCRIPT
 #endif
 
+#ifdef GTEST_ENABLE
+#include "rdkv_cdl_log_wrapper.h"
+#endif
+
 #ifndef GTEST_ENABLE
 #include "rdk_fwdl_utils.h"
 #include "common_device_api.h"
@@ -301,4 +305,22 @@ size_t GetTR181Url(TR181URL eURL, char *pUrlOut, size_t szBufSize);
 */
 size_t GetServURL(char *pServURL, size_t szBufSize);
 
+/* function isSecureDbgSrvUnlocked - determines whether the secure debug service may be unlocked.
+ *
+ *         The decision is based on:
+ *           - DbgServices RFC
+ *           - DeviceType RFC
+ *           - build type (Prod vs non-Prod; e.g. ePROD vs known non-ePROD types; eUNKNOWN is
+ *             treated as locked/Prod-like)
+ *           - LABSIGNED_ENABLED property value from /etc/device.properties
+ *
+ *         Usage: bool isSecureDbgSrvUnlocked(BUILDTYPE eBuildType)
+ *
+ *         RETURN - true if:
+ *                    - the build type is non-Prod (i.e. not ePROD and not eUNKNOWN); or
+ *                    - the build type is Prod, DbgServices RFC is enabled,
+ *                      DeviceType is "test", and LABSIGNED_ENABLED is set to true;
+ *                  false otherwise (including when the build type is eUNKNOWN).
+ */
+bool isSecureDbgSrvUnlocked(BUILDTYPE eBuildType);
 #endif

src/include/rfcinterface.h

@@ -86,6 +86,7 @@ typedef struct rfcdetails {
 #define RFC_FW_REBOOT_NOTIFY "Device.DeviceInfo.X_RDKCENTRAL-COM_xOpsDeviceMgmt.RPC.RebootPendingNotification"
 #define RFC_FW_AUTO_EXCLUDE "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.FWUpdate.AutoExcluded.Enable"
 #define RFC_DEBUGSRV "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Identity.DbgServices.Enable"
+#define RFC_DEVICETYPE "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Identity.DeviceType"
 
 #define RFC_XCONF_CHECK_NOW "Device.X_COMCAST-COM_Xcalibur.Client.xconfCheckNow"
 
@@ -98,5 +99,6 @@ int isMtlsEnabled(const char *);
 int isIncremetalCDLEnable(const char *file_name);
 bool isMmgbleNotifyEnabled(void);
 bool isDebugServicesEnabled(void);
+void getDeviceTypeRFC(char *deviceType, size_t size);
 
 #endif /* VIDEO_RFCINTERFACE_RFCINTERFACE_H_ */

src/rfcInterface/rfcinterface.c

@@ -25,6 +25,7 @@
 #include "rdk_fwdl_utils.h"
 #include "system_utils.h"
 #endif
+#include <strings.h>
 
 /*
  * Description: Get RFC data and store inside structure.
@@ -308,3 +309,36 @@ bool isDebugServicesEnabled(void)
     }
     return status;
 }
+
+
+/* Description: Reads the device type RFC value and copies it into the provided buffer.
+ * @param deviceType Output buffer that receives the device type string ("test", "prod", or "unknown").
+ * @param size       Size of the deviceType buffer in bytes; must be greater than 0. The string is always NUL-terminated.
+ * @return void. On error or unrecognized RFC value, "unknown" is written to deviceType (if size > 0).
+ */
+void getDeviceTypeRFC(char *deviceType, size_t size ){
+
+	if (deviceType == NULL || size == 0){
+        SWLOG_ERROR("%s: Invalid Arguments Passed...\n", __FUNCTION__);
+		return;
+	}
+
+	const char* type = "unknown";
+    char rfc_data[RFC_VALUE_BUF_SIZE] = {0};
+    int ret = read_RFCProperty("DEVICETYPE", RFC_DEVICETYPE, rfc_data, sizeof(rfc_data));
+
+    if (ret == -1) {
+        SWLOG_ERROR("%s: Failed to read device type\n", __FUNCTION__);
+	}
+
+    SWLOG_INFO("%s: RFC device type = %s\n", __FUNCTION__, rfc_data);
+
+    if (strncasecmp(rfc_data, "prod", 4) == 0) {
+        type = "prod";
+    } else if (strncasecmp(rfc_data, "test", 4) == 0) {
+        type = "test";
+    } 
+
+	strncpy(deviceType, type, size - 1);
+    deviceType[size - 1] = '\0';
+}