bctbx_list_t* linphone_core_fetch_friends_lists_from_db(LinphoneCore *lc) {
char *buf;
uint64_t begin,end;
bctbx_list_t *result = NULL;
bctbx_list_t *elem = NULL;
if (!lc || lc->friends_db == NULL) {
ms_warning("Either lc is NULL or friends database wasn't initialized with linphone_core_friends_storage_init() yet");
return NULL;
}
buf = sqlite3_mprintf("SELECT * FROM friends_lists ORDER BY id");
begin = ortp_get_cur_time_ms();
linphone_sql_request_friends_list(lc->friends_db, buf, &result);
end = ortp_get_cur_time_ms();
ms_message("%s(): %u results fetched, completed in %i ms",__FUNCTION__, (unsigned int)bctbx_list_size(result), (int)(end-begin));
sqlite3_free(buf);
for(elem = result; elem != NULL; elem = elem->next) {
LinphoneFriendList *lfl = (LinphoneFriendList *)elem->data;
lfl->lc = lc;
lfl->friends = linphone_core_fetch_friends_from_db(lc, lfl);
}
return result;
}
MSList * linphone_core_get_call_history_for_address(LinphoneCore *lc, const LinphoneAddress *addr) {
char *buf;
char *sipAddress;
uint64_t begin,end;
MSList *result = NULL;
if (!lc || lc->logs_db == NULL || addr == NULL) return NULL;
/*since we want to append query parameters depending on arguments given, we use malloc instead of sqlite3_mprintf*/
sipAddress = linphone_address_as_string_uri_only(addr);
buf = sqlite3_mprintf("SELECT * FROM call_history WHERE caller LIKE '%%%q%%' OR callee LIKE '%%%q%%' ORDER BY id DESC", sipAddress, sipAddress); // The '%%%q%%' takes care of the eventual presence of a display name
begin = ortp_get_cur_time_ms();
linphone_sql_request_call_log(lc->logs_db, buf, &result);
end = ortp_get_cur_time_ms();
ms_message("%s(): completed in %i ms",__FUNCTION__, (int)(end-begin));
sqlite3_free(buf);
ms_free(sipAddress);
if (lc->call_logs) {
copy_user_data_from_existing_logs(lc->call_logs, result);
}
return result;
}
bctbx_list_t* linphone_core_fetch_friends_from_db(LinphoneCore *lc, LinphoneFriendList *list) {
char *buf;
uint64_t begin,end;
bctbx_list_t *result = NULL;
bctbx_list_t *elem = NULL;
if (!lc || lc->friends_db == NULL || list == NULL) {
ms_warning("Either lc (or list) is NULL or friends database wasn't initialized with linphone_core_friends_storage_init() yet");
return NULL;
}
linphone_vcard_context_set_user_data(lc->vcard_context, &result);
buf = sqlite3_mprintf("SELECT * FROM friends WHERE friend_list_id = %u ORDER BY id", list->storage_id);
begin = ortp_get_cur_time_ms();
linphone_sql_request_friend(lc->friends_db, buf, lc->vcard_context);
end = ortp_get_cur_time_ms();
ms_message("%s(): %u results fetched, completed in %i ms",__FUNCTION__, (unsigned int)bctbx_list_size(result), (int)(end-begin));
sqlite3_free(buf);
for(elem = result; elem != NULL; elem = elem->next) {
LinphoneFriend *lf = (LinphoneFriend *)elem->data;
lf->lc = lc;
lf->friend_list = list;
}
linphone_vcard_context_set_user_data(lc->vcard_context, NULL);
return result;
}
LinphoneCallLog * linphone_core_get_last_outgoing_call_log(LinphoneCore *lc) {
char *buf;
uint64_t begin,end;
MSList *list = NULL;
LinphoneCallLog* result = NULL;
if (!lc || lc->logs_db == NULL) return NULL;
/*since we want to append query parameters depending on arguments given, we use malloc instead of sqlite3_mprintf*/
buf = sqlite3_mprintf("SELECT * FROM call_history WHERE direction = 0 ORDER BY id DESC LIMIT 1");
begin = ortp_get_cur_time_ms();
linphone_sql_request_call_log(lc->logs_db, buf, &list);
end = ortp_get_cur_time_ms();
ms_message("%s(): completed in %i ms",__FUNCTION__, (int)(end-begin));
sqlite3_free(buf);
if (list) {
result = (LinphoneCallLog*)list->data;
}
if (lc->call_logs && result) {
copy_user_data_from_existing_log(lc->call_logs, result);
}
return result;
}
static int simulate_jitter_by_bit_budget_reduction(OrtpNetworkSimulatorCtx *sim, int budget_increase){
unsigned int r=ortp_random()%1000;
float threshold,score;
int budget_adjust=0;
uint64_t now=ortp_get_cur_time_ms();
if (sim->last_jitter_event==0){
sim->last_jitter_event=ortp_get_cur_time_ms();
}
if (sim->in_jitter_event){
threshold=100;
score=(float)r;
}else{
score=1000.0*(float)r*(now-sim->last_jitter_event)*sim->params.jitter_burst_density*1e-6;
threshold=500;
}
if (score>(int)threshold){
int64_t strength_rand=sim->params.jitter_strength * (float)(ortp_random()%1000);
sim->in_jitter_event=TRUE;
budget_adjust=-((int64_t)budget_increase*strength_rand/1000LL);
/*ortp_message("jitter in progress... bit_budget_adjustement=%i, bit_budget=%i",budget_adjust,sim->bit_budget);*/
}else if (sim->in_jitter_event){
/*ortp_message("jitter ended.");*/
sim->in_jitter_event=FALSE;
sim->last_jitter_event=ortp_get_cur_time_ms();
}
return budget_adjust;
}
MSList *linphone_chat_room_get_history_range(LinphoneChatRoom *cr, int startm, int endm){
LinphoneCore *lc=linphone_chat_room_get_core(cr);
MSList *ret;
char *buf,*buf2;
char *peer;
uint64_t begin,end;
int buf_max_size = 512;
if (lc->db==NULL) return NULL;
peer = linphone_address_as_string_uri_only(linphone_chat_room_get_peer_address(cr));
cr->messages_hist = NULL;
/*since we want to append query parameters depending on arguments given, we use malloc instead of sqlite3_mprintf*/
buf=ms_malloc(buf_max_size);
buf=sqlite3_snprintf(buf_max_size-1,buf,"SELECT * FROM history WHERE remoteContact = %Q ORDER BY id DESC",peer);
if (startm<0) startm=0;
if ((endm>0&&endm>=startm) || (startm == 0 && endm == 0) ){
buf2=ms_strdup_printf("%s LIMIT %i ",buf,endm+1-startm);
ms_free(buf);
buf = buf2;
}else if(startm>0){
ms_message("%s(): end is lower than start (%d < %d). Assuming no end limit.",__FUNCTION__,endm,startm);
buf2=ms_strdup_printf("%s LIMIT -1",buf);
ms_free(buf);
buf = buf2;
}
if (startm>0){
buf2=ms_strdup_printf("%s OFFSET %i ",buf,startm);
ms_free(buf);
buf = buf2;
}
begin=ortp_get_cur_time_ms();
linphone_sql_request_message(lc->db,buf,cr);
end=ortp_get_cur_time_ms();
if (endm+1-startm > 1) {
//display message only if at least 2 messages are loaded
ms_message("%s(): completed in %i ms",__FUNCTION__, (int)(end-begin));
}
ms_free(buf);
ret=cr->messages_hist;
cr->messages_hist=NULL;
ms_free(peer);
return ret;
}
void rtp_session_run_rtcp_send_scheduler(RtpSession *session) {
uint64_t tc = ortp_get_cur_time_ms();
OrtpRtcpSendAlgorithm *sa = &session->rtcp.send_algo;
if (tc >= sa->tn) {
compute_rtcp_interval(session);
sa->tn = sa->tp + sa->T_rr;
if (tc >= sa->tn) {
if (sa->t_rr_last == 0) {
rtp_session_schedule_first_rtcp_send(session);
} else {
if (sa->T_rr_interval != 0) {
sa->T_rr_current_interval = (uint32_t)rtcp_rand((float)sa->T_rr_interval);
} else {
sa->T_rr_current_interval = 0;
}
if (sa->tn >= (sa->t_rr_last + sa->T_rr_current_interval)) {
rtp_session_send_regular_rtcp_packet_and_reschedule(session, tc);
} else if (rtp_session_has_fb_packets_to_send(session) == TRUE) {
rtp_session_send_fb_rtcp_packet_and_reschedule(session);
} else {
rtp_session_reschedule(session, tc);
}
}
}
}
}
bool_t ortp_loss_rate_estimator_process_report_block(OrtpLossRateEstimator *obj, const RtpSession *session, const report_block_t *rb){
int32_t cum_loss=report_block_get_cum_packet_lost(rb);
int32_t extseq=report_block_get_high_ext_seq(rb);
int32_t diff_unique_outgoing=(int32_t)(session->stats.packet_sent-obj->last_packet_sent_count);
int32_t diff_total_outgoing=diff_unique_outgoing+(int32_t)(session->stats.packet_dup_sent-obj->last_dup_packet_sent_count);
int32_t diff;
uint64_t curtime;
bool_t got_value=FALSE;
if (obj->last_ext_seq==-1 || obj->last_estimate_time_ms==(uint64_t)-1){
/*first report cannot be considered, since we don't know the interval it covers*/
obj->last_ext_seq=extseq;
obj->last_cum_loss=cum_loss;
obj->last_estimate_time_ms=ortp_get_cur_time_ms();
return FALSE;
}
diff=extseq-obj->last_ext_seq;
curtime=ortp_get_cur_time_ms();
if (diff<0 || diff>obj->min_packet_count_interval * 100){
ortp_warning("ortp_loss_rate_estimator_process %p: Suspected discontinuity in sequence numbering from %d to %d.", obj, obj->last_ext_seq, extseq);
obj->last_ext_seq=extseq;
obj->last_cum_loss=cum_loss;
obj->last_packet_sent_count=session->stats.packet_sent;
obj->last_dup_packet_sent_count=session->stats.packet_dup_sent;
}else if (diff>obj->min_packet_count_interval && curtime-obj->last_estimate_time_ms>=obj->min_time_ms_interval){
/*we have sufficient interval*/
int32_t new_losses=cum_loss-obj->last_cum_loss;
/*if we are using duplicates, they will not be visible in 'diff' variable.
But since we are the emitter, we can retrieve the total count of packet we
sent and use this value to compute the loss rate instead.*/
obj->loss_rate = 100.f * (1.f - MAX(0, (diff_unique_outgoing - new_losses) * 1.f / diff_total_outgoing));
/*update last values with current*/
got_value=TRUE;
obj->last_estimate_time_ms=curtime;
if (obj->loss_rate>100.f){
ortp_error("ortp_loss_rate_estimator_process %p: Loss rate MUST NOT be greater than 100%%", obj);
}
obj->last_ext_seq=extseq;
obj->last_cum_loss=cum_loss;
obj->last_packet_sent_count=session->stats.packet_sent;
obj->last_dup_packet_sent_count=session->stats.packet_dup_sent;
}
return got_value;
}
static void linphone_migrate_timestamps(sqlite3* db){
int ret;
char* errmsg = NULL;
uint64_t begin=ortp_get_cur_time_ms();
linphone_sql_request(db,"BEGIN TRANSACTION");
ret = sqlite3_exec(db,"SELECT id,time,direction FROM history WHERE time != '-1';", migrate_messages_timestamp, db, &errmsg);
if( ret != SQLITE_OK ){
ms_warning("Error migrating outgoing messages: %s.\n", errmsg);
sqlite3_free(errmsg);
linphone_sql_request(db, "ROLLBACK");
} else {
uint64_t end;
linphone_sql_request(db, "COMMIT");
end=ortp_get_cur_time_ms();
ms_message("Migrated message timestamps to UTC in %lu ms",(unsigned long)(end-begin));
}
}
const MSList *linphone_core_get_call_history(LinphoneCore *lc) {
char *buf;
uint64_t begin,end;
MSList *result = NULL;
if (!lc || lc->logs_db == NULL) return NULL;
buf = sqlite3_mprintf("SELECT * FROM call_history ORDER BY id DESC LIMIT %i", lc->max_call_logs);
begin = ortp_get_cur_time_ms();
linphone_sql_request_call_log(lc->logs_db, buf, &result);
end = ortp_get_cur_time_ms();
ms_message("%s(): completed in %i ms",__FUNCTION__, (int)(end-begin));
sqlite3_free(buf);
if (lc->call_logs) {
copy_user_data_from_existing_logs(lc->call_logs, result);
}
lc->call_logs = ms_list_free_with_data(lc->call_logs, (void (*)(void*))linphone_call_log_unref);
lc->call_logs = result;
return lc->call_logs;
}
static void rtp_session_schedule_first_rtcp_send(RtpSession *session) {
uint64_t tc;
size_t overhead;
size_t report_size;
size_t sdes_size;
size_t xr_size = 0;
OrtpRtcpSendAlgorithm *sa = &session->rtcp.send_algo;
if ((session->rtcp.enabled == FALSE) || (session->target_upload_bandwidth == 0) || (sa->initialized == TRUE))
return;
overhead = (ortp_stream_is_ipv6(&session->rtcp.gs) == TRUE) ? IP6_UDP_OVERHEAD : IP_UDP_OVERHEAD;
sdes_size = (session->full_sdes != NULL) ? msgdsize(session->full_sdes) + sizeof(rtcp_common_header_t) : 0;
switch (session->mode) {
case RTP_SESSION_RECVONLY:
report_size = sizeof(rtcp_rr_t);
break;
case RTP_SESSION_SENDONLY:
report_size = sizeof(rtcp_sr_t) - sizeof(report_block_t);
break;
case RTP_SESSION_SENDRECV:
default:
report_size = sizeof(rtcp_sr_t);
break;
}
if (session->rtcp.xr_conf.enabled == TRUE) {
if (session->rtcp.xr_conf.rcvr_rtt_mode != OrtpRtcpXrRcvrRttNone)
xr_size += sizeof(rtcp_xr_header_t) + sizeof(rtcp_xr_rcvr_rtt_report_block_t);
if (session->rtcp.xr_conf.stat_summary_enabled == TRUE)
xr_size += sizeof(rtcp_xr_header_t) + sizeof(rtcp_xr_stat_summary_report_block_t);
if (session->rtcp.xr_conf.voip_metrics_enabled == TRUE)
xr_size += sizeof(rtcp_xr_header_t) + sizeof(rtcp_xr_voip_metrics_report_block_t);
}
sa->avg_rtcp_size = (float)(overhead + report_size + sdes_size + xr_size);
sa->initialized = TRUE;
tc = ortp_get_cur_time_ms();
compute_rtcp_interval(session);
if (sa->T_rr > 0) sa->tn = tc + sa->T_rr;
sa->tp = tc;
sa->t_rr_last = tc;
sa->Tmin = 0;
}
static bool_t is_fb_packet_to_be_sent_immediately(RtpSession *session) {
uint64_t t0;
if (rtp_session_has_fb_packets_to_send(session) == TRUE)
return FALSE;
t0 = ortp_get_cur_time_ms();
if (t0 > session->rtcp.send_algo.tn)
return FALSE;
if (session->rtcp.send_algo.allow_early == FALSE) {
if ((session->rtcp.send_algo.tn - t0) >= session->rtcp.send_algo.T_max_fb_delay) {
/* Discard message as it is considered that it will not be useful to the sender
at the time it will receive it. */
freemsg(session->rtcp.send_algo.fb_packets);
session->rtcp.send_algo.fb_packets = NULL;
}
return FALSE;
}
return TRUE;
}
