cnfdemoprm.cpp

Conferencing code using Dialogic hardware

/**********@@@SOFT@@@WARE@@@COPY@@@RIGHT@@@**********************************
* DIALOGIC CONFIDENTIAL
*
* Copyright (C) 2006-2007 Dialogic Corporation. All Rights Reserved.
* The source code contained or described herein and all documents related
* to the source code ("Material") are owned by Dialogic Corporation or its
* suppliers or licensors. Title to the Material remains with Dialogic Corporation
* or its suppliers and licensors. The Material contains trade secrets and
* proprietary and confidential information of Dialogic or its suppliers and
* licensors. The Material is protected by worldwide copyright and trade secret
* laws and treaty provisions. No part of the Material may be used, copied,
* reproduced, modified, published, uploaded, posted, transmitted, distributed,
* or disclosed in any way without Dialogic's prior express written permission.
*
* No license under any patent, copyright, trade secret or other intellectual
* property right is granted to or conferred upon you by disclosure or delivery
* of the Materials, either expressly, by implication, inducement, estoppel or
* otherwise. Any license under such intellectual property rights must be
* express and approved by Dialogic in writing.
*
***********************************@@@SOFT@@@WARE@@@COPY@@@RIGHT@@@**********/
//***********************************************************************
//***********************************************************************
// CnfDemoPrm.cpp: implementation of the CnfDemoPrm class.
//
//////////////////////////////////////////////////////////////////////

#define PRINT_VERSION
#include "utils.h"
#include "dialogic.h"
#include "product_versions.h"
#include "CnfDemoPrm.h"


static const char * CNF_MODULE_NAME = "CnfDemoPrm";


static NAME_TABLE mode_table_stru[] = {
    {"MODE_1PCC",     MEDIA_OPERATIONAL_MODE_1PCC     },
    {"MODE_3PCC",     MEDIA_OPERATIONAL_MODE_3PCC     },
    { 0,0}
};
static CNameTable mode_table(mode_table_stru);
//////////////////////////////////////////////////////////////////////
// Global functions
//////////////////////////////////////////////////////////////////////
//*****************************************************************************
// Purpose	: 
//    Get message name from given type
// Parameters:	
//    [in] type
// Returns:	
//    name ("????" indicates unknown)
//*****************************************************************************
const char *get_call_control_mode_name(enumIPCCLIBMediaMode mode){
 return mode_table.find_name(mode);
}  //	End of log_get_msgtype_name()

//*****************************************************************************
// Purpose	: 
//    Get message type from given name
// Parameters:	
//    [in] char *name
// Returns:	
//    MSG_TYPE  ( returns MSG_TYPE_MAX in case of unresolved value )
//*****************************************************************************
enumIPCCLIBMediaMode get_call_control_value(const char *name){
  return (enumIPCCLIBMediaMode) mode_table.find_code(name);
}  //	End of log_get_msgtype_value()


//*****************************************************************************
// Purpose	: 
//    Get reserve device type from given name
// Parameters:	
//    [in] char *name
// Returns:	
//    MSG_TYPE  ( returns MSG_TYPE_MAX in case of unresolved value )
//*****************************************************************************
static NAME_TABLE  reserve_table_stru [] = {
    {"No",     RESERVE_RESOURCE_NONE },
    {"Yes",    RESERVE_RESOURCE      },
    {"Ex",     RESERVE_RESOURCE_EX   },
    { 0,0}
};

static CNameTable reserve_table(reserve_table_stru);

RESERVE_RESOURCE_TYPE get_reserve_resource_value(const char *name){
  return  (RESERVE_RESOURCE_TYPE) reserve_table.find_code(name);
}  //	End of get_reserve_resource_value()


//*****************************************************************************
// Purpose	: 
//    Get reserve device name from given type
// Parameters:	
//    [in] type
// Returns:	
//    name ("????" indicates unknown)
//*****************************************************************************
const char *get_reserve_resource_name(RESERVE_RESOURCE_TYPE mode){
    return reserve_table.find_name(mode); 
}  //	End of get_reserve_resource_name()


//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
//*****************************************************************************
// Purpose	: 
//    Constructor
// Parameters:	
//    none
// Returns:	
//    none
//*****************************************************************************
CnfDemoPrm::CnfDemoPrm(CGenLog *pLog) 
           : ConfigFile(pLog){

 return;
}   //	End of constructor()

//*****************************************************************************
// Purpose	: 
//    Destructor
// Parameters:	
//    none
// Returns:	
//    none
//*****************************************************************************
CnfDemoPrm::~CnfDemoPrm(){


    { // delete conference parameters
        list<PCnfParams>::iterator pos;
        for ( pos = m_ConferenceContainer.begin(); pos != m_ConferenceContainer.end(); ++pos) {
              delete (*pos);
        } 
    }

    { // delete ipt params
        list<PIptParams>::iterator pos;
        for ( pos = m_IptContainer.begin(); pos != m_IptContainer.end(); ++pos) {
              delete (*pos);
        } 
    }

 return;
}  //	End of destructor()


//*****************************************************************************
// Purpose	: 
//    Read configuration file and load parameters
// Parameters:	
//    [in] file name
// Returns:	
//    true = success
//*****************************************************************************
bool CnfDemoPrm::ReadConfigFile(const char *filename){
char token[MAXTOKEN];
bool brc = true;

   CFG_ERROR err = LoadConfigFile(filename);

   LOG(err == CFG_OK?LOG_API:LOG_ERR2, CNF_MODULE_NAME,
              "[%d] %s = Open(%s)", err, cfg_get_errormsg(err),filename); 

       if ( err != CFG_OK ) {
            return false;    
       }

       while (GetNextToken(token,sizeof(token) ) ){
           if (IsSection("common") ){
               if (! ReadCommonValues(token) ){
                     brc = false;
               }
           } else if (IsSection("ipt")) { 
               if (GetSectionId() == -1) {
                   LOG(LOG_ERR2, CNF_MODULE_NAME,
                       "%s(%d): Section IPT requires unique id",
                       filename, GetCurrentLineNumber());
               }
               if (! ReadIptValues(token) ){
                     brc = false;
               }
           } else if (IsSection("dti")) { 
               if (! ReadDtiValues(token) ){
                     brc = false;
               }
           } else if (IsSection("BoardParameters")) { // no spaces in the name here!!!
               if (! ReadBoardValues(token) ){
                     brc = false;
               }
           } else if (IsSection("Conference") ){
               if (GetSectionId() == -1) {
                   LOG(LOG_ERR2, CNF_MODULE_NAME,
                           "%s(%d): Section IPT requires unique id",
                            filename, GetCurrentLineNumber());
               }
               // Read conference
               if (! ReadConference(token) ){
                     brc = false;
               }
           }
       } // while GetNextToken

       // Store last conference
       if ( brc && m_is_correct) {
            StoreConference(); 
            StoreIpt();
       }

// More validations

	   if (m_CommonParams.m_call_control_mode == MEDIA_OPERATIONAL_MODE_3PCC){
		   if (GetRequestedNumberOfIptDevices("H323") > 0) {
               LOG(LOG_ERR2, CNF_MODULE_NAME,
                  "H323 does not support 3PCC mode.",
                   filename, GetCurrentLineNumber());
		   }
	   }


       LOG(LOG_DBG, CNF_MODULE_NAME, "Done reading configuration file (%s)", filename); 
   return brc && m_is_correct;
}  //	End of ReadConfigFile()

//*****************************************************************************
// Purpose	: 
//    Read section [Common] from configuration file
// Parameters:	
//    [in] first token
// Returns:	
//    true = success
//    false = unexpected eof
//*****************************************************************************
bool CnfDemoPrm::ReadCommonValues(const char *token){
  typedef enum {
    KEYWORD_MAX_LOG_SIZE,
    KEYWORD_PRINT_LEVEL,
    KEYWORD_LOG_FILE_NAME,
    KEYWORD_WELCOME_FILE_NAME,
    KEYWORD_BAD_PASSCODE_FILE_NAME,
    KEYWORD_CALL_LATER_FILE_NAME,
    KEYWORD_GOOD_BYE_FILE_NAME,
	KEYWORD_CALL_CONTROL_MODE,
	KEYWORD_RESERVE_RESOURCE
  } COMMON_KEYWORD_CODES;
  static const char *common_keywords[] = {
   "MaxLogSize",
   "PrintLevel",
   "LogFileName",
   "WelcomeFileName",
   "BadPasscodeFileName",
   "CallLaterFileName",
   "GoodByeFileName",
   "CallControlMode",
   "ReserveResource",
  };  //	End of common_keywords

  const size_t num_common_keywords = sizeof(common_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_common_keywords; inx++){
     if (COMPARE_EQUAL == str_compare(common_keywords[inx],token ) ) {
         switch(inx){
            case KEYWORD_MAX_LOG_SIZE:    //   "MaxLogSize",
                 brc = GetUNumber(value, &m_CommonParams.m_maxlogsize);
                 if (!brc){
                     LogInvalidValue(token, value);
                 }
                 break;

            case KEYWORD_PRINT_LEVEL:    //   "MaxLogLeve",
                 if ( ! str_getunsignednumber(value, (unsigned int *)&m_CommonParams.m_log_level ) ) {
                        m_CommonParams.m_log_level = log_get_msgtype_value(value);
                 }

                 if ( m_CommonParams.m_log_level >= MSG_TYPE_MAX ){
                     LogInvalidValue(token,value);
                     brc = false;
                 } 
                 break;

			case KEYWORD_CALL_CONTROL_MODE:	
                 if ( ! str_getunsignednumber(value, (unsigned int *)&m_CommonParams.m_call_control_mode ) ) {
                        m_CommonParams.m_call_control_mode = get_call_control_value(value);
                 }
				 switch(m_CommonParams.m_call_control_mode){
					case MEDIA_OPERATIONAL_MODE_1PCC:
					case MEDIA_OPERATIONAL_MODE_3PCC:
						 break;
					default:
                         LogInvalidValue(token,value);
                         brc = false;
						 break;
				 } // switch
				 break;

			case KEYWORD_RESERVE_RESOURCE:	
                 if ( ! str_getunsignednumber(value, (unsigned int *)&m_CommonParams.m_reserve_resource_type ) ) {
                        m_CommonParams.m_reserve_resource_type = get_reserve_resource_value(value);
                 }

                 if ( m_CommonParams.m_reserve_resource_type > RESERVE_RESOURCE_EX ){
                     LogInvalidValue(token,value);
                     brc = false;
                 } 

				 break;

            case KEYWORD_LOG_FILE_NAME:    //   "LogFileName",
                 str_storestring(&m_CommonParams.m_log_file, value);
                 break;

            case KEYWORD_WELCOME_FILE_NAME:    //   "WelcomeFileName",
                 str_storestring(&m_CommonParams.m_welcome_file, value);
                 break;

            case KEYWORD_BAD_PASSCODE_FILE_NAME:    //   "BadPasscodeFileName",
                 str_storestring(&m_CommonParams.m_bad_passcode_file, value);
                 break;

            case KEYWORD_CALL_LATER_FILE_NAME:    //   "CallLaterFileName",
                 str_storestring(&m_CommonParams.m_callater_file, value);
                 break;

            case KEYWORD_GOOD_BYE_FILE_NAME:    //   "GoodByeFileName",
                 str_storestring(&m_CommonParams.m_goodbye_file, value);
                 break;

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

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

 return brc;
}  //	End of ReadCommonValues()

//*****************************************************************************
// For   ReadIptValues():
// Tables with possible parameter values
//*****************************************************************************

static NAME_TABLE digit_types[] = {