/* * capset_set_fcp_forwardall - sets the fcp-controlled call forward all feature * */ static void capset_set_fcp_forwardall (cc_boolean state) { CONFIG_DEBUG(DEB_F_PREFIX"FCP Setting CALLFWD Capability to [%d]", DEB_F_PREFIX_ARGS(JNI, "capset_set_fcp_forwardall"), (unsigned int)state); capability_idleset[CCAPI_CALL_CAP_CALLFWD] = state; capability_set[OFFHOOK][CCAPI_CALL_CAP_CALLFWD] = state; }
/* * Function: config_get_string() * * Description: Get any arbitrary config entry as a string * * Parameters: id - The id of the config string to get * buffer - Empty buffer where string will be copied * buffer_len - length of the buffer where string will be copied * * Returns: None */ void config_get_string (int id, char *buffer, int buffer_len) { const var_t *entry; char *buf_start; /* * Set the result to be empty in case we can't find anything */ buffer[0] = 0; if ((id >= 0) && (id < CFGID_PROTOCOL_MAX)) { entry = &prot_cfg_table[id]; if (entry->length > buffer_len) { CONFIG_ERROR(CFG_F_PREFIX"insufficient buffer: %d\n", "config_get_string", id); } else { buf_start = buffer; entry->print_func(entry, buffer, buffer_len); CONFIG_DEBUG(DEB_F_PREFIX"CFGID %d: get str: %s = %s\n", DEB_F_PREFIX_ARGS(CONFIG_API, "config_get_string"), id, entry->name, buf_start); } } else { CONFIG_ERROR(CFG_F_PREFIX"Invalid ID: %d\n", "config_get_string", id); } }
/* * capset_set_fcp_redial - sets the fcp-controlled redial feature * */ static void capset_set_fcp_redial (cc_boolean state) { CONFIG_DEBUG(DEB_F_PREFIX"FCP Setting REDIAL capability to [%d]", DEB_F_PREFIX_ARGS(JNI, "capset_set_fcp_redial"), (unsigned int)state); capability_idleset[CCAPI_CALL_CAP_REDIAL] = state; capability_set[OFFHOOK][CCAPI_CALL_CAP_REDIAL] = state; capability_set[ONHOOK][CCAPI_CALL_CAP_REDIAL] = state; }
/* * Some logical upper limit to avoid long print out in case * of large length value */ void print_config_value (int id, char *get_set, const char *entry_name, void *buffer, int length) { long long_val = 0; int int_val = 0; short short_val = 0; char char_val = 0; char str[MAX_CONFIG_VAL_PRINT_LEN]; char *in_ptr; char *str_ptr; if (length == sizeof(char)) { char_val = *(char *) buffer; long_val = (long) char_val; CONFIG_DEBUG(DEB_F_PREFIX"CFGID %d: %s: %s = %ld\n", DEB_F_PREFIX_ARGS(CONFIG_API, "print_config_value"), id, get_set, entry_name, long_val); } else if (length == sizeof(short)) { short_val = *(short *) buffer; long_val = (long) short_val; CONFIG_DEBUG(DEB_F_PREFIX"CFGID %d: %s: %s = %ld\n", DEB_F_PREFIX_ARGS(CONFIG_API, "print_config_value"), id, get_set, entry_name, long_val); } else if (length == sizeof(int)) { int_val = *(int *) buffer; long_val = (long) int_val; CONFIG_DEBUG(DEB_F_PREFIX"CFGID %d: %s: %s = %ld\n", DEB_F_PREFIX_ARGS(CONFIG_API, "print_config_value"), id, get_set, entry_name, long_val); } else if (length == sizeof(long)) { long_val = *(long *) buffer; CONFIG_DEBUG(DEB_F_PREFIX"CFGID %d: %s: %s = %ld\n", DEB_F_PREFIX_ARGS(CONFIG_API, "print_config_value"), id, get_set, entry_name, long_val); } else if (length < MAX_CONFIG_VAL_PRINT_LEN / 2) { in_ptr = (char *) buffer; str_ptr = &str[0]; while (length--) { sprintf(str_ptr++, "%02x", *in_ptr++); str_ptr++; } *str_ptr = '\0'; CONFIG_DEBUG(DEB_F_PREFIX"CFGID %d: %s: %s = %s\n", DEB_F_PREFIX_ARGS(CONFIG_API, "print_config_value"), id, get_set, entry_name, str); } else { CONFIG_ERROR(CFG_F_PREFIX"cfg_id = %d length too long -> %d\n", "print_config_value", id, length); } }
/* * Function: config_set_string() * * Parameters: id - The id of the config string to set * buffer - The new value for the string * * Description: Set any arbitrary config entry as a string * * Returns: None */ void config_set_string (int id, char *buffer) { const var_t *entry; if ((id >= 0) && (id < CFGID_PROTOCOL_MAX)) { entry = &prot_cfg_table[id]; if (entry->parse_func(entry, buffer)) { /* Parse function returned an error */ CONFIG_ERROR(CFG_F_PREFIX"Parse function failed. ID: %d %s:%s\n", "config_set_string", id, entry->name, buffer); } else { CONFIG_DEBUG(DEB_F_PREFIX"CFGID %d: %s set str to %s\n", DEB_F_PREFIX_ARGS(CONFIG_API, "config_set_string"), id, entry->name, buffer); } } else { CONFIG_ERROR(CFG_F_PREFIX"Invalid ID: %d\n", "config_set_string", id); } }
/* * capset_init - initialize the internal capability data structures to defaults * */ static void capset_init () { // initialize the 4 tables related to capability set to false memset(capability_idleset, 0, sizeof(capability_idleset)); memset(capability_set, 0, sizeof(capability_set)); // ---------------------------------------------------------------------- // FCP based capabilities // ---------------------------------------------------------------------- CONFIG_DEBUG(DEB_F_PREFIX"FCP Initializing Capabilities to default", DEB_F_PREFIX_ARGS(JNI, "capset_init")); // ---------------------------------------------------------------------- // Non-FCP-based Capabilities // ---------------------------------------------------------------------- // Now, set all the non-FCP based capabilities to appropriate default settings // (some of which may be enabled by default) capability_idleset[CCAPI_CALL_CAP_NEWCALL] = TRUE; // call-state based settings // offhook capability_set[OFFHOOK][CCAPI_CALL_CAP_ENDCALL] = TRUE; // onhook capability_set[ONHOOK][CCAPI_CALL_CAP_NEWCALL] = TRUE; // ringout capability_set[RINGOUT][CCAPI_CALL_CAP_ENDCALL] = TRUE; // ringing capability_set[RINGIN][CCAPI_CALL_CAP_ANSWER] = TRUE; // proceed capability_set[PROCEED][CCAPI_CALL_CAP_ENDCALL] = TRUE; // connected capability_set[CONNECTED][CCAPI_CALL_CAP_ENDCALL] = TRUE; capability_set[CONNECTED][CCAPI_CALL_CAP_HOLD] = TRUE; capability_set[CONNECTED][CCAPI_CALL_CAP_TRANSFER] = TRUE; capability_set[CONNECTED][CCAPI_CALL_CAP_CONFERENCE] = TRUE; capability_set[CONNECTED][CCAPI_CALL_CAP_SELECT] = TRUE; // hold capability_set[HOLD][CCAPI_CALL_CAP_RESUME] = TRUE; capability_set[REMHOLD][CCAPI_CALL_CAP_RESUME] = TRUE; // busy capability_set[BUSY][CCAPI_CALL_CAP_ENDCALL] = TRUE; // reorder capability_set[REORDER][CCAPI_CALL_CAP_ENDCALL] = TRUE; // dialing capability_set[DIALING][CCAPI_CALL_CAP_ENDCALL] = TRUE; capability_set[DIALING][CCAPI_CALL_CAP_DIAL] = TRUE; capability_set[DIALING][CCAPI_CALL_CAP_SENDDIGIT] = TRUE; capability_set[DIALING][CCAPI_CALL_CAP_BACKSPACE] = TRUE; // holdrevert capability_set[HOLDREVERT][CCAPI_CALL_CAP_ANSWER] = TRUE; // preservation capability_set[PRESERVATION][CCAPI_CALL_CAP_ENDCALL] = TRUE; // waiting for digits capability_set[WAITINGFORDIGITS][CCAPI_CALL_CAP_SENDDIGIT] = TRUE; capability_set[WAITINGFORDIGITS][CCAPI_CALL_CAP_BACKSPACE] = TRUE; }
//-------------------------------------- // ParseStrainFile //-------------------------------------- bool StrainConfigFile::Parse( const std::string & sBuf ) { bool *vInitializationCheck; vInitializationCheck = new bool[ StrainOpt::eNumKeywords ]; for ( Int i = 0; i < StrainOpt::eNumKeywords; i ++ ) vInitializationCheck[i] = false; std::vector< std::vector< std::string> > vsTokens; GeneralLib::Tokenize( vsTokens, sBuf, " \t\n"); for(Size_Type i = 0; i < vsTokens.size(); i ++) { Size_Type iFirstToken; if ( vsTokens[i].size() == 0 ) { iFirstToken = StrainOpt::eComment; } else if ( vsTokens[i][0].find_first_of( StrainOpt::Keywords[ StrainOpt::eComment ] ) == 0 ) // if first token is comment { iFirstToken = StrainOpt::eComment; } else { // Identify the keyword in the beginning of the line (i.e., vertex? texture? for( iFirstToken = 0; iFirstToken < StrainOpt::eNumKeywords; iFirstToken ++) { if( strcmp( StrainOpt::Keywords[iFirstToken], vsTokens[i][0].c_str()) == 0 ) break; } CONFIG_DEBUG( std::cout << i + 1 << " " << StrainOpt::Keywords[iFirstToken] << " " << vsTokens[i][0].c_str() << " Token " << iFirstToken << endl ); } switch( iFirstToken ) // look at first token of each line { case StrainOpt::eComment: break; case StrainOpt::eStrainSearchType: SearchType = StrainOpt::ProcessSearchType( vsTokens[i], i ); break; case StrainOpt::eStrainType: StrainType = StrainOpt::ProcessStrainType( vsTokens[i], i ); break; case StrainOpt::eOptimizationMethod: OptimizationMethod = StrainOpt::ProcessOptMethod( vsTokens[i], i ); break; case StrainOpt::eStrainStepSize: StrainSteps = StrainOpt::ParseMatrix( vsTokens, i ); i += 2; // need to skip the matrix break; case StrainOpt::eMaxStrainStep: nMaxSteps = InitFileIO::ExtractInt( vsTokens[i], i ); break; case StrainOpt::eConvergenceMethod: boost::tie( ConvergenceMethod, fConvergenceThresh ) = StrainOpt::ProcessConvergenceMethod( vsTokens[i], i ); break; default: { cerr << "[StrainConfig] Error: syntax not recognized: Line " << i << endl; exit(0); return false; } } vInitializationCheck[ iFirstToken ] = true; } bool bMissingTokens = false; for ( Int i = 0; i < StrainOpt::eNumKeywords; i ++ ) if( ! vInitializationCheck[ i ] ) { cerr << "[StrainConfig] Missing variable: \'" << StrainOpt::Keywords[i] << "\' not optional" << endl; bMissingTokens = true; } delete [] vInitializationCheck; if ( bMissingTokens ) RUNTIME_ASSERT(0, "[StrainConfig] Failed to parse Strain config file\n" ); return true; }