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
 */
void
platform_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. */
void
update_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 void
dp_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
 */
void
platform_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
 */
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);
    }
}