Line data    Source code

       1             : /*
       2             :  * Distributed under the OpenDDS License.
       3             :  * See: http://www.opendds.org/license.html
       4             :  */
       5             : 
       6             : #include <DCPS/DdsDcps_pch.h> // Only the _pch include should start with DCPS/
       7             : 
       8             : #include "debug.h"
       9             : #include "Util.h"
      10             : 
      11             : #ifdef OPENDDS_SECURITY
      12             : #include "PoolAllocator.h"
      13             : #endif
      14             : 
      15             : #include <ace/Log_Msg.h>
      16             : 
      17             : #include <cstring>
      18             : 
      19             : OPENDDS_BEGIN_VERSIONED_NAMESPACE_DECL
      20             : 
      21             : namespace OpenDDS {
      22             : namespace DCPS {
      23             : 
      24             : #ifndef OPENDDS_UTIL_BUILD
      25             : OpenDDS_Dcps_Export unsigned int Transport_debug_level = 0;
      26             : OpenDDS_Dcps_Export TransportDebug transport_debug;
      27             : #endif
      28             : 
      29             : OpenDDS_Dcps_Export LogLevel log_level(LogLevel::Warning);
      30             : OpenDDS_Dcps_Export unsigned int DCPS_debug_level = 0;
      31             : #ifdef OPENDDS_SECURITY
      32             : OpenDDS_Dcps_Export SecurityDebug security_debug;
      33             : #endif
      34             : 
      35          13 : void LogLevel::set(LogLevel::Value value)
      36             : {
      37          13 :   level_ = value;
      38             : #ifdef OPENDDS_SECURITY
      39          13 :   if (level_ >= Notice) {
      40           0 :     security_debug.set_debug_level(1);
      41             :   } else {
      42          13 :     security_debug.set_all_flags_to(false);
      43             :   }
      44             : #endif
      45          13 :   if (level_ >= Debug) {
      46           0 :     if (DCPS_debug_level == 0) {
      47           0 :       DCPS_debug_level = 1;
      48             :     }
      49             :   } else {
      50          13 :     DCPS_debug_level = 0;
      51             : #ifndef OPENDDS_UTIL_BUILD
      52          13 :     Transport_debug_level = 0;
      53          13 :     transport_debug = TransportDebug();
      54             : #endif
      55             :   }
      56          13 : }
      57             : 
      58             : namespace {
      59             :   struct LogLevelNameValue {
      60             :     const char* const name;
      61             :     const LogLevel::Value value;
      62             :   };
      63             :   static const LogLevelNameValue log_levels[] = {
      64             :     {"none", LogLevel::None},
      65             :     {"error", LogLevel::Error},
      66             :     {"warning", LogLevel::Warning},
      67             :     {"notice", LogLevel::Notice},
      68             :     {"info", LogLevel::Info},
      69             :     {"debug", LogLevel::Debug}
      70             :   };
      71             : };
      72             : 
      73           0 : void LogLevel::set_from_string(const char* name)
      74             : {
      75           0 :   for (size_t i = 0; i < array_count(log_levels); ++i) {
      76           0 :     if (!std::strcmp(log_levels[i].name, name)) {
      77           0 :       set(log_levels[i].value);
      78           0 :       return;
      79             :     }
      80             :   }
      81           0 :   if (log_level >= Warning) {
      82           0 :     ACE_ERROR((LM_WARNING, "(%P|%t) WARNING: LogLevel::set_from_string: "
      83             :       "Invalid log level name: %C\n", name));
      84             :   }
      85             : }
      86             : 
      87           0 : const char* LogLevel::get_as_string() const
      88             : {
      89           0 :   const unsigned index = static_cast<unsigned>(get());
      90           0 :   if (index >= array_count(log_levels)) {
      91           0 :     ACE_ERROR((LM_WARNING, "(%P|%t) WARNING: LogLevel::get_as_string: "
      92             :       "Invalid log level value: %u\n", index));
      93           0 :     return "invalid";
      94             :   }
      95           0 :   return log_levels[index].name;
      96             : }
      97             : 
      98           0 : OpenDDS_Dcps_Export void set_DCPS_debug_level(unsigned int lvl)
      99             : {
     100           0 :   if (log_level.get() < LogLevel::Debug) {
     101           0 :     log_level.set(LogLevel::Debug);
     102             :   }
     103           0 :   if (log_level >= LogLevel::Info) {
     104           0 :     ACE_DEBUG((LM_INFO, "(%P|%t) INFO: set_DCPS_debug_level: set to %u\n", lvl));
     105             :   }
     106           0 :   DCPS_debug_level = lvl;
     107           0 : }
     108             : 
     109             : #ifdef OPENDDS_SECURITY
     110           1 : SecurityDebug::SecurityDebug()
     111           1 :   : fake_encryption(false)
     112           1 :   , force_auth_role(FORCE_AUTH_ROLE_NORMAL)
     113             : {
     114           1 :   set_all_flags_to(false);
     115           1 : }
     116             : 
     117          14 : void SecurityDebug::set_all_flags_to(bool value)
     118             : {
     119          14 :   encdec_error = value;
     120          14 :   encdec_warn = value;
     121          14 :   encdec_debug = value;
     122          14 :   auth_debug = value;
     123          14 :   auth_warn = value;
     124          14 :   new_entity_error = value;
     125          14 :   new_entity_warn = value;
     126          14 :   cleanup_error = value;
     127          14 :   access_error = value;
     128          14 :   access_warn = value;
     129          14 :   bookkeeping = value;
     130          14 :   showkeys = value;
     131          14 :   chlookup = value;
     132          14 : }
     133             : 
     134           0 : void SecurityDebug::parse_flags(const ACE_TCHAR* flags)
     135             : {
     136           0 :   String s(ACE_TEXT_ALWAYS_CHAR(flags));
     137           0 :   const String delim(",");
     138             :   while (true) {
     139           0 :     const size_t pos = s.find(delim);
     140           0 :     const String flag = s.substr(0, pos);
     141           0 :     if (flag.length()) {
     142           0 :       if (flag == "all") {
     143           0 :         set_all_flags_to(true);
     144           0 :       } else if (flag == "encdec_error") {
     145           0 :         encdec_error = true;
     146           0 :       } else if (flag == "encdec_warn") {
     147           0 :         encdec_warn = true;
     148           0 :       } else if (flag == "encdec_debug") {
     149           0 :         encdec_debug = true;
     150           0 :       } else if (flag == "auth_debug") {
     151           0 :         auth_debug = true;
     152           0 :       } else if (flag == "auth_warn") {
     153           0 :         auth_warn = true;
     154           0 :       } else if (flag == "new_entity_error") {
     155           0 :         new_entity_error = true;
     156           0 :       } else if (flag == "new_entity_warn") {
     157           0 :         new_entity_warn = true;
     158           0 :       } else if (flag == "cleanup_error") {
     159           0 :         cleanup_error = true;
     160           0 :       } else if (flag == "access_error") {
     161           0 :         access_error = true;
     162           0 :       } else if (flag == "access_warn") {
     163           0 :         access_warn = true;
     164           0 :       } else if (flag == "bookkeeping") {
     165           0 :         bookkeeping = true;
     166           0 :       } else if (flag == "showkeys") {
     167           0 :         showkeys = true;
     168           0 :       } else if (flag == "chlookup") {
     169           0 :         chlookup = true;
     170           0 :       } else if (log_level >= LogLevel::Warning) {
     171           0 :         ACE_ERROR((LM_WARNING, "(%P|%t) WARNING: SecurityDebug::parse_flags: "
     172             :           "Unknown Security Debug Category: \"%C\"\n", flag.c_str()));
     173             :       }
     174             :     }
     175           0 :     if (pos == String::npos) {
     176           0 :       break;
     177             :     }
     178           0 :     s.erase(0, pos + delim.length());
     179           0 :   }
     180           0 : }
     181             : 
     182           0 : void SecurityDebug::set_debug_level(unsigned level)
     183             : {
     184           0 :   access_error = new_entity_error = cleanup_error = level >= 1;
     185           0 :   access_warn = level >= 2;
     186           0 :   auth_warn = encdec_error = level >= 3;
     187           0 :   new_entity_warn = level >= 3;
     188           0 :   auth_debug = encdec_warn = bookkeeping = level >= 4;
     189           0 :   encdec_debug = level >= 8;
     190           0 :   showkeys = level >= 9;
     191           0 :   chlookup = level >= 10;
     192           0 : }
     193             : #endif
     194             : 
     195             : } // namespace DCPS
     196             : } // namespace OpenDDS
     197             : 
     198             : OPENDDS_END_VERSIONED_NAMESPACE_DECL