VLog.cxx
上传用户:sy_wanhua
上传日期:2013-07-25
资源大小:3048k
文件大小:17k
源码类别:

流媒体/Mpeg4/MP4

开发平台:

C/C++

  1. /* ====================================================================
  2.  * The Vovida Software License, Version 1.0 
  3.  * 
  4.  * Copyright (c) 2000 Vovida Networks, Inc.  All rights reserved.
  5.  * 
  6.  * Redistribution and use in source and binary forms, with or without
  7.  * modification, are permitted provided that the following conditions
  8.  * are met:
  9.  * 
  10.  * 1. Redistributions of source code must retain the above copyright
  11.  *    notice, this list of conditions and the following disclaimer.
  12.  * 
  13.  * 2. Redistributions in binary form must reproduce the above copyright
  14.  *    notice, this list of conditions and the following disclaimer in
  15.  *    the documentation and/or other materials provided with the
  16.  *    distribution.
  17.  * 
  18.  * 3. The names "VOCAL", "Vovida Open Communication Application Library",
  19.  *    and "Vovida Open Communication Application Library (VOCAL)" must
  20.  *    not be used to endorse or promote products derived from this
  21.  *    software without prior written permission. For written
  22.  *    permission, please contact vocal@vovida.org.
  23.  *
  24.  * 4. Products derived from this software may not be called "VOCAL", nor
  25.  *    may "VOCAL" appear in their name, without prior written
  26.  *    permission of Vovida Networks, Inc.
  27.  * 
  28.  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
  29.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  30.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
  31.  * NON-INFRINGEMENT ARE DISCLAIMED.  IN NO EVENT SHALL VOVIDA
  32.  * NETWORKS, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT DAMAGES
  33.  * IN EXCESS OF $1,000, NOR FOR ANY INDIRECT, INCIDENTAL, SPECIAL,
  34.  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  35.  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  36.  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  37.  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  38.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  39.  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  40.  * DAMAGE.
  41.  * 
  42.  * ====================================================================
  43.  * 
  44.  * This software consists of voluntary contributions made by Vovida
  45.  * Networks, Inc. and many individuals on behalf of Vovida Networks,
  46.  * Inc.  For more information on Vovida Networks, Inc., please see
  47.  * <http://www.vovida.org/>.
  48.  *
  49.  */
  50. static const char* const VLog_cxx_Version = 
  51.     "$Id: VLog.cxx,v 1.6 2001/04/22 05:36:43 icahoon Exp $";
  52. #include "VLog.hxx"
  53. #include "CpPriorityLog.hxx"
  54. #include <cassert>
  55. #include <cctype>
  56. #include <string>
  57. using Vocal::Logging::VLog;
  58. using Vocal::Logging::Log;
  59. using Vocal::Logging::PriorityLog;
  60. using Vocal::Logging::CpPriorityLog;
  61. using std::string;
  62. Sptr<PriorityLog>   VLog::null_ = 0;
  63. bool          VLog::traceOn_ = false;
  64. bool          VLog::verboseOn_ = false;
  65. VLog::VLog()
  66.     : emergency_(0),
  67.      alert_(0),
  68.      critical_(0),
  69. error_(0),
  70.      warning_(0),
  71.      notice_(0),
  72.      info_(0),
  73.      debug_(0),
  74.      debugStack_(0),
  75.      debugOper_(0),
  76.      debugHB_(0),
  77. trace_(traceOn_),
  78. verbose_(verboseOn_),
  79. funcName_("")
  80. {
  81.     if ( null_ == 0 )
  82.     {
  83.      init(cpLogGetPriority());
  84.     }
  85. }
  86. VLog::VLog(const string & funcName)
  87.     : emergency_(0),
  88.      alert_(0),
  89.      critical_(0),
  90. error_(0),
  91.      warning_(0),
  92.      notice_(0),
  93.      info_(0),
  94.      debug_(0),
  95.      debugStack_(0),
  96.      debugOper_(0),
  97.      debugHB_(0),
  98. trace_(traceOn_),
  99. verbose_(verboseOn_),
  100. funcName_(funcName)
  101. {
  102.     if ( null_ == 0 )
  103.     {
  104.      init(cpLogGetPriority());
  105.     }
  106.     
  107.     if ( funcName.size() )
  108.     {
  109.         VTRACE(*this) << "Function Entry: " << funcName << VTRACE_END(*this);
  110.     }
  111. }
  112. VLog::~VLog()
  113. {
  114.     if ( funcName_.size() )
  115.     {
  116.         VTRACE(*this) << "Function Exit: " << funcName_ << VTRACE_END(*this);
  117.     }
  118. }
  119. void
  120. VLog::init(
  121.     int       priority,
  122.     const char * file
  123. )
  124. {
  125.     int priorityLevel = priority;
  126.     
  127.     if ( priorityLevel > LAST_PRIORITY )
  128.     {
  129.         priorityLevel = LAST_PRIORITY;
  130.     }
  131.     
  132.     // cpLogSetPriority(priorityLevel);
  133.     if ( file )
  134.     {
  135.      // cpLogOpen's signature is broken, so let's cast away const.
  136.         //
  137.      char * f = const_cast<char *>(file);
  138.         cpLogOpen(f);
  139.     }
  140.     null_ = new CpPriorityLog("--NULL---", -1, false, false);
  141.     registerLog(-1, null_);
  142.     
  143.     registerLog(LOG_EMERG,  new CpPriorityLog("EMERGENCY", LOG_EMERG, true));
  144.     registerLog(LOG_ALERT,  new CpPriorityLog("ALRT     ", LOG_ALERT, true));
  145.     registerLog(LOG_CRIT,   new CpPriorityLog("CRITICAL ", LOG_CRIT,  true));
  146.     registerLog(LOG_ERR,    new CpPriorityLog("ERROR    ", LOG_ERR,     false, false));
  147.     registerLog(LOG_WARNING,new CpPriorityLog("WARNING  ", LOG_WARNING, false, false));
  148.     registerLog(LOG_NOTICE, new CpPriorityLog("NOTICE   ", LOG_NOTICE,  false, false));
  149.     registerLog(LOG_INFO,   new CpPriorityLog("INFO     ", LOG_INFO,    false, false));
  150.     registerLog(LOG_DEBUG,  new CpPriorityLog("DEBUG    ", LOG_DEBUG,   false, false));
  151.     registerLog(LOG_DEBUG_STACK,new CpPriorityLog("DEBUG_STK", LOG_DEBUG_STACK, false, false));
  152.     registerLog(LOG_DEBUG_OPER, new CpPriorityLog("DEBUG_OP ", LOG_DEBUG_OPER,  false, false));
  153.     registerLog(LOG_DEBUG_HB,   new CpPriorityLog("DEBUG_HB ", LOG_DEBUG_HB,    false, false));
  154.     switch ( priority )
  155.     {
  156.         case LOG_VERBOSE:       VLog::on(LOG_VERBOSE);
  157.         case LOG_TRACE:         VLog::on(LOG_TRACE);
  158.         case LOG_DEBUG_HB:
  159.         case LOG_DEBUG_OPER:    VLog::on(LOG_DEBUG_OPER);
  160.         case LOG_DEBUG_STACK:   VLog::on(LOG_DEBUG_STACK);
  161.         case LOG_DEBUG:         VLog::on(LOG_DEBUG);
  162.         case LOG_INFO:          VLog::on(LOG_INFO);
  163.         case LOG_NOTICE:        VLog::on(LOG_NOTICE);
  164.         case LOG_WARNING:       VLog::on(LOG_WARNING);
  165.         case LOG_ERR:           VLog::on(LOG_ERR);
  166.     }
  167.     // You only get heartbeat logging if you explicitly ask for it.
  168.     //
  169.     if ( priority == LOG_DEBUG_HB )
  170.     {
  171.         VLog::on(LOG_DEBUG_HB);
  172.     }
  173. }
  174. void
  175. VLog::uninit()
  176. {
  177.     clearLogs();
  178.     null_ = 0;
  179. }
  180. void               
  181. VLog::on(int priority)
  182. {
  183.     if ( priority == LOG_TRACE )
  184.     {
  185.      traceOn_ = true;
  186. priority = LOG_DEBUG_STACK;
  187.     }
  188.     if ( priority == LOG_VERBOSE )
  189.     {
  190.      verboseOn_ = true;
  191. priority = LOG_DEBUG_STACK;
  192.     }
  193.     
  194.     LogMap::iterator it = log_.find(priority);
  195.     Sptr<PriorityLog> nullLog = 0;
  196.     Sptr<PriorityLog> log = ( it == log_.end() ? nullLog : (*it).second );
  197.     if ( priority != -1 && log != 0 )
  198.     {
  199.      log->on();
  200.     }
  201. }
  202. void               
  203. VLog::off(int priority)
  204. {
  205.     if ( priority == LOG_TRACE )
  206.     {
  207.      traceOn_ = false;
  208. return;
  209.     }
  210.     if ( priority == LOG_VERBOSE )
  211.     {
  212.      verboseOn_ = false;
  213. return;
  214.     }
  215.     
  216.     LogMap::iterator it = log_.find(priority);
  217.     Sptr<PriorityLog> nullLog = 0;
  218.     Sptr<PriorityLog> log = ( it == log_.end() ? nullLog : (*it).second );
  219.     if ( log != 0 )
  220.     {
  221.      log->off();
  222.     }
  223. }
  224. void               
  225. VLog::logOn(int priority)
  226. {
  227.     if ( priority == LOG_TRACE )
  228.     {
  229.      priority = LOG_DEBUG_STACK;
  230. trace_ = true;
  231.     }
  232.     if ( priority == LOG_VERBOSE )
  233.     {
  234.      priority = LOG_DEBUG_STACK;
  235. verbose_ = true;
  236.     }
  237.     LogMap::iterator it = log_.find(priority);
  238.     Sptr<PriorityLog> nullLog = 0;
  239.     Sptr<PriorityLog> log = ( it == log_.end() ? nullLog : (*it).second );
  240.     if ( priority != -1 && log != 0 )
  241.     {
  242. switch ( priority )
  243. {
  244.          case LOG_EMERG:
  245.     {
  246.      if ( emergency_ == 0 || emergency_ == VLog::null_ )
  247. {
  248.              emergency_ = log->clone();
  249.          emergency_->on();
  250. }
  251.      break;
  252.     }
  253.          case LOG_ALERT:
  254.     {
  255.      if ( alert_ == 0 || alert_ == VLog::null_ )
  256. {
  257.              alert_ = log->clone();
  258.          alert_->on();
  259. }
  260.      break;
  261.     }
  262.          case LOG_CRIT:
  263.     {
  264.      if ( critical_ == 0 || critical_ == VLog::null_ )
  265. {
  266.              critical_ = log->clone();
  267.          critical_->on();
  268. }
  269.      break;
  270.          }
  271.          case LOG_ERR:
  272.     {
  273.      if ( error_ == 0 || error_ == VLog::null_ )
  274. {
  275.              error_ = log->clone();
  276.          error_->on();
  277. }
  278.      break;
  279.     }
  280.          case LOG_WARNING:
  281.     {
  282.      if ( warning_ == 0 || warning_ == VLog::null_ )
  283. {
  284.              warning_ = log->clone();
  285.          warning_->on();
  286. }
  287.      break;
  288.     }
  289.          case LOG_NOTICE:
  290.     {
  291.      if ( notice_ == 0 || notice_ == VLog::null_ )
  292. {
  293.              notice_ = log->clone();
  294.          notice_->on();
  295. }
  296.      break;
  297.     }
  298.          case LOG_INFO:
  299.     {
  300.      if ( info_ == 0 || info_ == VLog::null_ )
  301. {
  302.              info_ = log->clone();
  303.          info_->on();
  304. }
  305.      break;
  306.     }
  307.          case LOG_DEBUG:
  308.     {
  309.      if ( debug_ == 0 || debug_ == VLog::null_ )
  310. {
  311.              debug_ = log->clone();
  312.          debug_->on();
  313. }
  314.      break;
  315.     }
  316.          case LOG_DEBUG_STACK:
  317.     {
  318.      if ( debugStack_ == 0 || debugStack_ == VLog::null_ )
  319. {
  320.              debugStack_ = log->clone();
  321.          debugStack_->on();
  322. }
  323.      break;
  324.     }
  325.          case LOG_DEBUG_OPER:
  326.     {
  327.      if ( debugOper_ == 0 || debugOper_ == VLog::null_ )
  328. {
  329.              debugOper_ = log->clone();
  330.          debugOper_->on();
  331. }
  332.      break;
  333.     }
  334.          case LOG_DEBUG_HB:
  335.     {
  336.      if ( debugHB_ == 0 || debugHB_ == VLog::null_ )
  337. {
  338.              debugHB_ = log->clone();
  339.          debugHB_->on();
  340. }
  341.      break;
  342.     }
  343.     default:
  344.     {
  345.      break;
  346.     }
  347. }
  348.     }
  349. }
  350. void               
  351. VLog::logOff(int priority)
  352. {
  353.     if ( priority == LOG_TRACE )
  354.     {
  355. trace_ = false;
  356. return;
  357.     }
  358.     if ( priority == LOG_VERBOSE )
  359.     {
  360. verbose_ = false;
  361. return;
  362.     }
  363.     LogMap::iterator it = log_.find(priority);
  364.     Sptr<PriorityLog> nullLog = 0;
  365.     Sptr<PriorityLog> log = ( it == log_.end() ? nullLog : (*it).second );
  366.     if ( log != 0 )
  367.     {
  368. switch ( priority )
  369. {
  370.          case LOG_EMERG:
  371.     {
  372.      if ( emergency_ != 0 )
  373. {
  374.          emergency_->off();
  375. }
  376.      break;
  377.     }
  378.          case LOG_ALERT:
  379.     {
  380.      if ( alert_ != 0 )
  381. {
  382.          alert_->off();
  383. }
  384.      break;
  385.     }
  386.          case LOG_CRIT:
  387.     {
  388.      if ( critical_ != 0 )
  389. {
  390.          critical_->off();
  391. }
  392.      break;
  393.          }
  394.          case LOG_ERR:
  395.     {
  396.      if ( error_ != 0 )
  397. {
  398.          error_->off();
  399. }
  400.      break;
  401.     }
  402.          case LOG_WARNING:
  403.     {
  404.      if ( warning_ != 0 )
  405. {
  406.          warning_->off();
  407. }
  408.      break;
  409.     }
  410.          case LOG_NOTICE:
  411.     {
  412.      if ( notice_ != 0 )
  413. {
  414.          notice_->off();
  415. }
  416.      break;
  417.     }
  418.          case LOG_INFO:
  419.     {
  420.      if ( info_ != 0 )
  421. {
  422.          info_->off();
  423. }
  424.      break;
  425.     }
  426.          case LOG_DEBUG:
  427.     {
  428.      if ( debug_ != 0 )
  429. {
  430.          debug_->off();
  431. }
  432.      break;
  433.     }
  434.          case LOG_DEBUG_STACK:
  435.     {
  436.      if ( debugStack_ != 0 )
  437. {
  438.          debugStack_->off();
  439. }
  440.      break;
  441.     }
  442.          case LOG_DEBUG_OPER:
  443.     {
  444.      if ( debugOper_ != 0 )
  445. {
  446.          debugOper_->off();
  447. }
  448.      break;
  449.     }
  450.          case LOG_DEBUG_HB:
  451.     {
  452.      if ( debugHB_ != 0 )
  453. {
  454.          debugHB_->off();
  455. }
  456.      break;
  457.     }
  458.     default:
  459.     {
  460.      break;
  461.     }
  462. }
  463.     }
  464. }
  465. PriorityLog &          
  466. VLog::logEmergency()
  467. {
  468.     assert( VLog::null_ != 0 );
  469.     
  470.     if ( emergency_ == 0 )
  471.     {
  472.      Sptr<PriorityLog> log = getLog(LOG_EMERG);
  473.         emergency_ = ( log != 0 ? Sptr<PriorityLog>(log->clone()) : VLog::null_ );
  474.     }
  475.     
  476.     return ( *emergency_ );
  477. }
  478. PriorityLog &          
  479. VLog::logAlert()
  480. {
  481.     assert( VLog::null_ != 0 );
  482.     if ( alert_ == 0 )
  483.     {
  484.      Sptr<PriorityLog> log = getLog(LOG_ALERT);
  485.         alert_ = ( log != 0 ? Sptr<PriorityLog>(log->clone()) : VLog::null_ );
  486.     }
  487.     
  488.     return ( *alert_ );
  489. }
  490. PriorityLog &          
  491. VLog::logCritical()
  492. {
  493.     assert( VLog::null_ != 0 );
  494.     if ( critical_ == 0 )
  495.     {
  496.      Sptr<PriorityLog> log = getLog(LOG_CRIT);
  497.         critical_ = ( log != 0 ? Sptr<PriorityLog>(log->clone()) : VLog::null_ );
  498.     }
  499.     
  500.     return ( *critical_ );
  501. }
  502. PriorityLog &          
  503. VLog::logError()
  504. {
  505.     assert( VLog::null_ != 0 );
  506.     if ( error_ == 0 )
  507.     {
  508.      Sptr<PriorityLog> log = getLog(LOG_ERR);
  509.         error_ = ( log != 0 ? Sptr<PriorityLog>(log->clone()) : VLog::null_ );
  510.     }
  511.     
  512.     return ( *error_ );
  513. }
  514. PriorityLog &          
  515. VLog::logWarning()
  516. {
  517.     assert( VLog::null_ != 0 );
  518.     if ( warning_ == 0 )
  519.     {
  520.      Sptr<PriorityLog> log = getLog(LOG_WARNING);
  521.         warning_ = ( log != 0 ? Sptr<PriorityLog>(log->clone()) : VLog::null_ );
  522.     }
  523.     
  524.     return ( *warning_ );
  525. }
  526. PriorityLog &          
  527. VLog::logNotice()
  528. {
  529.     assert( VLog::null_ != 0 );
  530.     if ( notice_ == 0 )
  531.     {
  532.      Sptr<PriorityLog> log = getLog(LOG_NOTICE);
  533.         notice_ = ( log != 0 ? Sptr<PriorityLog>(log->clone()) : VLog::null_ );
  534.     }
  535.     
  536.     return ( *notice_ );
  537. }
  538. PriorityLog &          
  539. VLog::logInfo()
  540. {
  541.     assert( VLog::null_ != 0 );
  542.     if ( info_ == 0 )
  543.     {
  544.      Sptr<PriorityLog> log = getLog(LOG_INFO);
  545.         info_ = ( log != 0 ? Sptr<PriorityLog>(log->clone()) : VLog::null_ );
  546.     }
  547.     
  548.     return ( *info_ );
  549. }
  550. PriorityLog &          
  551. VLog::logDebug()
  552. {
  553.     assert( VLog::null_ != 0 );
  554.     if ( debug_ == 0 )
  555.     {
  556.      Sptr<PriorityLog> log = getLog(LOG_DEBUG);
  557.         debug_ = ( log != 0 ? Sptr<PriorityLog>(log->clone()) : VLog::null_ );
  558.     }
  559.     
  560.     return ( *debug_ );
  561. }
  562. PriorityLog &          
  563. VLog::logDebugStack()
  564. {
  565.     assert( VLog::null_ != 0 );
  566.     if ( debugStack_ == 0 )
  567.     {
  568.      Sptr<PriorityLog> log = getLog(LOG_DEBUG_STACK);
  569.         debugStack_ = ( log != 0 ? Sptr<PriorityLog>(log->clone()) : VLog::null_ );
  570.     }
  571.     
  572.     return ( *debugStack_ );
  573. }
  574. PriorityLog &          
  575. VLog::logDebugOper()
  576. {
  577.     assert( VLog::null_ != 0 );
  578.     if ( debugOper_ == 0 )
  579.     {
  580.      Sptr<PriorityLog> log = getLog(LOG_DEBUG_OPER);
  581.         debugOper_ = ( log != 0 ? Sptr<PriorityLog>(log->clone()) : VLog::null_ );
  582.     }
  583.     
  584.     return ( *debugOper_ );
  585. }
  586. PriorityLog &          
  587. VLog::logDebugHB()
  588. {
  589.     assert( VLog::null_ != 0 );
  590.     if ( debugHB_ == 0 )
  591.     {
  592.      Sptr<PriorityLog> log = getLog(LOG_DEBUG_HB);
  593.         debugHB_ = ( log != 0 ? Sptr<PriorityLog>(log->clone()) : VLog::null_ );
  594.     }
  595.     
  596.     return ( *debugHB_ );
  597. }
  598. PriorityLog &     
  599. VLog::logTrace()
  600. {
  601.     assert( VLog::null_ != 0 );
  602.     return ( trace_ ? logDebugStack() : *VLog::null_ );
  603. }
  604. PriorityLog &     
  605. VLog::logVerbose()
  606. {
  607.     assert( VLog::null_ != 0 );
  608.     return ( verbose_ ? logDebugStack() : *VLog::null_ );
  609. }
  610. const char *        
  611. VLog::logName(int logLevel)
  612. {
  613.     switch ( logLevel )
  614.     {
  615.         case LOG_EMERG:         return "LOG_EMERG";
  616.         case LOG_ALERT:         return "LOG_ALERT";
  617.         case LOG_CRIT:          return "LOG_CRIT";
  618.         case LOG_ERR:           return "LOG_ERR";
  619.         case LOG_WARNING:       return "LOG_WARNING";
  620.         case LOG_NOTICE:        return "LOG_NOTICE";
  621.         case LOG_INFO:          return "LOG_INFO";
  622.         case LOG_DEBUG:         return "LOG_DEBUG";
  623.         case LOG_DEBUG_STACK:   return "LOG_DEBUG_STACK";
  624.         case LOG_DEBUG_OPER:    return "LOG_DEBUG_OPER";
  625.         case LOG_DEBUG_HB:      return "LOG_DEBUG_HB";
  626.         case LOG_TRACE:         return "LOG_TRACE";
  627.         case LOG_VERBOSE:       return "LOG_VERBOSE";
  628.     }    
  629.     return ( "LOG_UNKNOWN" );
  630. }
  631. int                 
  632. VLog::logValue(const char * name)
  633. {
  634.     string  log_emerg("log_emerg"),             emerg("emerg"),
  635.             log_alert("log_alert"),             alert("alert"),
  636.             log_crit("log_crit"),               crit("crit"),          
  637.             log_err("log_err"),                 err("err"),           
  638.             log_warning("log_warning"),         warning("warning"),       
  639.             log_notice("log_notice"),           notice("notice"),        
  640.             log_info("log_info"),               info("info"),          
  641.             log_debug("log_debug"),             debug("debug"),         
  642.             log_debug_stack("log_debug_stack"), debug_stack("debug_stack"),   
  643.             log_debug_oper("log_debug_oper"),   debug_oper("debug_oper"),    
  644.             log_debug_hb("log_debug_hb"),       debug_hb("debug_hb"),      
  645.             log_trace("log_trace"),             trace("trace"),         
  646.             log_verbose("log_verbose"),         verbose("verbose");    
  647.     string  logname(name);
  648.     size_t size = logname.size();
  649.     for ( size_t i = 0; i < size; i++ )
  650.     {
  651.         logname[i] = tolower(logname[i]);
  652.     }
  653.     if ( log_verbose == logname || verbose == logname )
  654.     {
  655.         return LOG_VERBOSE;
  656.     }
  657.     if ( log_trace == logname || trace == logname )
  658.     {
  659.         return LOG_TRACE;
  660.     }
  661.     if ( log_debug_hb == logname || debug_hb == logname )
  662.     {
  663.         return LOG_DEBUG_HB;
  664.     }
  665.     if ( log_debug_oper == logname || debug_oper == logname )
  666.     {
  667.         return LOG_DEBUG_OPER;
  668.     }
  669.     if ( log_debug_stack == logname || debug_stack == logname )
  670.     {
  671.         return LOG_DEBUG_STACK;
  672.     }
  673.     if ( log_debug == logname || debug == logname )
  674.     {
  675.         return LOG_DEBUG;
  676.     }
  677.     if ( log_info == logname || info == logname )
  678.     {
  679.         return LOG_INFO;
  680.     }
  681.     if ( log_notice == logname || notice == logname )
  682.     {
  683.         return LOG_NOTICE;
  684.     }
  685.     if ( log_warning == logname || warning == logname )
  686.     {
  687.         return LOG_WARNING;
  688.     }
  689.     if ( log_err == logname || err == logname )
  690.     {
  691.         return LOG_ERR;
  692.     }
  693.     if ( log_crit == logname || crit == logname )
  694.     {
  695.         return LOG_CRIT;
  696.     }
  697.     if ( log_alert == logname || alert == logname )
  698.     {
  699.         return LOG_ALERT;
  700.     }
  701.     if ( log_emerg == logname || emerg == logname )
  702.     {
  703.         return LOG_EMERG;
  704.     }
  705.     return ( LOG_ERR );
  706. }