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

/** * gets the device name * @returns - a pointer to the device name */cc_deviceinfo_ref_t CCAPI_DeviceInfo_getDeviceHandle () {   static const char *fname="CCAPI_DeviceInfo_getDeviceHandle";   CCAPP_DEBUG(DEB_F_PREFIX"Entering/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));   CCAPP_DEBUG(DEB_F_PREFIX"returned 0 (default)/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));   return 0;}

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

void ccsnap_gen_deviceEvent(ccapi_device_event_e event, cc_device_handle_t handle){    const char* fname = "ccsnap_gen_deviceEvent";    cc_device_info_t *device_info = CCAPI_Device_getDeviceInfo(handle);    if ( device_info != NULL ) {        CCAPP_DEBUG(DEB_F_PREFIX"data->ref_count=%d /n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), device_info->ref_count);        switch (event) {            case CCAPI_DEVICE_EV_NOTIFYPROMPT:              CCAPP_DEBUG(DEB_F_PREFIX"data->not_prompt=%s /n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), device_info->not_prompt);              CCAPP_DEBUG(DEB_F_PREFIX"data->not_prompt_prio=%d /n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), device_info->not_prompt_prio);              CCAPP_DEBUG(DEB_F_PREFIX"data->not_prompt_prog=%d /n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), device_info->not_prompt_prog);              break;            case CCAPI_DEVICE_EV_STATE:              CCAPP_DEBUG(DEB_F_PREFIX"setting property %s to %s/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), "FullyRegistered", ((device_info->ins_state == CC_STATE_INS) ? "1" : "0"));              //intentional follow through to let the debugs get printed.            default:              CCAPP_DEBUG(DEB_F_PREFIX"data->name=%s /n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), device_info->name);              CCAPP_DEBUG(DEB_F_PREFIX"data->mwi_lamp=%d /n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), device_info->mwi_lamp);              CCAPP_DEBUG(DEB_F_PREFIX"data->ins_state=%02X /n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), device_info->ins_state);              CCAPP_DEBUG(DEB_F_PREFIX"data->cucm_mode=%02X /n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), device_info->cucm_mode);              CCAPP_DEBUG(DEB_F_PREFIX"data->ins_cause=%02X /n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), device_info->ins_cause);              break;        }        CCAPI_DeviceListener_onDeviceEvent(event, handle, device_info);    }    CCAPI_Device_releaseDeviceInfo(device_info);}

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

/** * getStream Statistics * @param handle - call handle * @return stream stats */cc_return_t  CCAPI_CallInfo_getStreamStatistics(cc_callinfo_ref_t handle, cc_int32_t stats[], cc_int32_t *count){  static const char *fname="CCAPI_CallInfo_getStreamStatistics";  CCAPP_DEBUG(DEB_F_PREFIX"Entering/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));  CCAPP_DEBUG(DEB_F_PREFIX"returned CC_SUCCESS (default)/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname)); // todo return CC_SUCCESS;}

/*** Get Conference Participants* @param [in] handle - call handle* @param [in/out] participantHandles - array of participant handles to be returned* @param [in/out] count - in:  size of array provided in participantHandles; out:  number of entries populated (up to original value provided)* @return void*/void CCAPI_CallInfo_getConfParticipants (cc_callinfo_ref_t handle, cc_participant_ref_t participantHandles[], int* count){     cc_call_conference_ref_t              callConference   = NULL;    // conference reference (from call info)   cc_call_conference_participant_ref_t  participant      = NULL;    // participant reference   cc_uint16_t                           participantIndex = 0;       // participant index   cc_uint16_t                           nodeCount        = 0;       // linked list node count   CCAPP_DEBUG(DEB_F_PREFIX"Entering:  CCAPI_CallInfo_getConfParticipants/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, "CCAPI-CONF"));   // get conference reference from the call info   callConference = getCallConferenceRef(handle);   if (callConference == NULL)   {      CCAPP_ERROR(DEB_F_PREFIX"Unable to get conference handle/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, "CCAPI-CONF"));      *count = 0;      return;   }   nodeCount = SLL_LITE_NODE_COUNT(&(callConference->currentParticipantsList));   CCAPP_DEBUG(DEB_F_PREFIX"SLL NODE COUNT = [%d]/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, "CCAPI-CONF"), nodeCount);   if (nodeCount <= 0)   {            *count = 0;      return;         }   participant = (cc_call_conference_participant_ref_t)SLL_LITE_LINK_HEAD(&callConference->currentParticipantsList);   while (participant != NULL)   {      if (participantIndex >= *count)      {          CCAPP_ERROR(DEB_F_PREFIX"Not Enough Room Provided To List All Participants.  Listed [%d] of [%d]/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, "CCAPI-CONF"), count, nodeCount);          return;                  }            // add this participant to our list of particpiants      participantHandles[participantIndex] = (participant->callid);                      // step to the next stored participant in the list      participant = (cc_call_conference_participant_ref_t)SLL_LITE_LINK_NEXT_NODE(participant);      participantIndex++;   }   // sanity check   if (participantIndex != nodeCount)   {  // did not find the expected number of participants!       CCAPP_ERROR(DEB_F_PREFIX"Detected mismatch between counted participants [%d] and SLL returned nodecount [%d]/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, "CCAPI-CONF"),                participantIndex, nodeCount);       *count = 0;       return;   }      // return number of participants   *count = nodeCount;   return;}

/** * Get BLF state * @param feature - feature reference handle * @return cc_string_t - handle of the feature created */cc_blf_state_t CCAPI_featureInfo_getBLFState(cc_featureinfo_ref_t feature) {   static const char *fname="CCAPI_featureInfo_getBLFState";   cc_feature_info_t  *info = (cc_feature_info_t  *)feature;   CCAPP_DEBUG(DEB_F_PREFIX"Entering/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));   if ( info != NULL ) {       CCAPP_DEBUG(DEB_F_PREFIX"returned %d/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), info->blf_state);       return info->blf_state;   }   return CC_SIP_BLF_UNKNOWN;}

/* *  Function:    sub_hndlr_start * *  Description: does blf subscriptions upon registration. * *  Parameters: none. * *  Returns:   void */void sub_hndlr_start(){    static const char fname[] = "sub_hndlr_start";    int i;    cc_uint32_t lineFeature = 0;    cc_uint32_t featureOptionMask = 0;    char speedDialNumber[MAX_LINE_NAME_SIZE] = {0};    char primaryLine[MAX_LINE_NAME_SIZE] = {0};    int transId;    CCAPP_DEBUG(DEB_F_PREFIX"entering/n",                DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));    /* let the system know that subscription handler is available. */    isAvailable = TRUE;    /* get primary DN */    config_get_line_string(CFGID_LINE_NAME, primaryLine, 1, sizeof(primaryLine));    /*     * for speeddial/BLF buttons, make presence subscriptions.     */    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);        CCAPP_DEBUG(DEB_F_PREFIX"inst=%d, lineFeature=%d/n",                    DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname),                    i, lineFeature);        switch (lineFeature) {        case cfgLineFeatureSpeedDialBLF:            config_get_line_string(CFGID_LINE_SPEEDDIAL_NUMBER, speedDialNumber, i, sizeof(speedDialNumber));            if (speedDialNumber[0] == 0) {                break;            }            config_get_line_value(CFGID_LINE_FEATURE, &featureOptionMask, sizeof(featureOptionMask), i);            transId = get_new_trans_id();            transactionIds[i - 1] = transId;            CC_BLF_subscribe(transId,                             INT_MAX,                             primaryLine,                             speedDialNumber,                             i,                             featureOptionMask );            break;        default:            break;        }        //Initializes native BLF handler        ccBLFHandlerInitialized();    }}

/** * Call selection status * @param [in] handle - call handle * @return cc_boolean - selection status */cc_boolean  CCAPI_CallInfo_isCallSelected(cc_callinfo_ref_t handle){  static const char *fname="CCAPI_CallInfo_isCallSelected";  session_data_t *data = (session_data_t *)handle;  CCAPP_DEBUG(DEB_F_PREFIX"Entering/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));  if ( data != NULL){     CCAPP_DEBUG(DEB_F_PREFIX"returned %d/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), data->isSelected);     return data->isSelected;  }  return FALSE;}

/** * Get the speeddial Number * @param feature - feature reference handle * @return cc_string_t - speeddial number of the feature created */cc_string_t CCAPI_featureInfo_getSpeedDialNumber(cc_featureinfo_ref_t feature) {   static const char *fname="CCAPI_featureInfo_getSpeedDialNumber";   cc_feature_info_t  *info;   CCAPP_DEBUG(DEB_F_PREFIX"Entering/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));   info = (cc_feature_info_t *) feature;   if ( info != NULL ) {       CCAPP_DEBUG(DEB_F_PREFIX"returned %s/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), info->speedDialNumber);       return info->speedDialNumber;   }   return NULL;}

/** * has capability - is the feature allowed * @param handle - call handle * @param feat_id - feature id * @return boolean - is Allowed */cc_boolean  CCAPI_CallInfo_hasCapability(cc_callinfo_ref_t handle, cc_int32_t feat_id){  static const char *fname="CCAPI_CallInfo_hasCapability";  session_data_t *data = (session_data_t *)handle;  CCAPP_DEBUG(DEB_F_PREFIX"Entering/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));  if ( data != NULL){     CCAPP_DEBUG(DEB_F_PREFIX"feature id:  %d , value returned %d/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname),feat_id,  data->allowed_features[feat_id]);     return data->allowed_features[feat_id];  }  return FALSE;}

/** * get GCID * @param handle - call handle * @return GCID */cc_string_t CCAPI_CallInfo_getGCID(cc_callinfo_ref_t handle){  static const char *fname="CCAPI_CallInfo_getGCID";  session_data_t *data = (session_data_t *)handle;  CCAPP_DEBUG(DEB_F_PREFIX"Entering/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));  if ( data != NULL){     CCAPP_DEBUG(DEB_F_PREFIX"returned %s/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), data->gci);     return data->gci;  }  return strlib_empty();}

/** * get onhook reason * @param handle - call handle * @return onhook reason */cc_int32_t  CCAPI_CallInfo_getOnhookReason(cc_callinfo_ref_t handle){  static const char *fname="CCAPI_CallInfo_getOnhookReason";  session_data_t *data = (session_data_t *)handle;  CCAPP_DEBUG(DEB_F_PREFIX"Entering/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));  if ( data != NULL){     CCAPP_DEBUG(DEB_F_PREFIX"returned %d/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), data->cause);     return data->cause;  }  return CC_CAUSE_NORMAL;}

/** * get call instance number * @param handle - call handle * @return  */cc_int32_t CCAPI_CallInfo_getCallInstance(cc_callinfo_ref_t handle){  static const char *fname="CCAPI_CallInfo_getCallInstance";  session_data_t *data = (session_data_t *)handle;  CCAPP_DEBUG(DEB_F_PREFIX"Entering/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));  if ( data != NULL){     CCAPP_DEBUG(DEB_F_PREFIX"returned %d/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), data->inst);     return data->inst;  }  return 0;}

/** * get Call Type * @param handle - call handle * @return call type */cc_call_type_t CCAPI_CallInfo_getCallType(cc_callinfo_ref_t handle){  static const char *fname="CCAPI_CallInfo_getCallType";  session_data_t *data = (session_data_t *)handle;  CCAPP_DEBUG(DEB_F_PREFIX"Entering", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));  if ( data != NULL){     CCAPP_DEBUG(DEB_F_PREFIX"returned %02X", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), data->type);     return data->type;  }  return 0;}

/** * Get the retrieval prefix * @param feature - feature reference handle * @return cc_string_t - retrieval prefix of the feature created */cc_string_t CCAPI_featureInfo_getRetrievalPrefix(cc_featureinfo_ref_t feature) {   static const char *fname="CCAPI_featureInfo_getRetrievalPrefix";   cc_feature_info_t  *info;   CCAPP_DEBUG(DEB_F_PREFIX"Entering/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));   info = (cc_feature_info_t *) feature;   if ( info != NULL ) {       CCAPP_DEBUG(DEB_F_PREFIX"returned %s/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), info->retrievalPrefix);       return info->retrievalPrefix;   }   return NULL;}

/** * get past redirecting party number * @param handle - call handle * @return last redirecting party number */cc_string_t CCAPI_CallInfo_getLastRedirectingPartyNumber(cc_callinfo_ref_t handle){  static const char *fname="CCAPI_CallInfo_getLastRedirectingPartyNumber";  session_data_t *data = (session_data_t *)handle;  CCAPP_DEBUG(DEB_F_PREFIX"Entering/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));  if ( data != NULL){     CCAPP_DEBUG(DEB_F_PREFIX"returned %s/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), data->last_redir_number);     return data->last_redir_number;  }  return strlib_empty();}

/** * Get the Line Type * @param [in] line - line reference handle * @return cc_uint32_t - line featureID ( Line ) */cc_line_feature_t CCAPI_lineInfo_getLineType(cc_lineinfo_ref_t line){   static const char *fname="CCAPI_lineInfo_getLineType";   cc_line_info_t  *info = (cc_line_info_t *) line;   CCAPP_DEBUG(DEB_F_PREFIX"Entering/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));   if ( info != NULL ) {       CCAPP_DEBUG(DEB_F_PREFIX"returned %d/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), info->line_type);       return info->line_type;   }   return 0;}

/** * Get the feature Label Name * @param feature - feature reference handle * @return cc_string_t - name of the feature created */cc_string_t CCAPI_featureInfo_getDisplayName(cc_featureinfo_ref_t feature) {   static const char *fname="CCAPI_featureInfo_getDisplayName";   cc_feature_info_t  *info;   CCAPP_DEBUG(DEB_F_PREFIX"Entering/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));   info = (cc_feature_info_t *) feature;   if ( info != NULL ) {       CCAPP_DEBUG(DEB_F_PREFIX"returned %s/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), info->name);       return ccsnap_get_line_label(info->button);   }   return NULL;}

/** * get Original Called party number * @param handle - call handle * @return original called party number */cc_string_t CCAPI_CallInfo_getOriginalCalledPartyNumber(cc_callinfo_ref_t handle){  static const char *fname="CCAPI_CallInfo_getOriginalCalledPartyNumber";  session_data_t *data = (session_data_t *)handle;  CCAPP_DEBUG(DEB_F_PREFIX"Entering", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));  if ( data != NULL){     CCAPP_DEBUG(DEB_F_PREFIX"returned %s", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), data->orig_called_number);     return data->orig_called_number;  }  return strlib_empty();}

/** * gets call server name * @param handle - handle of call server * @returns name of the call server * NOTE: The memory for the string will be freed once the device info reference is freed. No need to free this memory explicitly. */cc_string_t CCAPI_DeviceInfo_getCallServerName (cc_callserver_ref_t handle){    static const char *fname="CCAPI_DeviceInfo_getCallServerName";    cc_call_server_t *ref = (cc_call_server_t *) handle;    CCAPP_DEBUG(DEB_F_PREFIX"Entering/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));    if (ref != NULL && ref->name != 0) {        CCAPP_DEBUG(DEB_F_PREFIX"returned %s/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), ref->name);	    return ref->name;    }    return strlib_empty();}

/** * get placed call party name * @param handle - call handle * @return placed party name */cc_string_t CCAPI_CallInfo_getPlacedCallPartyName(cc_callinfo_ref_t handle){  static const char *fname="CCAPI_CallInfo_getPlacedCallPartyName";  session_data_t *data = (session_data_t *)handle;  CCAPP_DEBUG(DEB_F_PREFIX"Entering", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));  if ( data != NULL){     CCAPP_DEBUG(DEB_F_PREFIX"returned %s", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), data->plcd_name);     return data->plcd_name;  }  return strlib_empty();}

/** * Call negotiated video direction * @param [in] handle - call handle * @return cc_sdp_direction_t - video direction */cc_sdp_direction_t  CCAPI_CallInfo_getVideoDirection(cc_callinfo_ref_t handle){  static const char *fname="CCAPI_CallInfo_getVideoDirection";  session_data_t *data = (session_data_t *)handle;  CCAPP_DEBUG(DEB_F_PREFIX"Entering/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));  if ( data != NULL){     CCAPP_DEBUG(DEB_F_PREFIX"returned %d/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), data->vid_dir);     return (data->vid_dir);  }  return CC_SDP_DIRECTION_INACTIVE;}

/** * get call policy * @param handle - call handle * @return call policy */cc_call_policy_t CCAPI_CallInfo_getPolicy(cc_callinfo_ref_t handle){  static const char *fname="CCAPI_CallInfo_getPolicy";  session_data_t *data = (session_data_t *)handle;  CCAPP_DEBUG(DEB_F_PREFIX"Entering/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));  if ( data != NULL){     CCAPP_DEBUG(DEB_F_PREFIX"returned %02X/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), data->policy);     return data->policy;  }  return CC_POLICY_NONE;}

/** * Get the line Name * @param line - line reference handle * @return cc_string_t - handle of the call created */cc_string_t CCAPI_lineInfo_getName(cc_lineinfo_ref_t line) {   static const char *fname="CCAPI_lineInfo_getName";   cc_line_info_t  *info = (cc_line_info_t *) line;   CCAPP_DEBUG(DEB_F_PREFIX"Entering/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));   if ( info != NULL ) {       CCAPP_DEBUG(DEB_F_PREFIX"returned %s/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), info->dn);       return info->dn;   }   return NULL;}

/** * get call security * @param handle - call handle * @return call security status */cc_call_security_t CCAPI_CallInfo_getSecurity(cc_callinfo_ref_t handle){  static const char *fname="CCAPI_CallInfo_getSecurity";  session_data_t *data = (session_data_t *)handle;  CCAPP_DEBUG(DEB_F_PREFIX"Entering", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));  if ( data != NULL){     CCAPP_DEBUG(DEB_F_PREFIX"returned %02X", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), data->security);     return data->security;  }  return CC_SECURITY_NONE;}

/** * get Call state * @param handle - call handle * @return call state */cc_call_state_t CCAPI_CallInfo_getCallState(cc_callinfo_ref_t handle){  static const char *fname="CCAPI_CallInfo_getCallState";  session_data_t *data = (session_data_t *)handle;  CCAPP_DEBUG(DEB_F_PREFIX"Entering/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));    if ( data != NULL){      CCAPP_DEBUG(DEB_F_PREFIX"returned %02X/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), data->state);     return data->state;  }  return ONHOOK;}

/** * get call attributes * @param handle - call handle * @return call attributes */cc_call_attr_t CCAPI_CallInfo_getCallAttr(cc_callinfo_ref_t handle){  static const char *fname="CCAPI_CallInfo_getCallAttr";  session_data_t *data = (session_data_t *)handle;  CCAPP_DEBUG(DEB_F_PREFIX"Entering/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));  if ( data != NULL){     CCAPP_DEBUG(DEB_F_PREFIX"returned %02X/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), data->attr);     return data->attr;  }  return 0;}

/** * Get the call log reference * @param [in] handle - call info handle * @return cc_string_t - INFO body * NOTE: Memory associated with the call log is tied to the cc_callinfo_ref_t handle * this would be freed when the callinfo ref is freed. */cc_calllog_ref_t  CCAPI_CallInfo_getCallLogRef(cc_callinfo_ref_t handle){  static const char *fname="CCAPI_CallInfo_getCallLogRef";  session_data_t *data = (session_data_t *)handle;  CCAPP_DEBUG(DEB_F_PREFIX"Entering/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname));  if ( data != NULL){     CCAPP_DEBUG(DEB_F_PREFIX"returned %x/n", DEB_F_PREFIX_ARGS(SIP_CC_PROV, fname), &data->call_log);     return &data->call_log;  }  return NULL;}