/**
* Ask the platform to sync with versions got from call control
* or outside entity. As part of the sync, platform downloads
* the files if required.
*
* @param cfg_ver - version stamp for config file
* @param dp_ver - version stamp for the dialplan file
* @param softkey_ver - version stamp for the softkey file.
*
* @return none
*/
void
platform_sync_cfg_vers (char *cfg_ver, char *dp_ver, char *softkey_ver)
{
static const char fname[] = "platform_sync_cfg_vers";
char empty_string[] = "";
feature_update_t msg;
if (cfg_ver == NULL) {
cfg_ver = empty_string;
}
if (dp_ver == NULL) {
dp_ver = empty_string;
}
if (softkey_ver == NULL) {
softkey_ver = empty_string;
}
CCAPP_DEBUG(DEB_F_PREFIX"cfg_ver=%s dp_ver=%s sk_ver=%s\n", DEB_F_PREFIX_ARGS(PLAT_API, fname),
cfg_ver, dp_ver, softkey_ver);
msg.sessionType = SESSIONTYPE_CALLCONTROL;
msg.featureID = DEVICE_SYNC_CONFIG_VERSION;
msg.update.ccFeatUpd.data.cfg_ver_data.cfg_ver = strlib_malloc(cfg_ver, strlen(cfg_ver));
msg.update.ccFeatUpd.data.cfg_ver_data.dp_ver = strlib_malloc(dp_ver, strlen(dp_ver));
msg.update.ccFeatUpd.data.cfg_ver_data.softkey_ver = strlib_malloc(softkey_ver, strlen(softkey_ver));
if ( ccappTaskPostMsg(CCAPP_FEATURE_UPDATE, &msg, sizeof(feature_update_t), CCAPP_CCPROVIER) != CPR_SUCCESS ) {
CCAPP_DEBUG(DEB_F_PREFIX"failed to send platform_sync_cfg_vers msg \n",
DEB_F_PREFIX_ARGS(PLAT_API, fname));
}
}
/*
* Function: strlib_open
*
* PARAMETERS: string_t : string to be modified
* int : length of string to be modified
*
* DESCRIPTION:User will call open when he wants to modify the string. If
* length of string after modification is going to be = < original string
* return to him pointer to original string, else a new string is malloced
* for user and a pointer to it is send to him.
*
* RETURNS: char* to modifiable string
*
*/
char *
strlib_open (string_t str, int length, const char *fname, int line)
{
char *ret_str;
string_block_t *temp;
if (!strlib_is_string(str)) {
return (NULL);
}
temp = STR_TO_STRUCT(str);
if ((temp->refcount == 1) && (length <= temp->length)) {
ret_str = (char *) str;
} else {
ret_str = (char *) strlib_malloc(str, length, fname, line);
if (!ret_str) {
/*
* If a malloc error occurred, give them back what they had.
* It's not right, but it's better than nothing.
*/
ret_str = (char *) str;
} else {
strlib_free(str);
}
}
return (ret_str);
}
void ccsnap_device_init() {
char temp[MAX_SIP_URL_LENGTH];
/* clean up structure if need be */
ccsnap_device_pre_init();
memset (&g_deviceInfo, 0, sizeof(g_deviceInfo));
g_deviceInfo.name =strlib_empty();
g_deviceInfo.not_prompt =strlib_empty();
g_deviceInfo.not_prompt_prio = 0;
g_deviceInfo.not_prompt_prog = 0;
g_deviceInfo.mwi_lamp = FALSE;
g_deviceInfo.cucm_mode = CC_MODE_CCM;
g_deviceInfo.ins_state = CC_STATE_IDLE;
g_deviceInfo.ins_cause = CC_CREATED_IDLE;
g_deviceInfo.reg_time = 0;
config_get_string(CFGID_CCM1_ADDRESS, temp, MAX_SIP_URL_LENGTH);
g_deviceInfo.ucm[0].name = strlib_malloc(temp, strlen(temp));
g_deviceInfo.ucm[0].type = CC_MODE_CCM;
g_deviceInfo.ucm[0].status = CC_CCM_STATUS_NONE;
config_get_string(CFGID_CCM2_ADDRESS, temp, MAX_SIP_URL_LENGTH);
g_deviceInfo.ucm[1].name = strlib_malloc(temp, strlen(temp));
g_deviceInfo.ucm[1].type = CC_MODE_CCM;
g_deviceInfo.ucm[1].status = CC_CCM_STATUS_NONE;
config_get_string(CFGID_CCM3_ADDRESS, temp, MAX_SIP_URL_LENGTH);
g_deviceInfo.ucm[2].name = strlib_malloc(temp, strlen(temp));
g_deviceInfo.ucm[2].type = CC_MODE_CCM;
g_deviceInfo.ucm[2].status = CC_CCM_STATUS_NONE;
config_get_string(CFGID_CCM_TFTP_IP_ADDR, temp, MAX_SIP_URL_LENGTH);
g_deviceInfo.ucm[3].name = strlib_malloc(temp, strlen(temp));
g_deviceInfo.ucm[3].type = CC_MODE_CCM;
g_deviceInfo.ucm[3].status = CC_CCM_STATUS_NONE;
g_accessoryCfgInfo.camera = ACCSRY_CFGD_CFG;
g_accessoryCfgInfo.video = ACCSRY_CFGD_CFG;
}
/*
* Function: strlib_empty
*
* PARAMETERS: None
*
* DESCRIPTION:strlib_empty will be called by user when he wants
* to initialize his string to '/0' or "". It is not same as initializing
* it to NULL. if(str) will evaluate to true if str = strlib_empty().
* Correct way to check for empty string will be to do if (str[0] == '\0') or
* if (str[0] == "")
*
* RETURNS: Pointer to empty_str
*/
string_t
strlib_empty (void)
{
string_block_t *temp;
static boolean empty_str_init = FALSE;
if (empty_str_init == FALSE) {
empty_str = strlib_malloc("", LEN_UNKNOWN, __FILE__, __LINE__);
temp = STR_TO_STRUCT(empty_str);
temp->refcount = 0xffff;
empty_str_init = TRUE;
}
return (empty_str);
}
/*
* Function: strlib_update
*
* PARAMETERS:string_t : destination string
* const char* : source string
*
* DESCRIPTION:like strcpy but returns const char* to a string in pool
*
* RETURNS: string_t:Pointer to a new string
*
*/
string_t
strlib_update (string_t destination, const char *source,
const char *calling_fname, int line)
{
const char *fname = "strlib_udpate";
string_t ret_str;
/* Bogus destination */
if (!destination) {
/* Should never happen, so report it */
err_msg("%s: Destination String is invalid: %s:%d", fname,
calling_fname, line);
/* bad input, bad output */
return NULL;
}
/* Bogus source */
if (!source) {
/* Should never happen, so report it and return something */
err_msg("%s: Source String is invalid: %s:%d", fname,
calling_fname, line);
strlib_free(destination);
return strlib_empty();
}
if (source[0] == '\0') {
/* Source is NULL string, use string empty */
strlib_free(destination);
return strlib_empty();
}
ret_str = strlib_malloc(source, LEN_UNKNOWN, calling_fname, line);
if (!ret_str) {
/*
* If a malloc error occurred, give them back what they had.
* It's not right, but it's better than nothing.
*/
ret_str = destination;
} else {
strlib_free(destination);
}
return (ret_str);
}
/**
* Inserts localized strings into existing strings with escape characters.
* @param destination the return phrase holder
* @param source the phrase with escape characters.
* @param len the input length to cap the maximum value
* @return pointer to the new string
*/
cc_string_t ccsnap_EscapeStrToLocaleStr(cc_string_t destination, cc_string_t source, int len)
{
static const char *fname="ccsnap_EscapeStrToLocaleStr";
char phrase_collector[MAX_LOCALE_STRING_LEN] = { '\0' };
char* phrase_collector_ptr = phrase_collector;
char* esc_string_itr = (char*)source;
int remaining_length = 0;
cc_string_t ret_str = strlib_empty();
if(destination == NULL){
CCAPP_DEBUG(DEB_F_PREFIX"Error: destination is NULL\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));
return NULL;
}
if(source == NULL){
CCAPP_DEBUG(DEB_F_PREFIX"Error: source is NULL\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));
strlib_free(destination);
return strlib_empty();
}
if(source[0] == '\0'){
strlib_free(destination);
return strlib_empty();
}
if (len == LEN_UNKNOWN) {
len = strlen(source) + MAX_LOCALE_PHRASE_LEN;
}
if (len <= 0){
CCAPP_DEBUG(DEB_F_PREFIX"Error: cannot write string of length <= 0\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));
strlib_free(destination);
return strlib_empty();
}
if (len > MAX_LOCALE_STRING_LEN){
len = MAX_LOCALE_STRING_LEN;
}
remaining_length = len;
while( *esc_string_itr != NUL &&
remaining_length > 0 &&
strlen(phrase_collector_ptr) < (size_t)(len-1))
{
int rtn = CC_SUCCESS;
int phrase_index = 0;
char* phrase_bucket_ptr = (char*)cpr_malloc(remaining_length * sizeof(char));
if (phrase_bucket_ptr == NULL) {
CCAPP_ERROR(DEB_F_PREFIX"Error: phrase_bucket_ptr is NULL\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));
strlib_free(destination);
return NULL;
}
phrase_bucket_ptr[0] = '\0';
switch(*esc_string_itr){
case OLD_CUCM_DICTIONARY_ESCAPE_TAG:
phrase_index += CALL_CONTROL_PHRASE_OFFSET;
// Do not set break to combine common code
case NEW_CUCM_DICTIONARY_ESCAPE_TAG:
esc_string_itr++;
phrase_index += (int)(*esc_string_itr);
rtn = platGetPhraseText(phrase_index, phrase_bucket_ptr, remaining_length-1);
if(rtn == CC_FAILURE) break;
sstrncat(phrase_collector_ptr, (cc_string_t)phrase_bucket_ptr, remaining_length);
remaining_length--;
break;
default:
// We need length 2 to concat 1 char and a terminating char
sstrncat(phrase_collector_ptr, esc_string_itr, 1 + sizeof(char));
remaining_length--;
break;
}
esc_string_itr++;
cpr_free(phrase_bucket_ptr);
}
ret_str = strlib_malloc(phrase_collector_ptr, len);
if (!ret_str) {
/*
* If a malloc error occurred, give them back what they had.
* It's not right, but it's better than nothing.
*/
ret_str = destination;
} else {
strlib_free(destination);
}
CCAPP_DEBUG(DEB_F_PREFIX"Localization String returning %s\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), ret_str);
return (ret_str);
}
/**
* Initialize lineinfo and featureinfo arrays
*/
void ccsnap_line_init() {
int i;
cc_uint32_t tmpInt;
char tempStr[MAX_URL_LENGTH];
char maskStr[MAX_EXTERNAL_NUMBER_MASK_SIZE];
/* clean up structure if need be */
ccsnap_line_pre_init();
memset(lineInfo, 0, MAX_CONFIG_LINES*sizeof(cc_line_info_t));
memset(featureInfo, 0, MAX_CONFIG_LINES*sizeof(cc_feature_info_t));
for (i=1;i<=MAX_CONFIG_LINES;i++) {
config_get_line_value(CFGID_LINE_FEATURE, &tmpInt, sizeof(tmpInt), i);
if ( tmpInt == cfgLineFeatureDN ) {
lineInfo[i].button = i;
lineInfo[i].line_type = tmpInt;
config_get_line_value(CFGID_LINE_INDEX, &tmpInt, sizeof(tmpInt), i);
lineInfo[i].line_id = tmpInt;
config_get_line_value(CFGID_LINE_DISPLAYNAME_STRING, tempStr,
MAX_URL_LENGTH, i);
lineInfo[i].dn = strlib_malloc(tempStr, strlen(tempStr));
config_get_line_value(CFGID_LINE_NAME_STRING, tempStr,
MAX_URL_LENGTH, i);
lineInfo[i].name = strlib_malloc(tempStr, strlen(tempStr));
config_get_line_value(CFGID_LINE_CFWDALL, tempStr,
MAX_URL_LENGTH, i);
lineInfo[i].cfwd_dest = strlib_malloc(tempStr, strlen(tempStr));
config_get_line_value(CFGID_LINE_SPEEDDIAL_NUMBER_STRING, tempStr,
MAX_URL_LENGTH, i);
memset(maskStr, 0, sizeof(maskStr));
config_get_string(CFGID_CCM_EXTERNAL_NUMBER_MASK, maskStr, MAX_EXTERNAL_NUMBER_MASK_SIZE);
if (strlen(maskStr) > 0) {
lineInfo[i].externalNumber = CCAPI_ApplyTranslationMask(lineInfo[i].name, maskStr);
CCAPP_DEBUG("Setting lineInfo[i].externalNumber to %s\n", lineInfo[i].externalNumber);
} else {
lineInfo[i].externalNumber = strlib_empty();
}
} else {
lineInfo[i].line_id = MAX_CONFIG_LINES+1; // invalid line id
lineInfo[i].button = i;
lineInfo[i].dn = strlib_empty();
lineInfo[i].name = strlib_empty();
lineInfo[i].cfwd_dest = strlib_empty();
lineInfo[i].externalNumber = strlib_empty();
}
capset_get_idleset(CC_MODE_CCM, lineInfo[i].allowed_features);
// get feature again because it might have been changed if it is a DN
// and the tmpInt might have a different value
config_get_line_value(CFGID_LINE_FEATURE, &tmpInt, sizeof(tmpInt), i);
// features which have no properties
if ( tmpInt == cfgLineFeatureAllCalls ||
tmpInt == cfgLineFeatureMaliciousCallID ||
tmpInt == cfgLineFeatureRedial || tmpInt == cfgLineFeatureAnswerOldest || tmpInt == cfgLineFeatureServices ) {
featureInfo[i].feature_id = tmpInt;
featureInfo[i].button = i;
featureInfo[i].speedDialNumber = strlib_empty();
featureInfo[i].contact = strlib_empty();
featureInfo[i].name = strlib_empty();
featureInfo[i].retrievalPrefix = strlib_empty();
featureInfo[i].featureOptionMask = 0;
} else if ( tmpInt == cfgLineFeatureSpeedDialBLF || tmpInt == cfgLineFeatureSpeedDial){
featureInfo[i].feature_id = tmpInt;
featureInfo[i].button = i;
config_get_line_value(CFGID_LINE_SPEEDDIAL_NUMBER_STRING, tempStr,
MAX_URL_LENGTH, i);
featureInfo[i].speedDialNumber = strlib_malloc(tempStr, strlen(tempStr));
featureInfo[i].contact = strlib_empty();
config_get_line_value(CFGID_LINE_NAME_STRING, tempStr,
MAX_URL_LENGTH, i);
featureInfo[i].name = strlib_malloc(tempStr, strlen(tempStr));
featureInfo[i].retrievalPrefix = strlib_empty();
config_get_line_value(CFGID_LINE_FEATURE_OPTION_MASK, &tmpInt, sizeof(tmpInt), i);
featureInfo[i].featureOptionMask = tmpInt;
featureInfo[i].blf_state = CC_SIP_BLF_UNKNOWN;
} else {
featureInfo[i].feature_id = 0;
featureInfo[i].button = MAX_CONFIG_LINES+1; // invalid button value
featureInfo[i].speedDialNumber = strlib_empty();
featureInfo[i].contact = strlib_empty();
featureInfo[i].name = strlib_empty();
featureInfo[i].retrievalPrefix = strlib_empty();
featureInfo[i].featureOptionMask = 0;
}
}
}
/*
* Taken from CUCM/CUP code as they have done this already.
*/
cc_string_t CCAPI_ApplyTranslationMask (const char *ext, const char *mask)
{
char translationMask[100] = {'\0'};
char dn[100] = {'\0'};
char translatedString[100] = {'\0'};
cc_string_t result;
unsigned int maskLen,
dnLen,
i, j = 0;
if ((ext == NULL) || (mask == NULL)) {
return NULL;
}
maskLen = strlen(mask);
dnLen = strlen(ext);
if ((dnLen == 0) || (maskLen == 0)) {
CCAPP_DEBUG(DEB_F_PREFIX"CCAPI_ApplyTranslationMask DN or mask has len=0\n",
DEB_F_PREFIX_ARGS(SIP_CC_PROV, "CCAPI_ApplyTranslationMask"));
return NULL;
}
/* make sure there's enough space in the buffer to
* hold the translated string.
*/
if (dnLen + maskLen > 99) {
CCAPP_DEBUG(DEB_F_PREFIX"CCAPI_ApplyTranslationMask length overflow\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, "CCAPI_ApplyTranslationMask"));
return NULL;
}
sstrncpy(translationMask, mask, 100);
sstrncpy(dn, ext, 100);
/* make sure DN is numeric only */
for (i=0; i< dnLen; i++) {
if (isalpha(dn[i])) {
return 0;
}
}
if (maskLen > dnLen) {
stringInsert(dn, maskLen - dnLen, '?');
}
/* if the digit string is longer than the translation mask
* prepad the translation mask with '%'.
*/
if (dnLen > maskLen) {
stringInsert(translationMask, dnLen - maskLen, '%');
}
dnLen = strlen(dn);
for (i=0; i < dnLen; i++) {
if (translationMask[i] == '%')
continue;
else if (translationMask[i] == 'X')
translatedString[j++] = dn[i];
else
translatedString[j++] = translationMask[i];
}
translatedString[j] = 0;
result = strlib_malloc(translatedString, strlen(translatedString));
return result;
}
