fixed potential crash when SendCommand returns NULL

[deb_libcec.git] / src / lib / adapter / Pulse-Eight / USBCECAdapterCommands.cpp

diff --git a/src/lib/adapter/Pulse-Eight/USBCECAdapterCommands.cpp b/src/lib/adapter/Pulse-Eight/USBCECAdapterCommands.cpp
index bbd15d4b0b230edf42b76e0042396f35489f6ffe..85050334a0a99841370251e11229cc964a0173bd 100644 (file)
--- a/src/lib/adapter/Pulse-Eight/USBCECAdapterCommands.cpp
+++ b/src/lib/adapter/Pulse-Eight/USBCECAdapterCommands.cpp
@@ -1,7 +1,7 @@
 /*
  * This file is part of the libCEC(R) library.
  *
- * libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited.  All rights reserved.
+ * libCEC(R) is Copyright (C) 2011-2013 Pulse-Eight Limited.  All rights reserved.
  * libCEC(R) is an original work, containing original code.
  *
  * libCEC(R) is a trademark of Pulse-Eight Limited.
@@ -38,6 +38,7 @@
 #include "lib/LibCEC.h"
 #include "lib/CECProcessor.h"
 #include "lib/CECTypeUtils.h"
+#include "lib/platform/util/util.h"
 #include <stdio.h>
 
 using namespace CEC;
@@ -53,7 +54,9 @@ CUSBCECAdapterCommands::CUSBCECAdapterCommands(CUSBCECAdapterCommunication *comm
     m_settingCecVersion(CEC_VERSION_UNKNOWN),
     m_iSettingLAMask(0),
     m_bNeedsWrite(false),
-    m_iBuildDate(CEC_FW_BUILD_UNKNOWN)
+    m_iBuildDate(CEC_FW_BUILD_UNKNOWN),
+    m_bControlledMode(false),
+    m_adapterType(P8_ADAPTERTYPE_UNKNOWN)
 {
   m_persistedConfiguration.Clear();
 }
@@ -65,14 +68,14 @@ cec_datapacket CUSBCECAdapterCommands::RequestSetting(cec_adapter_messagecode ms
 
   CCECAdapterMessage params;
   CCECAdapterMessage *message = m_comm->SendCommand(msgCode, params);
-  if (message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED)
+  if (message && message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED)
   {
     retVal = message->response;
     retVal.Shift(2); // shift out start and msgcode
     retVal.size -= 1; // remove end
   }
 
-  delete message;
+  DELETE_AND_NULL(message);
   return retVal;
 }
 
@@ -83,13 +86,15 @@ uint16_t CUSBCECAdapterCommands::RequestFirmwareVersion(void)
 
   while (m_persistedConfiguration.iFirmwareVersion == CEC_FW_VERSION_UNKNOWN && iFwVersionTry++ < 3)
   {
+#ifdef CEC_DEBUGGING
     LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting the firmware version");
+#endif
     cec_datapacket response = RequestSetting(MSGCODE_FIRMWARE_VERSION);
     if (response.size == 2)
       m_persistedConfiguration.iFirmwareVersion = (response[0] << 8 | response[1]);
     else
     {
-      LIB_CEC->AddLog(CEC_LOG_WARNING, "the adapter did not respond with a correct firmware version (try %d)", iFwVersionTry);
+      LIB_CEC->AddLog(CEC_LOG_WARNING, "the adapter did not respond with a correct firmware version (try %d, size = %d)", iFwVersionTry, response.size);
       CEvent::Sleep(500);
     }
   }
@@ -100,12 +105,18 @@ uint16_t CUSBCECAdapterCommands::RequestFirmwareVersion(void)
     m_persistedConfiguration.iFirmwareVersion = 1;
   }
 
+  // firmware versions < 2 don't have an autonomous mode
+  if (m_persistedConfiguration.iFirmwareVersion < 2)
+    m_bControlledMode = true;
+
   return m_persistedConfiguration.iFirmwareVersion;
 }
 
 bool CUSBCECAdapterCommands::RequestSettingAutoEnabled(void)
 {
+#ifdef CEC_DEBUGGING
   LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting autonomous mode setting");
+#endif
 
   cec_datapacket response = RequestSetting(MSGCODE_GET_AUTO_ENABLED);
   if (response.size == 1)
@@ -119,7 +130,9 @@ bool CUSBCECAdapterCommands::RequestSettingAutoEnabled(void)
 
 bool CUSBCECAdapterCommands::RequestSettingCECVersion(void)
 {
+#ifdef CEC_DEBUGGING
   LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting CEC version setting");
+#endif
 
   cec_datapacket response = RequestSetting(MSGCODE_GET_HDMI_VERSION);
   if (response.size == 1)
@@ -131,11 +144,28 @@ bool CUSBCECAdapterCommands::RequestSettingCECVersion(void)
   return false;
 }
 
+p8_cec_adapter_type CUSBCECAdapterCommands::RequestAdapterType(void)
+{
+  if (m_adapterType == P8_ADAPTERTYPE_UNKNOWN)
+  {
+#ifdef CEC_DEBUGGING
+    LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting adapter type");
+#endif
+
+    cec_datapacket response = RequestSetting(MSGCODE_GET_ADAPTER_TYPE);
+    if (response.size == 1)
+      m_adapterType = (p8_cec_adapter_type)response[0];
+  }
+  return m_adapterType;
+}
+
 uint32_t CUSBCECAdapterCommands::RequestBuildDate(void)
 {
   if (m_iBuildDate == CEC_FW_BUILD_UNKNOWN)
   {
+#ifdef CEC_DEBUGGING
     LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting firmware build date");
+#endif
 
     cec_datapacket response = RequestSetting(MSGCODE_GET_BUILDDATE);
     if (response.size == 4)
@@ -146,7 +176,9 @@ uint32_t CUSBCECAdapterCommands::RequestBuildDate(void)
 
 bool CUSBCECAdapterCommands::RequestSettingDefaultLogicalAddress(void)
 {
+#ifdef CEC_DEBUGGING
   LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting default logical address setting");
+#endif
 
   cec_datapacket response = RequestSetting(MSGCODE_GET_DEFAULT_LOGICAL_ADDRESS);
   if (response.size == 1)
@@ -160,7 +192,9 @@ bool CUSBCECAdapterCommands::RequestSettingDefaultLogicalAddress(void)
 
 bool CUSBCECAdapterCommands::RequestSettingDeviceType(void)
 {
+#ifdef CEC_DEBUGGING
   LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting device type setting");
+#endif
   m_persistedConfiguration.deviceTypes.Clear();
 
   cec_datapacket response = RequestSetting(MSGCODE_GET_DEVICE_TYPE);
@@ -176,7 +210,9 @@ bool CUSBCECAdapterCommands::RequestSettingDeviceType(void)
 
 bool CUSBCECAdapterCommands::RequestSettingLogicalAddressMask(void)
 {
+#ifdef CEC_DEBUGGING
   LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting logical address mask setting");
+#endif
 
   cec_datapacket response = RequestSetting(MSGCODE_GET_LOGICAL_ADDRESS_MASK);
   if (response.size == 2)
@@ -190,7 +226,9 @@ bool CUSBCECAdapterCommands::RequestSettingLogicalAddressMask(void)
 
 bool CUSBCECAdapterCommands::RequestSettingOSDName(void)
 {
+#ifdef CEC_DEBUGGING
   LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting OSD name setting");
+#endif
 
   memset(m_persistedConfiguration.strDeviceName, 0, 13);
   cec_datapacket response = RequestSetting(MSGCODE_GET_OSD_NAME);
@@ -212,7 +250,9 @@ bool CUSBCECAdapterCommands::RequestSettingOSDName(void)
 
 bool CUSBCECAdapterCommands::RequestSettingPhysicalAddress(void)
 {
+#ifdef CEC_DEBUGGING
   LIB_CEC->AddLog(CEC_LOG_DEBUG, "requesting physical address setting");
+#endif
 
   cec_datapacket response = RequestSetting(MSGCODE_GET_PHYSICAL_ADDRESS);
   if (response.size == 2)
@@ -230,20 +270,26 @@ bool CUSBCECAdapterCommands::SetSettingAutoEnabled(bool enabled)
   bool bReturn(false);
 
   /* check whether this value was changed */
-  if (m_bSettingAutoEnabled == enabled)
-    return bReturn;
+  {
+    CLockObject lock(m_mutex);
+    if (m_bSettingAutoEnabled == enabled)
+      return bReturn;
+    m_bNeedsWrite = true;
+  }
 
-  m_bNeedsWrite = true;
   LIB_CEC->AddLog(CEC_LOG_DEBUG, "turning autonomous mode %s", enabled ? "on" : "off");
 
   CCECAdapterMessage params;
   params.PushEscaped(enabled ? 1 : 0);
   CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_AUTO_ENABLED, params);
-  bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
-  delete message;
+  bReturn = message && message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
+  DELETE_AND_NULL(message);
 
   if (bReturn)
+  {
+    CLockObject lock(m_mutex);
     m_bSettingAutoEnabled = enabled;
+  }
 
   return bReturn;
 }
@@ -253,17 +299,26 @@ bool CUSBCECAdapterCommands::SetSettingDeviceType(cec_device_type type)
   bool bReturn(false);
 
   /* check whether this value was changed */
-  if (m_persistedConfiguration.deviceTypes.types[0] == type)
-    return bReturn;
+  {
+    CLockObject lock(m_mutex);
+    if (m_persistedConfiguration.deviceTypes.types[0] == type)
+      return bReturn;
+    m_bNeedsWrite = true;
+  }
 
-  m_bNeedsWrite = true;
   LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting the device type to %X (previous: %X)", (uint8_t)type, (uint8_t)m_persistedConfiguration.deviceTypes.types[0]);
 
   CCECAdapterMessage params;
   params.PushEscaped((uint8_t)type);
   CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_DEVICE_TYPE, params);
-  bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
-  delete message;
+  bReturn = message && message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
+  DELETE_AND_NULL(message);
+
+  if (bReturn)
+  {
+    CLockObject lock(m_mutex);
+    m_persistedConfiguration.deviceTypes.types[0] = type;
+  }
 
   return bReturn;
 }
@@ -273,20 +328,26 @@ bool CUSBCECAdapterCommands::SetSettingDefaultLogicalAddress(cec_logical_address
   bool bReturn(false);
 
   /* check whether this value was changed */
-  if (m_persistedConfiguration.logicalAddresses.primary == address)
-    return bReturn;
+  {
+    CLockObject lock(m_mutex);
+    if (m_persistedConfiguration.logicalAddresses.primary == address)
+      return bReturn;
+    m_bNeedsWrite = true;
+  }
 
-  m_bNeedsWrite = true;
   LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting the default logical address to %X (previous: %X)", (uint8_t)address, (uint8_t)m_persistedConfiguration.logicalAddresses.primary);
 
   CCECAdapterMessage params;
   params.PushEscaped((uint8_t)address);
   CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_DEFAULT_LOGICAL_ADDRESS, params);
-  bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
-  delete message;
+  bReturn = message && message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
+  DELETE_AND_NULL(message);
 
   if (bReturn)
+  {
+    CLockObject lock(m_mutex);
     m_persistedConfiguration.logicalAddresses.primary = address;
+  }
 
   return bReturn;
 }
@@ -296,21 +357,27 @@ bool CUSBCECAdapterCommands::SetSettingLogicalAddressMask(uint16_t iMask)
   bool bReturn(false);
 
   /* check whether this value was changed */
-  if (m_iSettingLAMask == iMask)
-    return bReturn;
+  {
+    CLockObject lock(m_mutex);
+    if (m_iSettingLAMask == iMask)
+      return bReturn;
+    m_bNeedsWrite = true;
+  }
 
-  m_bNeedsWrite = true;
   LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting the logical address mask to %2X (previous: %2X)", iMask, m_iSettingLAMask);
 
   CCECAdapterMessage params;
   params.PushEscaped(iMask >> 8);
   params.PushEscaped((uint8_t)iMask);
   CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_LOGICAL_ADDRESS_MASK, params);
-  bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
-  delete message;
+  bReturn = message && message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
+  DELETE_AND_NULL(message);
 
   if (bReturn)
+  {
+    CLockObject lock(m_mutex);
     m_iSettingLAMask = iMask;
+  }
 
   return bReturn;
 }
@@ -320,21 +387,27 @@ bool CUSBCECAdapterCommands::SetSettingPhysicalAddress(uint16_t iPhysicalAddress
   bool bReturn(false);
 
   /* check whether this value was changed */
-  if (m_persistedConfiguration.iPhysicalAddress == iPhysicalAddress)
-    return bReturn;
+  {
+    CLockObject lock(m_mutex);
+    if (m_persistedConfiguration.iPhysicalAddress == iPhysicalAddress)
+      return bReturn;
+    m_bNeedsWrite = true;
+  }
 
-  m_bNeedsWrite = true;
   LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting the physical address to %04X (previous: %04X)", iPhysicalAddress, m_persistedConfiguration.iPhysicalAddress);
 
   CCECAdapterMessage params;
   params.PushEscaped(iPhysicalAddress >> 8);
   params.PushEscaped((uint8_t)iPhysicalAddress);
   CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_PHYSICAL_ADDRESS, params);
-  bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
-  delete message;
+  bReturn = message && message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
+  DELETE_AND_NULL(message);
 
   if (bReturn)
+  {
+    CLockObject lock(m_mutex);
     m_persistedConfiguration.iPhysicalAddress = iPhysicalAddress;
+  }
 
   return bReturn;
 }
@@ -344,20 +417,26 @@ bool CUSBCECAdapterCommands::SetSettingCECVersion(cec_version version)
   bool bReturn(false);
 
   /* check whether this value was changed */
-  if (m_settingCecVersion == version)
-    return bReturn;
+  {
+    CLockObject lock(m_mutex);
+    if (m_settingCecVersion == version)
+      return bReturn;
+    m_bNeedsWrite = true;
+  }
 
-  m_bNeedsWrite = true;
   LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting the CEC version to %s (previous: %s)", ToString(version), ToString(m_settingCecVersion));
 
   CCECAdapterMessage params;
   params.PushEscaped((uint8_t)version);
   CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_HDMI_VERSION, params);
-  bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
-  delete message;
+  bReturn = message && message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
+  DELETE_AND_NULL(message);
 
   if (bReturn)
+  {
+    CLockObject lock(m_mutex);
     m_settingCecVersion = version;
+  }
 
   return bReturn;
 }
@@ -376,8 +455,8 @@ bool CUSBCECAdapterCommands::SetSettingOSDName(const char *strOSDName)
   for (size_t iPtr = 0; iPtr < strlen(strOSDName); iPtr++)
     params.PushEscaped(strOSDName[iPtr]);
   CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_OSD_NAME, params);
-  bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
-  delete message;
+  bReturn = message && message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
+  DELETE_AND_NULL(message);
 
   if (bReturn)
     snprintf(m_persistedConfiguration.strDeviceName, 13, "%s", strOSDName);
@@ -387,16 +466,26 @@ bool CUSBCECAdapterCommands::SetSettingOSDName(const char *strOSDName)
 
 bool CUSBCECAdapterCommands::WriteEEPROM(void)
 {
-  if (!m_bNeedsWrite)
-    return true;
+  {
+    CLockObject lock(m_mutex);
+    if (!m_bNeedsWrite)
+      return true;
+  }
 
   LIB_CEC->AddLog(CEC_LOG_DEBUG, "writing settings in the EEPROM");
 
   CCECAdapterMessage params;
   CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_WRITE_EEPROM, params);
-  m_bNeedsWrite = !(message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED);
-  delete message;
-  return m_bNeedsWrite;
+  bool bReturn = message && message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
+  DELETE_AND_NULL(message);
+
+  if (bReturn)
+  {
+    CLockObject lock(m_mutex);
+    m_bNeedsWrite = false;
+  }
+
+  return bReturn;
 }
 
 bool CUSBCECAdapterCommands::PersistConfiguration(const libcec_configuration &configuration)
@@ -480,12 +569,14 @@ bool CUSBCECAdapterCommands::GetConfiguration(libcec_configuration &configuratio
 
 bool CUSBCECAdapterCommands::PingAdapter(void)
 {
+#ifdef CEC_DEBUGGING
   LIB_CEC->AddLog(CEC_LOG_DEBUG, "sending ping");
+#endif
 
   CCECAdapterMessage params;
   CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_PING, params);
-  bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
-  delete message;
+  bool bReturn = message && message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
+  DELETE_AND_NULL(message);
   return bReturn;
 }
 
@@ -497,19 +588,32 @@ bool CUSBCECAdapterCommands::SetAckMask(uint16_t iMask)
   params.PushEscaped(iMask >> 8);
   params.PushEscaped((uint8_t)iMask);
   CCECAdapterMessage *message  = m_comm->SendCommand(MSGCODE_SET_ACK_MASK, params);
-  bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
-  delete message;
+  bool bReturn = message && message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
+  DELETE_AND_NULL(message);
   return bReturn;
 }
 
+void CUSBCECAdapterCommands::SetActiveSource(bool bSetTo, bool bClientUnregistered)
+{
+  if (bClientUnregistered) return;
+  if (m_persistedConfiguration.iFirmwareVersion >= 3)
+  {
+    LIB_CEC->AddLog(CEC_LOG_DEBUG, "marking the adapter as %s source", bSetTo ? "active" : "inactive");
+    CCECAdapterMessage params;
+    params.PushEscaped(bSetTo ? 1 : 0);
+    CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_ACTIVE_SOURCE, params);
+    DELETE_AND_NULL(message);
+  }
+}
+
 bool CUSBCECAdapterCommands::StartBootloader(void)
 {
   LIB_CEC->AddLog(CEC_LOG_DEBUG, "starting the bootloader");
 
   CCECAdapterMessage params;
   CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_START_BOOTLOADER, params);
-  bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
-  delete message;
+  bool bReturn = message && message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
+  DELETE_AND_NULL(message);
   return bReturn;
 }
 
@@ -519,19 +623,32 @@ bool CUSBCECAdapterCommands::SetLineTimeout(uint8_t iTimeout)
   CCECAdapterMessage params;
   params.PushEscaped(iTimeout);
   CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_TRANSMIT_IDLETIME, params);
-  bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
-  delete message;
+  bool bReturn = message && message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
+  DELETE_AND_NULL(message);
   return bReturn;
 }
 
 bool CUSBCECAdapterCommands::SetControlledMode(bool controlled)
 {
+  {
+    CLockObject lock(m_mutex);
+    if (m_bControlledMode == controlled)
+      return true;
+  }
+
   LIB_CEC->AddLog(CEC_LOG_DEBUG, "turning controlled mode %s", controlled ? "on" : "off");
 
   CCECAdapterMessage params;
   params.PushEscaped(controlled ? 1 : 0);
   CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_CONTROLLED, params);
-  bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
-  delete message;
+  bool bReturn = message && message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
+  DELETE_AND_NULL(message);
+
+  if (bReturn)
+  {
+    CLockObject lock(m_mutex);
+    m_bControlledMode = controlled;
+  }
+
   return bReturn;
 }