/** * Gracefully unload the Sipcc stack * @return */ cc_return_t CCAPI_Service_destroy() { CCAPP_ERROR("CCAPI_Service_destroy - calling CC_Service_destroy \n"); if (is_action_to_be_deferred(STOP_ACTION) == TRUE) { return CC_SUCCESS; } // initialize the config to empty init_empty_str(g_cfg_p); isServiceStartRequestPending = FALSE; registration_processEvent(EV_CC_DESTROY); return (CC_SUCCESS); }
void ccsnap_set_line_label(int btn, cc_string_t label) { CCAPP_ERROR(DEB_F_PREFIX"btn=%d label=%s\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, "ccsnap_set_line_label"), btn, label); if ( btn > 0 && btn <= MAX_CONFIG_LINES+1 ) { if ( label == NULL ) { label = strlib_empty(); } if ( lineLabels[btn] == NULL ) { lineLabels[btn] = strlib_empty(); } lineLabels[btn] = strlib_update(lineLabels[btn], label); } }
/** * * @content: the content of the document * @length: the length in bytes * * Parse the in memory document and free the resulting tree */ void decodeInfoXML(const char *content, int length, cc_call_conference_Info_t *info) { xmlDocPtr doc; /* the resulting document tree */ xmlNode *root_element = NULL; doc = xmlReadMemory(content, length, "noname.xml", NULL, 0); if (doc == NULL) { CCAPP_ERROR(DEB_F_PREFIX" Failed to parse document\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, "CCAPI-CONFPARSE")); return; } /* Get the root element node */ root_element = xmlDocGetRootElement(doc); if (root_element == NULL) { CCAPP_ERROR(DEB_F_PREFIX" Failed to get the root element\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, "CCAPI-CONFPARSE")); return; } if (xmlStrcmp(root_element->name, (const xmlChar *)"conference-info") == 0) { parse_conference_info_node(root_element, doc, info); } xmlFreeDoc(doc); }
/** * * Notify the platform that call control has shut down. * * @param none * * @return none */ void shutdownCCAck (void) { static const char fname[] = "shutdownCCAck"; feature_update_t msg; CCAPP_DEBUG(DEB_F_PREFIX"\n", DEB_F_PREFIX_ARGS(PLAT_API, fname)); msg.sessionType = SESSIONTYPE_CALLCONTROL; msg.featureID = CCAPP_SHUTDOWN_ACK; if ( ccappTaskPostMsg(CCAPP_SHUTDOWN_ACK, &msg, sizeof(feature_update_t), CCAPP_CCPROVIER) != CPR_SUCCESS ) { CCAPP_ERROR(PLT_F_PREFIX"failed to send shutdownCCAck(%d) msg \n", fname); } }
void platform_logout_reset_req(void){ static const char fname[] = "platform_logout_reset_req"; feature_update_t msg; CCAPP_DEBUG(DEB_F_PREFIX"\n", DEB_F_PREFIX_ARGS(PLAT_API, fname)); msg.sessionType = SESSIONTYPE_CALLCONTROL; msg.featureID = CCAPP_LOGOUT_RESET; if ( ccappTaskPostMsg(CCAPP_FALLBACK_IND, &msg, sizeof(feature_update_t), CCAPP_CCPROVIER) != CPR_SUCCESS ) { CCAPP_ERROR(PLT_F_PREFIX"failed to send Logout_Reset(%d) msg \n", fname); } return; }
cc_participant_ref_t CCAPI_CallInfo_getConfSelfParticipant (cc_callinfo_ref_t handle) { cc_call_conference_ref_t callConference; // conference reference (from call info) // get conference reference from the call info callConference = getCallConferenceRef(handle); if (callConference == NULL) { // unexpected error CCAPP_ERROR(DEB_F_PREFIX"Unable to get conference reference\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, "CCAPI-CONF")); return strlib_empty(); } return (callConference->myParticipantId); }
cc_boolean CCAPI_CallInfo_isConfSelfParticipant (cc_callinfo_ref_t handle, cc_participant_ref_t participantHandle) { cc_call_conference_ref_t callConference; // conference reference (from call info) // get conference reference from the call info callConference = getCallConferenceRef(handle); if (callConference == NULL) { // error - log CCAPP_ERROR(DEB_F_PREFIX"Unable to get conference reference\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, "CCAPI-CONF")); return (FALSE); } return (strcmp((callConference->myParticipantId), participantHandle) == 0); }
/** * Notify the platform about the change in call control mode. * * @param mode - the call control mode. * cip_sipcc_CcMgmtConst_CC_TYPE_CCM * or cip_sipcc_CcMgmtConst_CC_TYPE_OTHER * * @return none */ void platform_cc_mode_notify (int mode) { static const char fname[] = "platform_cc_mode_notify"; feature_update_t msg; CCAPP_DEBUG(DEB_F_PREFIX"mode =%d\n", DEB_F_PREFIX_ARGS(PLAT_API, fname), mode); msg.sessionType = SESSIONTYPE_CALLCONTROL; msg.featureID = CCAPP_MODE_NOTIFY; msg.update.ccFeatUpd.data.line_info.info = mode; if ( ccappTaskPostMsg(CCAPP_MODE_NOTIFY, &msg, sizeof(feature_update_t), CCAPP_CCPROVIER) != CPR_SUCCESS ) { CCAPP_ERROR(PLT_F_PREFIX"failed to send platform_cc_mode_notify(%d) msg \n", fname, mode); } }
/** * Stop Sipcc stack service * @return */ cc_return_t CCAPI_Service_stop() { int sdpmode = 0; CCAPP_ERROR("CCAPI_Service_stop - calling registration stop"); config_get_value(CFGID_SDPMODE, &sdpmode, sizeof(sdpmode)); if (!sdpmode) { if (is_action_to_be_deferred(STOP_ACTION) == TRUE) { return CC_SUCCESS; } } sendResetUpdates = 0; // reset to default is not to send updates isServiceStartRequestPending = FALSE; registration_processEvent(EV_CC_STOP); return CC_SUCCESS; }
/** * Get the call conference reference * @param [in] handle - call info handle * @return cc_call_conference_Info_t */ cc_call_conference_ref_t getCallConferenceRef(cc_callinfo_ref_t handle) { session_data_t *data = (session_data_t *)handle; if (!CCAPI_CallInfo_getIsConference(handle)) { CCAPP_ERROR(DEB_F_PREFIX"Conference API Invoked, but Not In Conference Call\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, "CCAPI-CONF")); return (NULL); }; if (data == NULL) { return (NULL); } return (&data->call_conference); }
/** * Indicate to the platform that reg manager intends to fallback to * primary CCM. Currently the fallback_to is always to CC_TYPE_CCM. * * @param fallback_to - type of call control, * e.g. cip_sipcc_CcMgmtConst_CC_TYPE_CCM * * @return none */ void platform_reg_fallback_ind (int fallback_to) { static const char fname[] = "platform_reg_fallback_ind"; feature_update_t msg; DEF_DEBUG(DEB_F_PREFIX"***********Fallback to %d CUCM.***********\n", DEB_F_PREFIX_ARGS(PLAT_API, fname), fallback_to); msg.sessionType = SESSIONTYPE_CALLCONTROL; msg.featureID = CCAPP_FALLBACK_IND; msg.update.ccFeatUpd.data.line_info.info = fallback_to; if ( ccappTaskPostMsg(CCAPP_FALLBACK_IND, &msg, sizeof(feature_update_t), CCAPP_CCPROVIER) != CPR_SUCCESS ) { CCAPP_ERROR(PLT_F_PREFIX"failed to send platform_reg_fallback_ind(%d) msg \n", fname, fallback_to); } }
/** * Get Maximum Number of Conference Participants ( in case gui wants to show %full conference info ) * @param [in] handle - call handle * @return maximum number of conference participants */ cc_uint16_t CCAPI_CallInfo_getConfParticipantMax (cc_callinfo_ref_t handle) { // cc_call_conference_ref_t callConference; // conference reference (from call info) CCAPP_DEBUG(DEB_F_PREFIX"Entering: CCAPI_CallInfo_getConfParticipantMax\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, "CCAPI-CONF")); // get conference reference from the call info callConference = getCallConferenceRef(handle); if (callConference == NULL) { // no conference reference available CCAPP_ERROR(DEB_F_PREFIX"Unable to get conference reference\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, "CCAPI-CONF")); return (0); } // return the max return (callConference->participantMax); }
void CCAPI_Start_response(int device_handle, const char *device_name, const char *sipUser, const char *sipPassword, const char *sipDomain) { static const char fname[] = "CCAPI_Start_response"; if (is_empty_str((char*)sipUser) || is_empty_str((char*)sipDomain)) { CCAPP_ERROR(DEB_F_PREFIX" invalid registration details user=%s, domain=%s", DEB_F_PREFIX_ARGS(CC_API, fname), sipUser, sipDomain); return; } g_dev_hdl = device_handle; sstrncpy(g_dev_name, device_name, sizeof(g_dev_name)); if (is_phone_registered() == FALSE) { if (parse_setup_properties(device_handle, device_name, sipUser, sipPassword, sipDomain)) { registration_processEvent(EV_CC_CONFIG_RECEIVED); } return; } }
cpr_status_e ccappTaskPostMsg(unsigned int msgId, void * data, uint16_t len, int appId) { cprBuffer_t *msg; static const char fname[] = "ccappPostMsg"; cpr_status_e retval = CPR_SUCCESS; msg = (cprBuffer_t *) cpr_malloc(len); if (msg == NULL) { CCAPP_ERROR(DEB_F_PREFIX"failed to allocate message.\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname)); return CPR_FAILURE; } memcpy(msg, data, len); if ((retval=ccappTaskSendMsg(msgId, msg, len, appId)) == CPR_FAILURE) { cpr_free(msg); } return retval; }
/* * parse_conference_description_node * * Do conference-description specific parsing. * * Assumes a_node, info are not null. */ static void parse_conference_description_node (xmlNode * a_node, cc_call_conference_Info_t *info) { xmlNode *cur_node; xmlChar *data; for (cur_node = a_node->children; cur_node != NULL; cur_node = cur_node->next) { if (cur_node->type == XML_ELEMENT_NODE) { if (xmlStrcmp(cur_node->name, (const xmlChar *) "maximum-user-count") == 0) { data = xmlNodeGetContent(cur_node); if (data != NULL) { info->participantMax = atoi((const char*)data); xmlFree(data); } else { //No max-user-count - continue parsing other elements - CCAPP_ERROR(DEB_F_PREFIX" Error while trying to get the max-user-count\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, "CCAPI-CONFPARSE")); } } } } }
/* * Function: ParseDialVersion() * * Parameters: parseptr - pointer to bytes to be parsed * * Description: Parse the contents of a versionStamp tag and store it * The format of the versionStamp is as follows: * <versionStamp>value up to 64 chars</versionStamp> * * Returns: 0 - if the version stamp is successfully parsed. * 1 - if the version stamp parsing fails. */ static int ParseDialVersion (char **parseptr) { ParseDialState state = STATE_ANY; char version_stamp[MAX_DP_VERSION_STAMP_LEN] = { 0 }; int len; for (;;) { char buffer[MAX_DP_VERSION_STAMP_LEN]; XMLToken tok; tok = parse_xml_tokens(parseptr, buffer, sizeof(buffer)); switch (tok) { case TOK_KEYWORD: switch (state) { case STATE_START_TAG_COMPLETED: /* * the keyword is version stamp value here. copy it temporarily. */ memcpy(version_stamp, buffer, MAX_DP_VERSION_STAMP_LEN); break; case STATE_END_TAG_STARTED: if (cpr_strcasecmp(buffer, "versionStamp") != 0) { return 1; } state = STATE_END_TAG_FOUND; break; default: break; } break; case TOK_RBRACKET: /* ">" */ if (state == STATE_ANY) { state = STATE_START_TAG_COMPLETED; } else if (state == STATE_END_TAG_FOUND) { /* strip of the warping curly braces if they exist */ len = strlen(version_stamp); if (len <= 2) { CCAPP_ERROR("ParseDialVersion(): Version length [%d] is way too small", len); return (1); } memset(g_dp_version_stamp, 0, MAX_DP_VERSION_STAMP_LEN); if ((version_stamp[0] == '{') && (version_stamp[len - 1] == '}')) { memcpy(g_dp_version_stamp, (version_stamp + 1), (len - 2)); } else { memcpy(g_dp_version_stamp, version_stamp, len); } return 0; } else { return 1; } break; case TOK_ENDLBRACKET: /* "</" */ if (state == STATE_START_TAG_COMPLETED) { state = STATE_END_TAG_STARTED; } else { return 1; } break; default: /* * Problem parsing. Let them know */ return 1; } } }
/* * parse_user_node * * Do user node specific parsing. * * Assumes a_node, info are not null. */ static void parse_user_node (xmlNode * a_node, cc_call_conference_Info_t *info) { xmlChar *data; xmlNode *cur_node; cc_call_conferenceParticipant_Info_t *participant; sll_lite_return_e sll_ret_val; //allocate a new participant participant = cpr_malloc(sizeof(cc_call_conferenceParticipant_Info_t)); if (participant == NULL) { CCAPP_ERROR(DEB_F_PREFIX" Malloc failure for participant\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, "CCAPI-CONFPARSE")); return; } else { participant->participantName = strlib_empty(); participant->endpointUri = strlib_empty(); participant->callid = strlib_empty(); participant->participantNumber = strlib_empty(); participant->participantSecurity = CC_SECURITY_NONE; participant->participantStatus = CCAPI_CONFPARTICIPANT_UNKNOWN; participant->canRemoveOtherParticipants = FALSE; } sll_ret_val = sll_lite_link_tail(&info->currentParticipantsList, (sll_lite_node_t *)participant); if (sll_ret_val != SLL_LITE_RET_SUCCESS) { CCAPP_ERROR(DEB_F_PREFIX" Error while trying to insert in the linked list\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, "CCAPI-CONFPARSE")); cpr_free(participant); return; } data = xmlGetProp(a_node, (const xmlChar *) "entity"); if (data != NULL) { char *tmp2; char *tmp1; participant->endpointUri = strlib_update(participant->endpointUri, (const char*)data); // Parse the endpoint URI, to get the Participant number tmp1 = (char *) strstr((const char*)data, "sip:"); if (tmp1) { tmp1 += 4; tmp2 = (char *) strchr(tmp1, '@'); if (tmp2) { *tmp2 = 0; participant->participantNumber = strlib_update(participant->participantNumber, (const char*)tmp1); } } xmlFree(data); } else { //continue parsing other elements CCAPP_ERROR(DEB_F_PREFIX" Error while trying to find the endpoint URI\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, "CCAPI-CONFPARSE")); } for (cur_node = a_node->children; cur_node != NULL; cur_node = cur_node->next) { if (cur_node->type == XML_ELEMENT_NODE) { if (xmlStrcmp(cur_node->name, (const xmlChar *) "endpoint") == 0) { parse_user_endpoint_node(cur_node, participant, info); } else if (xmlStrcmp(cur_node->name, (const xmlChar *) "display-text") == 0) { data = xmlNodeGetContent(cur_node); if (data != NULL) { participant->participantName = strlib_update(participant->participantName, (const char*)data); xmlFree(data); } else { //No display text - continue parsing other elements - CCAPP_ERROR(DEB_F_PREFIX" Error while trying to get the display text\n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, "CCAPI-CONFPARSE")); } } } } }
/** * 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); }