cnfdemoprm.cpp

Conferencing code using Dialogic hardware

  }  // for each keyword  

  if ( inx == num_dti_keywords){
       LogUndefinedParameter(token);
  }
 return brc;
}  //	End of ReadDtiValues()

//*****************************************************************************
// Purpose	: 
//    Read section [Board Parameters] from configuration file
// Parameters:	
//    [in] first token
// Returns:	
//    true = success
//    false = unexpected eof
//*****************************************************************************
bool CnfDemoPrm::ReadBoardValues(const char *token){
  typedef enum {
    ACTIVE_TALKER,
    AT_INTERVAL,
    DTMF_CLAMPING,
    PRIVATE_BRD_LOG
  }BOARD_KEYWORD_CODES;
  static const char *brd_keywords[]={
   "ActiveTalker",
   "ATInterval",
   "DTMFClamping",
   "PrivateLog" 
  };
  static const size_t num_brd_keywords = sizeof(brd_keywords) / sizeof(const char *);
  char value[MAXTOKEN];

  // skip any '='
  *value = '=';
  while( *value == '=') {
         if (!GetNextToken(value, sizeof(value))){
             return false;
         }
  } // while

  bool brc = true;
  size_t inx;
  for ( inx = 0; inx < num_brd_keywords; inx++){
     if (COMPARE_EQUAL == str_compare(brd_keywords[inx],token ) ) {
         switch(inx){
            case ACTIVE_TALKER:   //   "Active talker",
                 if ( ! GetYesNo(value, &m_BrdParams.m_brd_active_talker) ){
                      brc = false;
                      LogInvalidValue(token, value);
                 }
                 break;

            case AT_INTERVAL:     //   "Notification interval",
                 if ( ! GetNumber(value, &m_BrdParams.m_brd_at_interval) ){
                     brc = false;
                     LogInvalidValue(token, value);
                 }
                 break;

            case DTMF_CLAMPING:    //   "DTMFClamping",
                 if ( ! GetYesNo(value, &m_BrdParams.m_brd_dtmf_clamping) ){
                      brc = false;
                      LogInvalidValue(token, value);
                 }
                 break;

            case PRIVATE_BRD_LOG:    //   "PrivateLog",
                 if ( ! str_getunsignednumber(value,(unsigned int *)&m_BrdParams.m_log_level ) ) {
                        m_BrdParams.m_log_level = log_get_msgtype_value(value);
                 }
 
                 if ( m_BrdParams.m_log_level >= MSG_TYPE_MAX ){
                      LogInvalidValue(token, value);
                      brc = false;
                 } 
                 break;

            default:
                 LogUnmatchedParameter(token, __LINE__);
                 brc = false;
                 break;
         } // switch inx (keyword)
         break;
     } // if keyword match
  }  // for each keyword  

  if ( inx == num_brd_keywords){
       LogUndefinedParameter(token);
  }
  return brc;
}  //	End of ReadBoardValues()

//*****************************************************************************
// Purpose	: 
//    Store current conference using m_cnf_params and initialize m_cnf_params
// Parameters:	
//    None
// Returns:	
//    true = success
//    false = was not stored (incomplete)
//*****************************************************************************
bool CnfDemoPrm::StoreConference(){
bool brc = false;
   if (m_cnf_params.cnf_id != -1) {
       // Conference is defined
       if (   ( 0 == m_cnf_params.pass_code)
           || ( 0 == *m_cnf_params.pass_code)
           || ( ! str_isnumber(m_cnf_params.pass_code ) )  ){
           LOG( LOG_ERR2, GetFileName(), 
                "Line %d: Missing or invalid pass code for conference %d",
                 GetCurrentLineNumber(), m_cnf_params.cnf_id );
       }else {
           if (m_ConferenceContainer.find(m_cnf_params.pass_code) ){
               // Duplicate
               LOG( LOG_ERR2, GetFileName(),
                    "Line %d: Duplicate pass code for conference %d, pass_code = %s",
                    GetCurrentLineNumber(), m_cnf_params.cnf_id, m_cnf_params.pass_code );
           } else {
               // Store & clean
               PCnfParams pCnfParams = new CnfParams(m_cnf_params);
               m_ConferenceContainer.push_back(pCnfParams);
               brc = true;
           }
           m_cnf_params.Init();
       }
   } // cnf_id != -1
 return brc;
}  //	End of StoreConference()


//*****************************************************************************
// Purpose	: 
//    Store current ipt using m_ipt_params and initialize m_ipt_params
// Parameters:	
//    None
// Returns:	
//    true = success
//    false = was not stored (incomplete)
//*****************************************************************************
bool CnfDemoPrm::StoreIpt(){
bool brc = false;
   if ( m_ipt_params.ipt_id != -1) {
        // Store & clean
           PIptParams pIptParams = new CIptParams(m_ipt_params);
           m_IptContainer.push_back(pIptParams);
           m_ipt_params.Init();
           brc = true;
   } // ipt_id != -1
 return brc;
}  //	End of StoreIpt()


//*****************************************************************************
// Purpose	: 
//    Read all sections [Conference xxx] from configuration file
// Parameters:	
//    [in] first token
// Returns:	
//    true = success
//    false = unexpected eof
//*****************************************************************************
bool CnfDemoPrm::ReadConference(const char *token){
  typedef enum {
    PASS_CODE,
    TONE_CLAMPING,
    DETECT_DIGITS,
    TMO_KEYWORD,
    VOICE_KEYWORD,
    BEEP_NOTIFY_KEYWORD,
    CNF_PRIVATE_LOG,
  }CNF_KEYWORD_CODES;

  static const char *cnf_keywords[]={
   "PassCode",
   "DTMFClamping",
   "DetectDigits",
   "Tmo",
   "VoiceParty",
   "BeepNotify",
   "PrivateLog"
  };
  static const size_t num_cnf_keywords = sizeof(cnf_keywords) / sizeof(const char *);

  if (m_cnf_params.cnf_id != GetSectionId() ){
       // Conference changed, store current value
       StoreConference();
  } // if section is not same

  m_cnf_params.cnf_id = GetSectionId();
  char value[MAXTOKEN];

  // skip any '='
  *value = '=';
  while( *value == '=') {
         if (!GetNextToken(value, sizeof(value))){
             return false;
         }
  } // while

  bool brc = true;
  size_t inx;  
  for ( inx = 0; inx < num_cnf_keywords; inx++){
     if (COMPARE_EQUAL == str_compare(cnf_keywords[inx],token ) ) {
         switch(inx){
            case PASS_CODE:    //   "PassCode",
                 str_storestring(&m_cnf_params.pass_code,value);
                 break;

            case TONE_CLAMPING:    //   "DtmfClamping",
                 if (! GetYesNo(value, &m_cnf_params.dtmf_clamping) ){
                     LogInvalidValue(token, value);
                     brc = false;
                 }
                 break;

            case DETECT_DIGITS:    //   "DetectDigits",
                 if (! GetYesNo(value, &m_cnf_params.detect_digits) ){
                     LogInvalidValue(token, value);
                     brc = false;
                 }
                 break;

            case TMO_KEYWORD:        //   "Tmo",
                 if (! str_getnumber(value, &m_cnf_params.tmo) ) {
                     LogInvalidValue(token, value);
                     brc = false;
                 }
                 break;

            case VOICE_KEYWORD:      //   "VoiceParty",
                 if (! GetYesNo(value, &m_cnf_params.voice_party) ){
                     LogInvalidValue(token, value);
                     brc = false;
                 }
                 break;

            case BEEP_NOTIFY_KEYWORD:
# ifdef _FR2619
                 if (! GetYesNo(value, &m_cnf_params.beep_notify) ){
                     LogInvalidValue(token, value);
                     brc = false;
                 }
# else 
                 LOG( LOG_WARNING, GetFileName(), 
                      "Line %d: Not supported parameter <%s> in this build (%s)",
                      GetCurrentLineNumber(),token, RELNAME );
# endif // _FR2619
                 break;

            case CNF_PRIVATE_LOG:    //   "PrivateLog",
                 if ( ! str_getunsignednumber(value, (unsigned int *)&m_cnf_params.private_log) ) {
                        m_cnf_params.private_log = log_get_msgtype_value(value);
                 }
 
                 if ( m_cnf_params.private_log >= MSG_TYPE_MAX ){
                      LogInvalidValue(token, value);
                      brc = false;
                 } 
                 break;

            default:
                 LogUnmatchedParameter(token, __LINE__);
                 brc = false;
                 break;
         } // switch inx (keyword)
         break;
     } // if compare keyword
  } // for keywords

  if ( inx == num_cnf_keywords){
       LogUndefinedParameter(token);
  }

 return brc;
}  //	End of ReadConference()

//*****************************************************************************
// Purpose	: 
//    Log 'invalid value' message: ( this is not appropriate <value> for <token> )
// Parameters:	
//    [in] token 
//    [in] value
// Returns:	
//    none
//*****************************************************************************
void CnfDemoPrm::LogInvalidValue(const char *token, const char *value){
  LOG( LOG_ERR2, GetFileName(), 
       "Line %d: (cfg file error) Invalid value <%s> for parameter %s",
       GetCurrentLineNumber(), value, token );
  return;
} // End of LogInvalidValue()

//*****************************************************************************
// Purpose	: 
//    Log "This token exist, but there is no case to handle (app error)"
// Parameters:	
//    [in] token 
//    [in] line (source line number in this file)
// Returns:	
//    none
//*****************************************************************************
void CnfDemoPrm::LogUnmatchedParameter(const char *token, int line){
     LOG( LOG_ERR2, CNF_MODULE_NAME, 
          "line %d(cfg file), (app error) token <%s> is defined, but there is no case to handle it - function %s line %d, file %s",
          GetCurrentLineNumber(), token,  line,  __FILE__);
 return ;
} // End of LogUnmatchedParameter()
//*****************************************************************************
// Purpose	: 
//    Log "This token is not recognized as parameter name"
// Parameters:	
//    [in] token 
// Returns:	
//    none
//*****************************************************************************
void CnfDemoPrm::LogUndefinedParameter(const char *token){
   LOG( LOG_ERR2, GetFileName(),
        "Line %d: Token '%s' is not recognized as parameter name",
        GetCurrentLineNumber(), token);
 return;
}  // End of LogUndefinedParameter()

//*****************************************************************************
// Purpose	: 
//    Dump all parameters
// Parameters:	
//    None
// Returns:	
//    none
//*****************************************************************************
void CnfDemoPrm::Dump(){
    LOG(LOG_DBG, CNF_MODULE_NAME, "=== Global Parameters ===");
    LOG(LOG_DBG, CNF_MODULE_NAME, "  section [Common]");
    m_CommonParams.Dump(GetLog());

    LOG(LOG_DBG, CNF_MODULE_NAME, "  section [Board parameters]");
    m_BrdParams.Dump(GetLog());

    LOG(LOG_DBG, CNF_MODULE_NAME, "  section [Dti]");
    m_DtiParams.Dump(GetLog());

    {
        LOG(LOG_DBG, CNF_MODULE_NAME, "  sections [Ipt]");
        list<PIptParams>::iterator pos;
        for ( pos = m_IptContainer.begin(); pos != m_IptContainer.end(); ++pos) { 
             (*pos)->Dump(GetLog());
        } 
    }

    {
        LOG(LOG_DBG, CNF_MODULE_NAME, "  sections [Conference nnn]");
        list<PCnfParams>::iterator pos;
        for ( pos = m_ConferenceContainer.begin(); pos != m_ConferenceContainer.end(); ++pos) {
             (*pos)->Dump(GetLog());
        } 
    }


 return;
}  //	End of Dump()