自学教程：C++ DEB_F_PREFIX_ARGS函数代码示例

/* *  Function:    sub_hndlr_controlBLFButtons * *  Description: hides/unhides BLF states. * *  Parameters: none. * *  Returns:    void */void sub_hndlr_controlBLFButtons(boolean state){    static const char fname[] = "sub_hndlr_controlBLFButtons";    if (state == TRUE) {        CCAPP_DEBUG(DEB_F_PREFIX"going to hide/n",                    DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));        hideBLFButtonsDisplay();    } else {        CCAPP_DEBUG(DEB_F_PREFIX"going to unhide/n",                    DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));        unhideBLFButtonsDisplay();    }}

/** * * Tell platform to adjust the time to the gmt_time received from outside * For sip the "outside" is from the "Date" header coming from a CCM or * any other Server * * @param       gmt_time   - GMT time in seconds * * @return      none */voidplatform_set_time (long gmt_time){    static const char fname[] = "platform_set_time";    session_mgmt_t msg;    CCAPP_DEBUG(DEB_F_PREFIX"setting time to=%ld", DEB_F_PREFIX_ARGS(PLAT_API, fname), gmt_time);    msg.func_id = SESSION_MGMT_SET_TIME;    msg.data.time.gmt_time = gmt_time;    if ( ccappTaskPostMsg(CCAPP_SESSION_MGMT, &msg, sizeof(session_mgmt_t), CCAPP_CCPROVIER) != CPR_SUCCESS ) {        CCAPP_DEBUG(DEB_F_PREFIX"failed to send platform_set_time msg/n", DEB_F_PREFIX_ARGS(PLAT_API, fname));    }}

/* *  Function:    sub_hndlr_isInUseBLFState * *  Description: returns if the BLF state is "in use" * *  Parameters: *    inst - line button number. * *  Returns:    TRUE/FALSE */boolean sub_hndlr_isInUseBLFState(int inst){    static const char fname[] = "sub_hndlr_isInUseBLFState";    if ((displayBLFState == TRUE) && (blfStates[inst - 1] == CC_SIP_BLF_INUSE)) {    CCAPP_DEBUG(DEB_F_PREFIX"inst=%d, isInUse=TRUE/n",                DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname),                inst);        return TRUE;    }    CCAPP_DEBUG(DEB_F_PREFIX"inst=%d, isInUse=FALSE/n",                DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname),                inst);    return FALSE;}

/* * capset_get_idleset - get the set of features associated with idle state * */void capset_get_idleset ( cc_cucm_mode_t mode, cc_boolean features[]){  static const char fname[] = "capset_get_idleset";  int i;  CCAPP_DEBUG(DEB_F_PREFIX"updating idleset",            DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));     for (i=0;i < CCAPI_CALL_CAP_MAX; i++) {  CCAPP_DEBUG(DEB_F_PREFIX"updating line features %d=%d",            DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), i, capability_idleset[i]);       features[i] = capability_idleset[i];     }}

/*called from configapp.c.  This routine will set the kpml  value on the java side and trigger it down to c-side.  Also, it will reinitialize the dialplan. */voidupdate_kpmlconfig(int kpmlVal){    static const char fname[] = "update_kpmlconfig";    session_mgmt_t msg;    CCAPP_DEBUG(DEB_F_PREFIX "kpml=%d/n", DEB_F_PREFIX_ARGS(PLAT_API, fname), kpmlVal);    msg.func_id = SESSION_MGMT_UPDATE_KPMLCONFIG;    msg.data.kpmlconfig.kpml_val = kpmlVal;    if ( ccappTaskPostMsg(CCAPP_SESSION_MGMT, &msg, sizeof(session_mgmt_t), CCAPP_CCPROVIER) != CPR_SUCCESS ) {        CCAPP_DEBUG(DEB_F_PREFIX"failed to send update_kpmlconfig msg/n", DEB_F_PREFIX_ARGS(PLAT_API, fname));    }}

static voiddp_do_redial (line_t line, callid_t call_id){    const char fname[] = "dp_do_redial";    DPINT_DEBUG(DEB_F_PREFIX"line=%d call_id=%d/n", DEB_F_PREFIX_ARGS(DIALPLAN, fname), line, call_id);    if (line == 0) {        line = dp_get_redial_line();    }    //CSCsz63263, use prime line instead if last redialed line is unregistered    if(ccsip_is_line_registered(line) == FALSE) {         DPINT_DEBUG(DEB_F_PREFIX"line %d unregistered, use line %d instead /n", DEB_F_PREFIX_ARGS(DIALPLAN, fname), line,        		 PRIME_LINE_ID);         line = PRIME_LINE_ID;         if( ccsip_is_line_registered(line) == FALSE) {            DPINT_DEBUG(DEB_F_PREFIX" prime line %d unregistered/n", DEB_F_PREFIX_ARGS(DIALPLAN, fname), line);            return;       }     }    if (g_dp_int.gReDialed[0] == NUL) {        DPINT_DEBUG(DEB_F_PREFIX"NO DIAL STRING line=%d call_id=%d/n", DEB_F_PREFIX_ARGS(DIALPLAN, fname), line,                    call_id);        return;    }    sstrncpy(g_dp_int.gDialed, g_dp_int.gReDialed, MAX_DIALSTRING);    g_dp_int.line = line;    g_dp_int.call_id = call_id;    g_dp_int.allow_proceed = TRUE;        /*     * If we are doing redial, then we won't be entering any more digits     */    g_dp_int.gDialplanDone = TRUE;       (void) cprCancelTimer(g_dp_int.dial_timer);    kpml_set_subscription_reject(line, call_id);    kpml_flush_quarantine_buffer(line, call_id);    cc_dialstring(CC_SRC_GSM, call_id, line, &g_dp_int.gReDialed[0]);}

/** * This function calls the JNI function to sends the information received * in apply-config NOTIFY message to Java side. * * @param   configVersionStamp - version stamp for config file * @param   dialplanVersionStamp - version stamp for the dialplan file * @param   fcpVersionStamp - version stamp for the softkey file (?) * @param   cucmResult  - CUCM result after applying config by CUCM * @param   loadId  - loadId to upgrade as requested by CUCM * @param   inactiveLoadId  - inactive loadId for inactive partition as requested by CUCM * @param   loadServer  - load server form where to pick loadId * @param   logServer  - log server for logging output of peer to peer upgrade. * @param   ppid  - specify whether peer to peer upgrade is enabled/disabled. * * @return  none */voidplatform_apply_config (char * configVersionStamp,                       char * dialplanVersionStamp,                       char * fcpVersionStamp,                       char * cucmResult,                       char * loadId,                       char * inactiveLoadId,                        char * loadServer,                       char * logServer,                       boolean ppid){    static const char fname[] = "platform_apply_config";    session_mgmt_t msg;    fcpVersionStamp = (fcpVersionStamp != NULL) ? fcpVersionStamp : "";    /// Print the arguments    CCAPP_DEBUG(DEB_F_PREFIX"   configVersionStamp=%s /ndialplanVersionStamp=%s"           "/nfcpVersionStamp=%s /ncucmResult=%s "           "/nloadId=%s /ninactiveLoadId=%s /nloadServer=%s /nlogServer=%s "           "/nppid=%s/n", DEB_F_PREFIX_ARGS(PLAT_API, fname),           (configVersionStamp != NULL) ? configVersionStamp : "",           (dialplanVersionStamp != NULL) ? dialplanVersionStamp:"",           fcpVersionStamp,           cucmResult != NULL ? cucmResult: "",           (loadId != NULL) ? loadId : "",           (inactiveLoadId != NULL) ? inactiveLoadId : "",           (loadServer != NULL) ? loadServer : "",           (logServer != NULL) ? logServer : "",           ppid == TRUE? "True": "False");    // following data is freed in function freeSessionMgmtData()    msg.func_id = SESSION_MGMT_APPLY_CONFIG;    msg.data.config.config_version_stamp = STRLIB_CREATE(configVersionStamp);    msg.data.config.dialplan_version_stamp = STRLIB_CREATE(dialplanVersionStamp);    msg.data.config.fcp_version_stamp = STRLIB_CREATE(fcpVersionStamp);    msg.data.config.cucm_result = STRLIB_CREATE(cucmResult);    msg.data.config.load_id = STRLIB_CREATE(loadId);    msg.data.config.inactive_load_id = STRLIB_CREATE(inactiveLoadId);    msg.data.config.load_server = STRLIB_CREATE(loadServer);    msg.data.config.log_server = STRLIB_CREATE(logServer);    msg.data.config.ppid = ppid;    if ( ccappTaskPostMsg(CCAPP_SESSION_MGMT, &msg, sizeof(session_mgmt_t), CCAPP_CCPROVIER) != CPR_SUCCESS ) {        CCAPP_DEBUG(DEB_F_PREFIX"failed to send platform_apply_config msg/n", DEB_F_PREFIX_ARGS(PLAT_API, fname));    }}

void conf_roster_free_call_conference (cc_call_conference_Info_t *confInfo){    cc_call_conferenceParticipant_Info_t *participant;    CCAPP_DEBUG(DEB_F_PREFIX"in free_call_confrerence /n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, "CCAPI-CONFPARSE"));    while((participant=(cc_call_conferenceParticipant_Info_t *)                sll_lite_unlink_head(&confInfo->currentParticipantsList)) != NULL)     {        strlib_free(participant->participantName);        strlib_free(participant->endpointUri);        strlib_free(participant->callid);        strlib_free(participant->participantNumber);                participant->participantSecurity        = CC_SECURITY_NONE;         participant->participantStatus          = CCAPI_CONFPARTICIPANT_UNKNOWN;        participant->canRemoveOtherParticipants = FALSE;                cpr_free(participant);        participant = NULL;    }    strlib_free(confInfo->myParticipantId);    conf_roster_init_call_conference(confInfo);}

/** * This function will check if wee need to send refresh PUBLISH.  * If so, it will send refresh PUBLISH * * @param[in] none * * @return none */void publish_handle_periodic_timer_expire (void){    static const char fname[] = "publish_handle_periodic_timer_expire";    int                 delta = 0;    ccsip_publish_cb_t *pcb_p;    pub_req_t           msg;    config_get_value(CFGID_TIMER_SUBSCRIBE_DELTA, &delta,                     sizeof(delta));    pcb_p = (ccsip_publish_cb_t *)sll_next(s_PCB_list, NULL);    while (pcb_p != NULL) {        if (pcb_p->outstanding_trxn == FALSE) {            if (pcb_p->hb.expires >= TMR_PERIODIC_PUBLISH_INTERVAL) {                pcb_p->hb.expires -= TMR_PERIODIC_PUBLISH_INTERVAL;            }            if (pcb_p->hb.expires <= (delta + TMR_PERIODIC_PUBLISH_INTERVAL)) {                CCSIP_DEBUG_TASK(DEB_F_PREFIX"sending REFRESH PUBLISH", DEB_F_PREFIX_ARGS(SIP_PUB, fname));                memset (&msg, 0, sizeof(msg));                /* refresh is triggered by NULL event data and non-zero expires value */                msg.pub_handle = pcb_p->pub_handle;                msg.expires = pcb_p->hb.orig_expiration;                (void)publish_handle_ev_app_publish(&msg);                           }        }        pcb_p = (ccsip_publish_cb_t *)sll_next(s_PCB_list, pcb_p);    }}

/** * gets the device idle status * @param [in] handle - reference to device info  * @returns boolean - idle status */cc_boolean CCAPI_DeviceInfo_isPhoneIdle(cc_deviceinfo_ref_t handle) {    static const char *fname="CCAPI_DeviceInfo_isPhoneIdle";    boolean ret = TRUE;    hashItr_t itr;    session_data_t * session_data;    cc_call_state_t call_state;    hashItrInit(&itr);    while ((session_data = hashItrNext(&itr)) != NULL) {        call_state = session_data->state;        if (call_state != ONHOOK &&            call_state != REMINUSE) {            ret = FALSE;            break;        }    }    CCAPP_DEBUG(DEB_F_PREFIX"idle state=%d session_id=0x%x call-state=%d handle=%x/n",        DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), ret,        (session_data != NULL)? session_data->sess_id: 0,        (session_data != NULL)? session_data->state: 0,         (handle)? handle:0);    return ret;}

/** * gets provisioing for received call logging * @param [in] handle - reference to device info * @returns boolean - false => disabled true => enabled */cc_boolean CCAPI_DeviceInfo_isReceivedCallLoggingEnabled (cc_deviceinfo_ref_t handle){    static const char *fname="CCAPI_DeviceInfo_isReceivedCallLoggingEnabled";    CCAPP_DEBUG(DEB_F_PREFIX" return val %d/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), ccsnap_isReceivedCallLoggingEnabled());    return ccsnap_isReceivedCallLoggingEnabled();}

/** * gets list of handles to features on the device * @param handles[in,out] - array of feature handle to be returned * @param count[in/out] number allocated in array/elements returned * @returns */void CCAPI_DeviceInfo_getFeatures (cc_deviceinfo_ref_t handle, cc_featureinfo_ref_t handles[], cc_uint16_t *count){    static const char *fname="CCAPI_DeviceInfo_getFeatures";    cc_featureinfo_ref_t feature;    int i=0, j=0;    CCAPP_DEBUG(DEB_F_PREFIX"Entering/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));    for (i=1;i<=MAX_CONFIG_LINES && j<*count;i++) {    	feature = (cc_featureinfo_ref_t) ccsnap_getFeatureInfo(i);    	if(feature != NULL){			handles[j++] = feature;    	}    }    *count=j;    CCAPP_DEBUG(DEB_F_PREFIX"Finished (no return) /n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));}

/** * gets list of handles to calls on the device * @param handle - device handle * @param handles - array of call handle to be returned * @param count[in/out] number allocated in array/elements returned * @returns  */void CCAPI_DeviceInfo_getCalls (cc_deviceinfo_ref_t handle, cc_call_handle_t handles[], cc_uint16_t *count) {    static const char *fname="CCAPI_DeviceInfo_getCalls";    hashItr_t itr;    session_data_t *data;    int i=0;    CCAPP_DEBUG(DEB_F_PREFIX"Entering/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));         hashItrInit(&itr);    while ( (data = (session_data_t*)hashItrNext(&itr)) != NULL &&              i<*count ) {        handles[i++] = CREATE_CALL_HANDLE_FROM_SESSION_ID(data->sess_id);    }    *count=i;    CCAPP_DEBUG(DEB_F_PREFIX"Finished (no return) /n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));}

/** * * CCApp Provider main routine. * * @param   arg - CCApp msg queue * * @return  void * * @pre     None */void CCApp_task(void * arg){    static const char fname[] = "CCApp_task";    phn_syshdr_t   *syshdr = NULL;    appListener *listener = NULL;    void * msg;    //initialize the listener list    sll_lite_init(&sll_list);    CCAppInit();    while (1) {        msg = cprGetMessage(ccapp_msgq, TRUE, (void **) &syshdr);        if ( msg) {#if DEBUG            dump_msg("CCAPPTASKDUMPMSG", (unsigned int *)msg, syshdr->Len, syshdr->Cmd);#else            CCAPP_DEBUG(DEB_F_PREFIX"Received Cmd[%d] for app[%d]/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname),                    syshdr->Cmd, syshdr->Usr.UsrInfo);#endif            listener = getCcappListener(syshdr->Usr.UsrInfo);            if (listener != NULL) {                (* ((appListener)(listener)))(msg, syshdr->Cmd);            } else {                CCAPP_DEBUG(DEB_F_PREFIX"Event[%d] doesn't have a dedicated listener./n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname),                        syshdr->Usr.UsrInfo);            }            cprReleaseSysHeader(syshdr);            cprReleaseBuffer(msg);        }    }}

/* *  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 */voidconfig_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);    }}

/* *  Function:    unhideBLFButtonsDisplay * *  Description: unhides BLF states. * *  Parameters: none. * *  Returns:    void */static void unhideBLFButtonsDisplay(){    static const char fname[] = "unhideBLFButtonsDisplay";    int i;    cc_uint32_t lineFeature = 0;    char speedDialNumber[MAX_LINE_NAME_SIZE] = {0};    CCAPP_DEBUG(DEB_F_PREFIX"entering/n",                DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));    displayBLFState = TRUE;    for (i = SPEEDDIAL_START_BUTTON_NUMBER; i <= MAX_REG_LINES; i++) {        // first line must always be a calling line.        config_get_line_value(CFGID_LINE_FEATURE, &lineFeature, sizeof(lineFeature), i);        config_get_line_string(CFGID_LINE_SPEEDDIAL_NUMBER, speedDialNumber, i, sizeof(speedDialNumber));        switch (lineFeature) {        case cfgLineFeatureSpeedDialBLF:            ccsnap_gen_blfFeatureEvent(blfStates[i - 1], i);            break;        default:            break;        }    }}

/* *  Function:    sub_hndlr_NotifyBLFStatus * *  Description: notifies the app of BLF state. * *  Parameters: *      requestId - requestId of the subscription *      status - BLF status *      appId -  button number of the BLF feature key. * *  Returns:    void */void sub_hndlr_NotifyBLFStatus(int requestId, cc_blf_state_t status, int appId){    static const char fname[] = "sub_hndlr_NotifyBLFStatus";    cc_uint32_t lineFeature = 0;    char speedDialNumber[MAX_LINE_NAME_SIZE] = {0};    CCAPP_DEBUG(DEB_F_PREFIX"requestId=%d, status=%d, appId=%d/n",                DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname),                requestId, status, appId);    if (appId == 0) {        // call list BLF.    } else {        config_get_line_value(CFGID_LINE_FEATURE, &lineFeature, sizeof(lineFeature), appId);        config_get_line_string(CFGID_LINE_SPEEDDIAL_NUMBER, speedDialNumber, appId, sizeof(speedDialNumber));        blfStates[appId - 1] = status;        if (displayBLFState == FALSE) {            return; // ignore the notify        }        if (lineFeature == cfgLineFeatureSpeedDialBLF) {            ccsnap_gen_blfFeatureEvent(status, appId);        }    }}

void ccsnap_set_phone_services_provisioning(boolean misd, boolean plcd, boolean rcvd) {   CCAPP_ERROR(DEB_F_PREFIX"missed=%d placed=%d received=%d/n",    		DEB_F_PREFIX_ARGS(SIP_CC_PROV, "ccsnap_set_phone_services_provisioning"), misd, plcd, rcvd);   missed = misd;   placed = plcd;   received = rcvd;}

voiddp_store_digits (line_t line, callid_t call_id, unsigned char digit){    const char fname[] = "dp_store_digits";    short len;    if (g_dp_int.line != line && g_dp_int.call_id != call_id) {        return;    }    if (digit == BKSPACE_KEY) {        return;    }    g_dp_int.line = line;    g_dp_int.call_id = call_id;    len = (short) strlen(g_dp_int.gDialed);    if (len >= MAX_DIALSTRING-1)    {   // safety check to prevent going out of bounds        CCAPP_ERROR(DEB_F_PREFIX"Unexpected dialstring [%s] (length [%d] > max [%d]) received", DEB_F_PREFIX_ARGS(DIALPLAN, fname), g_dp_int.gDialed,            len, MAX_DIALSTRING);        return;        }    g_dp_int.gDialed[len] = digit;    g_dp_int.gDialed[len + 1] = 0;    DPINT_DEBUG(DEB_F_PREFIX"digit = %c, dig_str = %s", DEB_F_PREFIX_ARGS(DIALPLAN, fname), digit,                &g_dp_int.gDialed[0]);}

/* *  Function: dp_reset() * *  Parameters: none * *  Description: Called during soft reset * *  Returns: none */voiddp_reset (void){    DPINT_DEBUG(DEB_F_PREFIX"Reset dp_int module/n", DEB_F_PREFIX_ARGS(DIALPLAN, "dp_reset"));    /* cleanup redial buffer */    memset(g_dp_int.gReDialed, 0, sizeof(g_dp_int.gReDialed));}

/* * This function finds month (0 to 11) from month name * listed above in month_ar[]. This is used to convert the * date header from CCM to derive time/date. */static booleanset_month_from_str (char *month_str){    boolean ret_val = FALSE;    const char * fname = "set_month_from_str";    int i;    if (month_str) {        if (strncmp(month_str, last_month_str, 3) != 0) {            for (i = 0; i < 12; i++) {                if (strncmp(month_str, month_ar[i], 3) == 0) {                    sstrncpy(last_month_str, month_str, sizeof(last_month_str));                    last_month = i;                    ret_val = TRUE;                    break;                }            }        } else {            ret_val = TRUE;        }    } else {        TNP_DEBUG(DEB_F_PREFIX "Input month_str is NULL!!!! /n", DEB_F_PREFIX_ARGS(PLAT_API, fname));    }    return (ret_val);}

/** * Returns the Video  mute state for this call * @return boolean true=muted false=not muted */cc_boolean CCAPI_CallInfo_isVideoMuted (cc_callinfo_ref_t handle){  static const char *fname="CCAPI_CallInfo_isVideoMuted";  session_data_t *data = (session_data_t *)handle;  session_data_t * sess_data_p;  CCAPP_DEBUG(DEB_F_PREFIX"Entering/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));  if ( data != NULL){      sess_data_p = (session_data_t *)findhash(data->sess_id);      if ( sess_data_p != NULL ) {          CCAPP_DEBUG(DEB_F_PREFIX"returned %d/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), sess_data_p->video_mute);          return sess_data_p->video_mute;      }  }  return FALSE;}

/* * sipsdp_write_to_buf() * * This function builds the specified SDP in a text buffer and returns * a pointer to this buffer. * * Returns: pointer to buffer - no errors *          NULL              - errors were encountered while building *                              the SDP. The details of the build failure *                              can be determined by enabling SDP debugs *                              and by examining SDP library error counters. */char *sipsdp_write_to_buf (cc_sdp_t *sdp_info, uint32_t *retbytes){    flex_string fs;	//    uint32_t sdp_len;    sdp_result_e rc;    flex_string_init(&fs);    if (!sdp_info || !sdp_info->src_sdp) {        CCSIP_DEBUG_ERROR(SIP_F_PREFIX"NULL sdp_info or src_sdp/n", __FUNCTION__);        return (NULL);    }    if ((rc = sdp_build(sdp_info->src_sdp, &fs))        != SDP_SUCCESS) {        CCSIP_DEBUG_TASK(DEB_F_PREFIX"sdp_build rc=%s/n", DEB_F_PREFIX_ARGS(SIP_SDP, __FUNCTION__),                         sdp_get_result_name(rc));        flex_string_free(&fs);        *retbytes = 0;        return (NULL);    }    *retbytes = fs.string_length;    /* We are not calling flex_string_free on this, instead returning the buffer     * caller's responsibility to free     */    return fs.buffer;}

/** * get media stream table * @param handle - call handle * @return status MediaStreamTable */MediaStreamTable*  CCAPI_CallInfo_getMediaStreams(cc_callinfo_ref_t handle) {  static const char *fname="CCAPI_CallInfo_getMediaStreams";  session_data_t *data = (session_data_t *)handle;  MediaTrack track;  MediaStreamTable* table = cpr_malloc(sizeof(MediaStreamTable));  if (!table)    return NULL;  CCAPP_DEBUG(DEB_F_PREFIX"Entering", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));  if (data != NULL) {    table->media_stream_id = data->media_stream_id;	table->num_tracks = 1;   /* this will change when we have multiple tracks per stream */	track.media_stream_track_id = data->media_stream_track_id;	track.video = FALSE;	table->track[0] = track;	/*	 * Partly implemented multi-track handling	   cc_table = data->media_tracks;	   table->stream_id = (unsigned int)cc_table->stream_id;	   table->num_tracks = (unsigned int)cc_table->num_tracks;	   track.track_id = cc_table->track[0].ref_id;	   table->track[0] = track;	*/    return table;  }  return table;}

/* *  Function: dp_start_dialing() * *  Parameters: line - line number *                                call_id - call indentification * *  Description: Start dialing and initilize dialing data. * *  Returns: none */static voiddp_init_dialing_data (line_t line, callid_t call_id){    const char fname[] = "dp_init_dialing_data";    DPINT_DEBUG(DEB_F_PREFIX"line=%d call_id=%d/n", DEB_F_PREFIX_ARGS(DIALPLAN, fname), line, call_id);    g_dp_int.call_id = call_id;    g_dp_int.line = line;    g_dp_int.gDialplanDone = FALSE;    g_dp_int.url_dialing = FALSE;    g_dp_int.gTimerType = DP_NONE_TIMER;    memset(g_dp_int.gDialed, 0, sizeof(g_dp_int.gDialed));    /* get offhook timeout */    g_dp_int.offhook_timeout = DIAL_TIMEOUT;    config_get_value(CFGID_OFFHOOK_TO_FIRST_DIGIT_TIMER,                     &g_dp_int.offhook_timeout,                     sizeof(g_dp_int.offhook_timeout));    /* Flush any collected KPML digits on this line */    kpml_flush_quarantine_buffer(line, call_id);}

/* *  Function: dp_check_plar_line * *  Parameters: line * *  Description: Function returns true if the call and line is plar. * *  Returns: TRUE - if plar configured and dialing completed. */booleandp_check_for_plar_line (line_t line){    static char fname[] = "dp_check_for_plar_line";    DialMatchAction action;    char empty_rewrite[MAX_DIALSTRING];    char empty[1];    int timeout = 0;    empty[0] = '/0';            // This empty (i.e. "") pattern.    //Check dialplan to generate empty invite    action = MatchDialTemplate(empty, line, (int *) &timeout,                               empty_rewrite, sizeof(empty_rewrite),                               NULL, NULL);    if (action == DIAL_FULLMATCH) {        /* Plar line is only when timeout == 0 or else it is warm line         */        if (timeout <= 0) {            DPINT_DEBUG(DEB_F_PREFIX"line=%d PLAR line/n", DEB_F_PREFIX_ARGS(DIALPLAN, fname), line);            return (TRUE);        }    }    return (FALSE);}

/* * 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;}

static void fsm_cac_notify_failure (cac_data_t *cac_data){    const char fname[] = "fsm_cac_notify_failure";    cc_setup_t     *msg = (cc_setup_t *) cac_data->msg_ptr;    cc_msgs_t       msg_id   = msg->msg_id;    callid_t        call_id  = msg->call_id;    line_t          line     = msg->line;    int             event_id = msg_id;    cc_srcs_t       src_id  = msg->src_id;    /* Notify UI about the failure */    lsm_ui_display_notify_str_index(STR_INDEX_NO_BAND_WIDTH);    /* Send response from network side regarding the failure */    if (event_id == CC_MSG_SETUP &&            src_id == CC_SRC_SIP) {        DEF_DEBUG(DEB_F_PREFIX"Send CAC failure to SIP %d.",                    DEB_F_PREFIX_ARGS("CAC", fname), cac_data->call_id);        cc_int_release(CC_SRC_GSM, CC_SRC_SIP, call_id, line,                       CC_CAUSE_CONGESTION, NULL, NULL);    } else {        /* If the cac failed, GSM is not spinning yet, so just send the         * information to UI in this case. Other case, where GSM receives event         * will send the information from GSM.         * If the UI is not cleaned up, session infomation is not cleared.         */        ui_call_state(evOnHook, line, call_id, CC_CAUSE_CONGESTION);    }}