FILE *sip_start(const char *senario, const char* dest_username, const char *passwd, LinphoneAddress* dest_addres) {
#if HAVE_SIPP
char *dest;
char *command;
FILE *file;
if (linphone_address_get_port(dest_addres)>0)
dest = ms_strdup_printf("%s:%i",linphone_address_get_domain(dest_addres),linphone_address_get_port(dest_addres));
else
dest = ms_strdup_printf("%s",linphone_address_get_domain(dest_addres));
//until errors logs are handled correctly and stop breaks output, they will be DISABLED
command = ms_strdup_printf(SIPP_COMMAND" -sf %s -s %s %s -trace_err -trace_msg -rtp_echo -m 1 -d 1000 -ap %s 2>/dev/null",senario
,dest_username
,dest
,(passwd?passwd:"none"));
ms_message("Starting sipp command [%s]",command);
file = popen(command, "r");
ms_free(command);
ms_free(dest);
return file;
#else
return NULL;
#endif
}
LinphoneCall * linphone_call_new_incoming(LinphoneCore *lc, LinphoneAddress *from, LinphoneAddress *to, SalOp *op){
LinphoneCall *call=ms_new0(LinphoneCall,1);
char *from_str;
call->dir=LinphoneCallIncoming;
sal_op_set_user_pointer(op,call);
call->op=op;
call->core=lc;
if (lc->sip_conf.ping_with_options){
/*the following sends an option request back to the caller so that
we get a chance to discover our nat'd address before answering.*/
call->ping_op=sal_op_new(lc->sal);
from_str=linphone_address_as_string(from);
sal_op_set_route(call->ping_op,sal_op_get_network_origin(call->op));
sal_op_set_user_pointer(call->ping_op,call);
sal_ping(call->ping_op,linphone_core_find_best_identity(lc,from,NULL),from_str);
ms_free(from_str);
}
linphone_address_clean(from);
linphone_core_get_local_ip(lc,linphone_address_get_domain(from),call->localip);
linphone_call_init_common(call, from, to);
call->params.has_video=linphone_core_video_enabled(lc);
call->localdesc=create_local_media_description (lc,call);
call->camera_active=call->params.has_video;
if (linphone_core_get_firewall_policy(call->core)==LinphonePolicyUseStun)
linphone_core_run_stun_tests(call->core,call);
discover_mtu(lc,linphone_address_get_domain(from));
return call;
}
LinphoneProxyConfig * linphone_account_creator_configure(const LinphoneAccountCreator *creator) {
LinphoneAuthInfo *info;
LinphoneProxyConfig *cfg = linphone_core_create_proxy_config(creator->core);
char *identity_str = _get_identity(creator);
LinphoneAddress *identity = linphone_address_new(identity_str);
char *route = NULL;
char *domain = NULL;
ms_free(identity_str);
if (creator->display_name) {
linphone_address_set_display_name(identity, creator->display_name);
}
if (creator->route) {
route = ms_strdup_printf("%s;transport=%s", creator->route, linphone_transport_to_string(creator->transport));
}
if (creator->domain) {
domain = ms_strdup_printf("%s;transport=%s", creator->domain, linphone_transport_to_string(creator->transport));
}
linphone_proxy_config_set_identity_address(cfg, identity);
linphone_proxy_config_set_server_addr(cfg, domain);
linphone_proxy_config_set_route(cfg, route);
linphone_proxy_config_enable_publish(cfg, FALSE);
linphone_proxy_config_enable_register(cfg, TRUE);
if (strcmp(creator->domain, "sip.linphone.org") == 0) {
linphone_proxy_config_enable_avpf(cfg, TRUE);
// If account created on sip.linphone.org, we configure linphone to use TLS by default
if (linphone_core_sip_transport_supported(creator->core, LinphoneTransportTls)) {
LinphoneAddress *addr = linphone_address_new(linphone_proxy_config_get_server_addr(cfg));
char *tmp;
linphone_address_set_transport(addr, LinphoneTransportTls);
tmp = linphone_address_as_string(addr);
linphone_proxy_config_set_server_addr(cfg, tmp);
linphone_proxy_config_set_route(cfg, tmp);
ms_free(tmp);
linphone_address_destroy(addr);
}
linphone_core_set_stun_server(creator->core, "stun.linphone.org");
linphone_core_set_firewall_policy(creator->core, LinphonePolicyUseIce);
}
info = linphone_auth_info_new(linphone_address_get_username(identity), // username
NULL, //user id
creator->password, // passwd
creator->password ? NULL : creator->ha1, // ha1
!creator->password && creator->ha1 ? linphone_address_get_domain(identity) : NULL, // realm - assumed to be domain
linphone_address_get_domain(identity) // domain
);
linphone_core_add_auth_info(creator->core, info);
linphone_address_destroy(identity);
if (linphone_core_add_proxy_config(creator->core, cfg) != -1) {
linphone_core_set_default_proxy(creator->core, cfg);
return cfg;
}
linphone_core_remove_auth_info(creator->core, info);
linphone_proxy_config_unref(cfg);
return NULL;
}
/**
* Compare two LinphoneAddress ignoring tags and headers, basically just domain, username, and port.
* Returns TRUE if they are equal.
**/
bool_t linphone_address_weak_equal(const LinphoneAddress *a1, const LinphoneAddress *a2){
const char *u1,*u2;
const char *h1,*h2;
int p1,p2;
u1=linphone_address_get_username(a1);
u2=linphone_address_get_username(a2);
p1=linphone_address_get_port_int(a1);
p2=linphone_address_get_port_int(a2);
h1=linphone_address_get_domain(a1);
h2=linphone_address_get_domain(a2);
return strings_equals(u1,u2) && strings_equals(h1,h2) && p1==p2;
}
static void linphone_interpret_url_test(void)
{
LinphoneCoreVTable v_table;
LinphoneCore* lc;
const char* sips_address = "sips:[email protected]";
LinphoneAddress* address;
LinphoneProxyConfig *proxy_config;
char *tmp;
memset ( &v_table,0,sizeof ( v_table ) );
lc = linphone_core_new ( &v_table,NULL,NULL,NULL );
BC_ASSERT_PTR_NOT_NULL_FATAL ( lc );
proxy_config =linphone_core_create_proxy_config(lc);
linphone_proxy_config_set_identity(proxy_config, "sip:[email protected]");
linphone_proxy_config_enable_register(proxy_config, FALSE);
linphone_proxy_config_set_server_addr(proxy_config,"sip:sip.linphone.org");
linphone_core_add_proxy_config(lc, proxy_config);
linphone_core_set_default_proxy_config(lc,proxy_config);
linphone_proxy_config_unref(proxy_config);
address = linphone_core_interpret_url(lc, sips_address);
BC_ASSERT_PTR_NOT_NULL_FATAL(address);
BC_ASSERT_STRING_EQUAL_FATAL(linphone_address_get_scheme(address), "sips");
BC_ASSERT_STRING_EQUAL_FATAL(linphone_address_get_username(address), "margaux");
BC_ASSERT_STRING_EQUAL_FATAL(linphone_address_get_domain(address), "sip.linphone.org");
linphone_address_destroy(address);
address = linphone_core_interpret_url(lc,"23");
BC_ASSERT_PTR_NOT_NULL(address);
BC_ASSERT_STRING_EQUAL(linphone_address_get_scheme(address), "sip");
BC_ASSERT_STRING_EQUAL(linphone_address_get_username(address), "23");
BC_ASSERT_STRING_EQUAL(linphone_address_get_domain(address), "sip.linphone.org");
linphone_address_destroy(address);
address = linphone_core_interpret_url(lc,"#24");
BC_ASSERT_PTR_NOT_NULL(address);
BC_ASSERT_STRING_EQUAL(linphone_address_get_scheme(address), "sip");
BC_ASSERT_STRING_EQUAL(linphone_address_get_username(address), "#24");
BC_ASSERT_STRING_EQUAL(linphone_address_get_domain(address), "sip.linphone.org");
tmp = linphone_address_as_string(address);
BC_ASSERT_TRUE(strcmp (tmp,"sip:%[email protected]") == 0);
linphone_address_destroy(address);
address = linphone_core_interpret_url(lc,tmp);
BC_ASSERT_STRING_EQUAL(linphone_address_get_scheme(address), "sip");
BC_ASSERT_STRING_EQUAL(linphone_address_get_username(address), "#24");
BC_ASSERT_STRING_EQUAL(linphone_address_get_domain(address), "sip.linphone.org");
linphone_address_destroy(address);
ms_free(tmp);
linphone_core_destroy (lc);
}
LinphoneAddress * linphone_core_manager_resolve(LinphoneCoreManager *mgr, const LinphoneAddress *source) {
struct addrinfo *addrinfo = NULL;
char ipstring [INET6_ADDRSTRLEN];
int err;
int port = linphone_address_get_port(source);
LinphoneAddress * dest;
sal_resolve_a( mgr->lc->sal
,linphone_address_get_domain(source)
,linphone_address_get_port(source)
,AF_INET
,(SalResolverCallback)dest_server_server_resolved
,&addrinfo);
dest=linphone_address_new(NULL);
wait_for(mgr->lc, mgr->lc, (int*)&addrinfo, 1);
err=getnameinfo((struct sockaddr*)addrinfo->ai_addr,addrinfo->ai_addrlen,ipstring,INET6_ADDRSTRLEN,NULL,0,NI_NUMERICHOST);
if (err !=0 ){
ms_error("linphone_core_manager_resolve(): getnameinfo error %s", gai_strerror(err));
}
linphone_address_set_domain(dest, ipstring);
if (port > 0)
linphone_address_set_port(dest, port);
return dest;
}
static char *guess_contact_for_register(LinphoneProxyConfig *obj){
LinphoneAddress *proxy=linphone_address_new(obj->reg_proxy);
char *ret=NULL;
const char *host;
if (proxy==NULL) return NULL;
host=linphone_address_get_domain (proxy);
if (host!=NULL){
LinphoneAddress *contact;
char localip[LINPHONE_IPADDR_SIZE];
LCSipTransports tr;
linphone_core_get_local_ip(obj->lc,host,localip);
contact=linphone_address_new(obj->reg_identity);
linphone_address_set_domain (contact,localip);
linphone_address_set_port_int(contact,linphone_core_get_sip_port(obj->lc));
linphone_address_set_display_name(contact,NULL);
linphone_core_get_sip_transports(obj->lc,&tr);
if (tr.udp_port <= 0) {
if (tr.tcp_port>0) {
sal_address_set_param(contact,"transport","tcp");
} else if (tr.tls_port>0) {
sal_address_set_param(contact,"transport","tls");
}
}
ret=linphone_address_as_string(contact);
linphone_address_destroy(contact);
}
linphone_address_destroy (proxy);
return ret;
}
LinphoneAddress *account_manager_check_account(AccountManager *m, LinphoneProxyConfig *cfg){
LinphoneCore *lc=linphone_proxy_config_get_core(cfg);
const char *identity=linphone_proxy_config_get_identity(cfg);
LinphoneAddress *id_addr=linphone_address_new(identity);
Account *account=account_manager_get_account(m,id_addr);
LinphoneAuthInfo *ai;
char *tmp;
bool_t create_account=FALSE;
if (!account){
account=account_new(id_addr,m->unique_id);
ms_message("No account for %s exists, going to create one.",identity);
create_account=TRUE;
m->accounts=ms_list_append(m->accounts,account);
}
/*modify the username of the identity of the proxy config*/
linphone_address_set_username(id_addr, linphone_address_get_username(account->modified_identity));
tmp=linphone_address_as_string(id_addr);
linphone_proxy_config_set_identity(cfg,tmp);
ms_free(tmp);
if (create_account){
account_create_on_server(account,cfg);
}
ai=linphone_auth_info_new(linphone_address_get_username(account->modified_identity),
NULL,
account->password,NULL,NULL,linphone_address_get_domain(account->modified_identity));
linphone_core_add_auth_info(lc,ai);
linphone_auth_info_destroy(ai);
linphone_address_unref(id_addr);
return account->modified_identity;
}
static int sip_login_do_login(SipSetupContext * ctx, const char *uri, const char *passwd, const char *userid){
LinphoneProxyConfig *cfg=sip_setup_context_get_proxy_config(ctx);
LinphoneCore *lc=linphone_proxy_config_get_core(cfg);
LinphoneAuthInfo *auth;
LinphoneAddress *parsed_uri;
char *tmp;
parsed_uri=linphone_address_new(uri);
if (parsed_uri==NULL){
return -1;
}
if (linphone_address_get_display_name(parsed_uri)!=NULL){
guess_display_name(parsed_uri);
}
tmp=linphone_address_as_string(parsed_uri);
linphone_proxy_config_set_identity(cfg,tmp);
if (passwd ) {
auth=linphone_auth_info_new(linphone_address_get_username(parsed_uri),userid,passwd,NULL,NULL,
linphone_address_get_domain(parsed_uri));
linphone_core_add_auth_info(lc,auth);
}
linphone_proxy_config_enable_register(cfg,TRUE);
linphone_proxy_config_done(cfg);
ms_free(tmp);
linphone_address_destroy(parsed_uri);
ms_message("SipLogin: done");
return 0;
}
/** * Sets the user identity as a SIP address. * * This identity is normally formed with display name, username and domain, such * as: * Alice <sip:[email protected]> * The REGISTER messages will have from and to set to this identity. * **/ int linphone_proxy_config_set_identity(LinphoneProxyConfig *obj, const char *identity){ LinphoneAddress *addr; if (identity!=NULL && strlen(identity)>0){ addr=linphone_address_new(identity); if (!addr || linphone_address_get_username(addr)==NULL){ ms_warning("Invalid sip identity: %s",identity); if (addr) linphone_address_destroy(addr); return -1; }else{ if (obj->reg_identity!=NULL) { ms_free(obj->reg_identity); obj->reg_identity=NULL; } obj->reg_identity=ms_strdup(identity); if (obj->realm){ ms_free(obj->realm); } obj->realm=ms_strdup(linphone_address_get_domain(addr)); linphone_address_destroy(addr); return 0; } } return -1; }
void linphone_core_send_initial_subscribes(LinphoneCore *lc) {
bctbx_list_t *lists = lc->friends_lists;
bool_t proxy_config_for_rls_presence_uri_domain = FALSE;
LinphoneAddress *rls_address = NULL;
const bctbx_list_t *elem;
if (lc->initial_subscribes_sent) return;
lc->initial_subscribes_sent=TRUE;
while (lists) {
LinphoneFriendList *list = (LinphoneFriendList *)lists->data;
if (list->rls_uri != NULL) {
rls_address = linphone_core_create_address(lc, list->rls_uri);
if (rls_address != NULL) {
const char *rls_domain = linphone_address_get_domain(rls_address);
if (rls_domain != NULL) {
for (elem = linphone_core_get_proxy_config_list(lc); elem != NULL; elem = elem->next) {
LinphoneProxyConfig *cfg = (LinphoneProxyConfig *)elem->data;
const char *proxy_domain = linphone_proxy_config_get_domain(cfg);
if (strcmp(rls_domain, proxy_domain) == 0) {
proxy_config_for_rls_presence_uri_domain = TRUE;
break;
}
}
}
linphone_address_unref(rls_address);
}
}
if (proxy_config_for_rls_presence_uri_domain == TRUE) {
ms_message("Presence list activated so do not send initial subscribes it will be done when registered");
} else {
linphone_core_update_friends_subscriptions(lc,NULL,linphone_core_should_subscribe_friends_only_when_registered(lc));
}
lists = bctbx_list_next(lists);
}
}
static void register_with_refresh_base_3(LinphoneCore* lc
, bool_t refresh
,const char* domain
,const char* route
,bool_t late_auth_info
,LCSipTransports transport
,LinphoneRegistrationState expected_final_state) {
int retry=0;
char* addr;
LinphoneProxyConfig* proxy_cfg;
stats* counters;
LinphoneAddress *from;
const char* server_addr;
LinphoneAuthInfo *info;
BC_ASSERT_PTR_NOT_NULL(lc);
if (!lc) return;
counters = get_stats(lc);
reset_counters(counters);
linphone_core_set_sip_transports(lc,&transport);
proxy_cfg = linphone_proxy_config_new();
from = create_linphone_address(domain);
linphone_proxy_config_set_identity(proxy_cfg,addr=linphone_address_as_string(from));
ms_free(addr);
server_addr = linphone_address_get_domain(from);
linphone_proxy_config_enable_register(proxy_cfg,TRUE);
linphone_proxy_config_set_expires(proxy_cfg,1);
if (route) {
linphone_proxy_config_set_route(proxy_cfg,route);
linphone_proxy_config_set_server_addr(proxy_cfg,route);
} else {
linphone_proxy_config_set_server_addr(proxy_cfg,server_addr);
}
linphone_address_destroy(from);
linphone_core_add_proxy_config(lc,proxy_cfg);
linphone_core_set_default_proxy(lc,proxy_cfg);
while (counters->number_of_LinphoneRegistrationOk<1+(refresh!=0)
&& retry++ <(1100 /*only wait 11 s if final state is progress*/+(expected_final_state==LinphoneRegistrationProgress?0:2000))) {
linphone_core_iterate(lc);
if (counters->number_of_auth_info_requested>0 && linphone_proxy_config_get_state(proxy_cfg) == LinphoneRegistrationFailed && late_auth_info) {
if (!linphone_core_get_auth_info_list(lc)) {
BC_ASSERT_EQUAL(linphone_proxy_config_get_error(proxy_cfg),LinphoneReasonUnauthorized, int, "%d");
info=linphone_auth_info_new(test_username,NULL,test_password,NULL,auth_domain,NULL); /*create authentication structure from identity*/
linphone_core_add_auth_info(lc,info); /*add authentication info to LinphoneCore*/
}
}
if (linphone_proxy_config_get_error(proxy_cfg) == LinphoneReasonBadCredentials
|| (counters->number_of_auth_info_requested>2 &&linphone_proxy_config_get_error(proxy_cfg) == LinphoneReasonUnauthorized)) /*no need to continue if auth cannot be found*/
break; /*no need to continue*/
ms_usleep(10000);
}
LinphoneCall * linphone_call_new_outgoing(struct _LinphoneCore *lc, LinphoneAddress *from, LinphoneAddress *to, const LinphoneCallParams *params)
{
LinphoneCall *call=ms_new0(LinphoneCall,1);
call->dir=LinphoneCallOutgoing;
call->op=sal_op_new(lc->sal);
sal_op_set_user_pointer(call->op,call);
call->core=lc;
linphone_core_get_local_ip(lc,linphone_address_get_domain(to),call->localip);
linphone_call_init_common(call,from,to);
call->params=*params;
call->localdesc=create_local_media_description (lc,call);
call->camera_active=params->has_video;
if (linphone_core_get_firewall_policy(call->core)==LinphonePolicyUseStun)
linphone_core_run_stun_tests(call->core,call);
discover_mtu(lc,linphone_address_get_domain (to));
if (params->referer){
sal_call_set_referer (call->op,params->referer->op);
}
return call;
}
static void register_with_refresh_base_2(LinphoneCore* lc, bool_t refresh,const char* domain,const char* route,bool_t late_auth_info,LCSipTransports transport) {
int retry=0;
char* addr;
LinphoneProxyConfig* proxy_cfg;
stats* counters;
LinphoneAddress *from;
const char* server_addr;
LinphoneAuthInfo *info;
CU_ASSERT_PTR_NOT_NULL(lc);
if (!lc) return;
counters = get_stats(lc);
reset_counters(counters);
linphone_core_set_sip_transports(lc,&transport);
proxy_cfg = linphone_proxy_config_new();
from = create_linphone_address(domain);
linphone_proxy_config_set_identity(proxy_cfg,addr=linphone_address_as_string(from));
ms_free(addr);
server_addr = linphone_address_get_domain(from);
linphone_proxy_config_enable_register(proxy_cfg,TRUE);
linphone_proxy_config_expires(proxy_cfg,1);
if (route) {
linphone_proxy_config_set_route(proxy_cfg,route);
linphone_proxy_config_set_server_addr(proxy_cfg,route);
} else {
linphone_proxy_config_set_server_addr(proxy_cfg,server_addr);
}
linphone_address_destroy(from);
linphone_core_add_proxy_config(lc,proxy_cfg);
linphone_core_set_default_proxy(lc,proxy_cfg);
while (counters->number_of_LinphoneRegistrationOk<1+(refresh!=0) && retry++ <310) {
linphone_core_iterate(lc);
if (counters->number_of_auth_info_requested>0 && late_auth_info) {
info=linphone_auth_info_new(test_username,NULL,test_password,NULL,auth_domain); /*create authentication structure from identity*/
linphone_core_add_auth_info(lc,info); /*add authentication info to LinphoneCore*/
}
ms_usleep(100000);
}
CU_ASSERT_TRUE(linphone_proxy_config_is_registered(proxy_cfg));
CU_ASSERT_EQUAL(counters->number_of_LinphoneRegistrationNone,0);
CU_ASSERT_EQUAL(counters->number_of_LinphoneRegistrationProgress,1);
CU_ASSERT_EQUAL(counters->number_of_LinphoneRegistrationOk,1+(refresh!=0));
CU_ASSERT_EQUAL(counters->number_of_LinphoneRegistrationFailed,late_auth_info?1:0);
CU_ASSERT_EQUAL(counters->number_of_LinphoneRegistrationCleared,0);
}
LinphoneAddress * create_linphone_address(const char * domain) {
LinphoneAddress *addr = linphone_address_new(NULL);
CU_ASSERT_PTR_NOT_NULL_FATAL(addr);
linphone_address_set_username(addr,test_username);
CU_ASSERT_STRING_EQUAL(test_username,linphone_address_get_username(addr));
if (!domain) domain= test_route;
linphone_address_set_domain(addr,domain);
CU_ASSERT_STRING_EQUAL(domain,linphone_address_get_domain(addr));
linphone_address_set_display_name(addr, NULL);
linphone_address_set_display_name(addr, "Mr Tester");
CU_ASSERT_STRING_EQUAL("Mr Tester",linphone_address_get_display_name(addr));
return addr;
}
int sip_setup_context_login_account(SipSetupContext * ctx, const char *uri, const char *passwd, const char *userid){
LinphoneAddress *from=linphone_address_new(uri);
if (from==NULL) {
ms_warning("Fail to parse %s",uri);
return -1;
}
strncpy(ctx->domain,linphone_address_get_domain(from),sizeof(ctx->domain));
strncpy(ctx->username,linphone_address_get_username(from),sizeof(ctx->username));
linphone_address_destroy(from);
if (ctx->funcs->login_account)
return ctx->funcs->login_account(ctx,uri,passwd,userid);
return -1;
}
void linphone_gtk_call_log_update(GtkWidget *w){
GtkTreeView *v=GTK_TREE_VIEW(linphone_gtk_get_widget(w,"logs_view"));
GtkListStore *store;
const MSList *logs;
store=(GtkListStore*)gtk_tree_view_get_model(v);
if (store==NULL){
store=gtk_list_store_new(3,G_TYPE_STRING,G_TYPE_STRING, G_TYPE_POINTER);
gtk_tree_view_set_model(v,GTK_TREE_MODEL(store));
g_object_unref(G_OBJECT(store));
}
gtk_list_store_clear (store);
for (logs=linphone_core_get_call_logs(linphone_gtk_get_core());logs!=NULL;logs=logs->next){
LinphoneCallLog *cl=(LinphoneCallLog*)logs->data;
GtkTreeIter iter;
LinphoneAddress *la=cl->dir==LinphoneCallIncoming ? cl->from : cl->to;
char *addr= linphone_address_as_string_uri_only (la);
const char *display;
gchar *logtxt;
gchar quality[20];
display=linphone_address_get_display_name (la);
if (display==NULL){
display=linphone_address_get_username (la);
if (display==NULL)
display=linphone_address_get_domain (la);
}
if (cl->quality!=-1){
snprintf(quality,sizeof(quality),"%.1f",cl->quality);
}
logtxt=g_markup_printf_escaped("<big><b>%s</b></big>\t<small><i>%s</i>\t<i>Quality: %s</i></small>\n"
"%s\t%i minutes %i seconds\t",display, addr, cl->quality!=-1 ? quality : _("n/a"),
cl->start_date,
cl->duration/60,cl->duration%60);
gtk_list_store_append (store,&iter);
gtk_list_store_set (store,&iter,
0, cl->dir==LinphoneCallOutgoing ? GTK_STOCK_GO_UP : GTK_STOCK_GO_DOWN,
1, logtxt,2,la,-1);
ms_free(addr);
g_free(logtxt);
}
}
bool SipClient::setIdentity(const QString &identity, const QString &password)
{
m_identity = identity;
m_password = password;
/* Create Proxy Config*/
m_proxyCfg = linphone_core_create_proxy_config(lc);
/*parse identity*/
LinphoneAddress *from = linphone_address_new(identity.toLatin1().data());
if (from == NULL) {
qDebug() << __PRETTY_FUNCTION__ << " " << identity << " is not a valid sip uri, must be like sip:[email protected]";
return false;
}
m_authInfo = linphone_auth_info_new(linphone_address_get_username(from), NULL, password.toLatin1().data(), NULL, NULL, NULL);
linphone_core_add_auth_info(lc, m_authInfo);
/* Configure proxy entries */
/* Set identity with user name and domain*/
linphone_proxy_config_set_identity(m_proxyCfg, identity.toLatin1().data());
/* Extract domain address from identity*/
const char *server_addr = linphone_address_get_domain(from);
/* We assume domain = proxy server address*/
linphone_proxy_config_set_server_addr(m_proxyCfg, server_addr);
/* Activate registration for this proxy config*/
linphone_proxy_config_enable_register(m_proxyCfg, TRUE);
/* Release resource*/
linphone_address_destroy(from);
/* Add proxy config to linphone core*/
linphone_core_add_proxy_config(lc, m_proxyCfg);
/* Set to default proxy*/
linphone_core_set_default_proxy(lc, m_proxyCfg);
return true;
}
/*the purpose of this test is to check that will not block the proxy config during SSL handshake for entire life in case of mistaken configuration*/
static void tls_with_non_tls_server(){
LinphoneCoreManager *mgr;
LinphoneProxyConfig* proxy_cfg;
LinphoneAddress* addr;
char tmp[256];
LinphoneCore *lc;
mgr=linphone_core_manager_new2( "marie_rc", 0);
lc=mgr->lc;
sal_set_transport_timeout(lc->sal,3000);
linphone_core_get_default_proxy(lc,&proxy_cfg);
linphone_proxy_config_edit(proxy_cfg);
addr=linphone_address_new(linphone_proxy_config_get_addr(proxy_cfg));
snprintf(tmp,sizeof(tmp),"sip:%s:%i;transport=tls" ,linphone_address_get_domain(addr)
,(linphone_address_get_port(addr)>0?linphone_address_get_port(addr):5060));
linphone_proxy_config_set_server_addr(proxy_cfg,tmp);
linphone_proxy_config_done(proxy_cfg);
linphone_address_destroy(addr);
CU_ASSERT_TRUE(wait_for_until(lc,lc,&mgr->stat.number_of_LinphoneRegistrationFailed,1,5000));
linphone_core_manager_destroy(mgr);
}
static void tls_with_non_tls_server(){
LinphoneCoreManager *mgr;
LinphoneProxyConfig* proxy_cfg;
LinphoneAddress* addr;
char tmp[256];
LinphoneCore *lc;
mgr=linphone_core_manager_new2( "marie_rc", 0);
lc=mgr->lc;
linphone_core_get_default_proxy(lc,&proxy_cfg);
linphone_proxy_config_edit(proxy_cfg);
addr=linphone_address_new(linphone_proxy_config_get_addr(proxy_cfg));
snprintf(tmp,sizeof(tmp),"sip:%s:%i;transport=tls" ,linphone_address_get_domain(addr)
,(linphone_address_get_port_int(addr)>0?linphone_address_get_port_int(addr):5060));
linphone_proxy_config_set_server_addr(proxy_cfg,tmp);
linphone_proxy_config_done(proxy_cfg);
linphone_address_destroy(addr);
/* FIXME http://git.linphone.org/mantis/view.php?id=758
CU_ASSERT_TRUE(wait_for(lc,lc,&mgr->stat.number_of_LinphoneRegistrationFailed,1));
*/
linphone_core_manager_destroy(mgr);
}
static void linphone_interpret_url_test()
{
LinphoneCoreVTable v_table;
LinphoneCore* lc;
const char* sips_address = "sips:[email protected]";
LinphoneAddress* address;
memset ( &v_table,0,sizeof ( v_table ) );
lc = linphone_core_new ( &v_table,NULL,NULL,NULL );
BC_ASSERT_PTR_NOT_NULL_FATAL ( lc );
address = linphone_core_interpret_url(lc, sips_address);
BC_ASSERT_PTR_NOT_NULL_FATAL(address);
BC_ASSERT_STRING_EQUAL_FATAL(linphone_address_get_scheme(address), "sips");
BC_ASSERT_STRING_EQUAL_FATAL(linphone_address_get_username(address), "margaux");
BC_ASSERT_STRING_EQUAL_FATAL(linphone_address_get_domain(address), "sip.linphone.org");
linphone_address_destroy(address);
linphone_core_destroy ( lc );
}
LinphoneProxyConfig * linphone_account_creator_configure(const LinphoneAccountCreator *creator) {
LinphoneAddress *identity;
LinphoneAuthInfo *info;
LinphoneProxyConfig *cfg = linphone_core_create_proxy_config(creator->core);
char *identity_str = ms_strdup_printf("sip:%s@%s", creator->username, creator->domain);
linphone_proxy_config_set_identity(cfg, identity_str);
linphone_proxy_config_set_server_addr(cfg, creator->domain);
linphone_proxy_config_set_route(cfg, creator->route);
linphone_proxy_config_enable_publish(cfg, FALSE);
linphone_proxy_config_enable_register(cfg, TRUE);
ms_free(identity_str);
if (strcmp(creator->domain, "sip.linphone.org") == 0) {
linphone_proxy_config_enable_avpf(cfg, TRUE);
// If account created on sip.linphone.org, we configure linphone to use TLS by default
if (linphone_core_sip_transport_supported(creator->core, LinphoneTransportTls)) {
LinphoneAddress *addr = linphone_address_new(linphone_proxy_config_get_server_addr(cfg));
char *tmp;
linphone_address_set_transport(addr, LinphoneTransportTls);
tmp = linphone_address_as_string(addr);
linphone_proxy_config_set_server_addr(cfg, tmp);
linphone_proxy_config_set_route(cfg, tmp);
ms_free(tmp);
linphone_address_destroy(addr);
}
linphone_core_set_stun_server(creator->core, "stun.linphone.org");
linphone_core_set_firewall_policy(creator->core, LinphonePolicyUseIce);
}
identity = linphone_address_new(linphone_proxy_config_get_identity(cfg));
info = linphone_auth_info_new(linphone_address_get_username(identity), NULL, creator->password, NULL, NULL, linphone_address_get_domain(identity));
linphone_core_add_auth_info(creator->core, info);
linphone_address_destroy(identity);
if (linphone_core_add_proxy_config(creator->core, cfg) != -1) {
linphone_core_set_default_proxy(creator->core, cfg);
return cfg;
}
linphone_core_remove_auth_info(creator->core, info);
linphone_proxy_config_unref(cfg);
return NULL;
}
int main(int argc, char *argv[]){
LinphoneCoreVTable vtable={0};
MyAppData *data=ms_new0(MyAppData,1);
char* identity=NULL;
char* password=NULL;
int i;
LinphoneProxyConfig* proxy_cfg;
LinphoneAddress *from;
LinphoneAuthInfo *info;
const char* server_addr;
/* takes sip uri identity from the command line arguments */
if (argc>1){
identity=argv[1];
}
/* takes password from the command line arguments */
if (argc>2){
password=argv[2];
}
signal(SIGINT,stop);
#ifdef DEBUG
linphone_core_enable_logs(NULL); /*enable liblinphone logs.*/
#endif
/*
Fill the LinphoneCoreVTable with application callbacks.
All are optional. Here we only use the registration_state_changed callbacks
in order to get notifications about the progress of the registration.
*/
vtable.registration_state_changed=registration_state_changed;
vtable.subscription_state_changed=subscription_state_changed;
/*
Instanciate a LinphoneCore object given the LinphoneCoreVTable
*/
lc=linphone_core_new(&vtable,NULL,NULL,data);
/*create proxy config*/
proxy_cfg = linphone_proxy_config_new();
/*parse identity*/
from = linphone_address_new(identity);
if (from==NULL){
printf("%s not a valid sip uri, must be like sip:[email protected] \n",identity);
goto end;
}
if (password!=NULL){
info=linphone_auth_info_new(linphone_address_get_username(from),NULL,password,NULL,NULL,NULL); /*create authentication structure from identity*/
linphone_core_add_auth_info(lc,info); /*add authentication info to LinphoneCore*/
}
// configure proxy entries
linphone_proxy_config_set_identity(proxy_cfg,identity); /*set identity with user name and domain*/
server_addr = linphone_address_get_domain(from); /*extract domain address from identity*/
linphone_proxy_config_set_server_addr(proxy_cfg,server_addr); /* we assume domain = proxy server address*/
linphone_proxy_config_enable_register(proxy_cfg,TRUE); /*activate registration for this proxy config*/
linphone_address_destroy(from); /*release resource*/
linphone_core_add_proxy_config(lc,proxy_cfg); /*add proxy config to linphone core*/
linphone_core_set_default_proxy(lc,proxy_cfg); /*set to default proxy*/
i=0;
/* main loop for receiving notifications and doing background linphonecore work: */
while(running){
linphone_core_iterate(lc); /* first iterate initiates registration */
ms_usleep(50000);
++i;
if (data->ev && i%100==0){
LinphoneContentPrivate content;
content.type="application";
content.subtype="goodxml";
content.data="really cool";
content.size=strlen((const char*)content.data);
linphone_event_notify(data->ev,LINPHONE_CONTENT(&content));
}
}
linphone_core_get_default_proxy(lc,&proxy_cfg); /* get default proxy config*/
linphone_proxy_config_edit(proxy_cfg); /*start editing proxy configuration*/
linphone_proxy_config_enable_register(proxy_cfg,FALSE); /*de-activate registration for this proxy config*/
linphone_proxy_config_done(proxy_cfg); /*initiate REGISTER with expire = 0*/
if (data->ev){
linphone_event_terminate(data->ev);
}
while(linphone_proxy_config_get_state(proxy_cfg) != LinphoneRegistrationCleared){
linphone_core_iterate(lc); /*to make sure we receive call backs before shutting down*/
ms_usleep(50000);
}
end:
printf("Shutting down...\n");
linphone_core_destroy(lc);
ms_free(data);
printf("Exited\n");
return 0;
}
int main(int argc, char *argv[]){
LinphoneCoreVTable vtable={0};
LinphoneCore *lc;
LinphoneVideoPolicy policy;
int i;
LinphoneAddress *addr=NULL;
LCSipTransports tp;
char * tmp = NULL;
LpConfig * lp_config = lp_config_new(NULL);
int max_call_duration=3600;
static const char *media_file = NULL;
policy.automatically_accept=TRUE;
signal(SIGINT,stop);
#ifndef _WIN32
signal(SIGUSR1,stats);
signal(SIGUSR2,dump_call_logs);
#endif
for(i = 1; i < argc; ++i) {
if (strcmp(argv[i], "--verbose") == 0) {
linphone_core_set_log_level_mask(ORTP_MESSAGE|ORTP_WARNING|ORTP_ERROR|ORTP_FATAL);
} else if (strcmp(argv[i], "--max-call-duration") == 0){
max_call_duration = atoi(argv[++i]);
} else if (strcmp(argv[i], "--listening-uri") == 0){
addr = linphone_address_new(argv[++i]);
if (!addr) {
printf("Error, bad sip uri");
helper(argv[0]);
}
/* switch(linphone_address_get_transport(addr)) {
case LinphoneTransportUdp:
case LinphoneTransportTcp:
break;
default:
ms_error("Error, bad sip uri [%s] transport, should be udp | tcp",argv[i]);
helper();
break;
}*/
} else if (strcmp(argv[i], "--media-file") == 0){
i++;
if (i<argc){
media_file = argv[i];
}else helper(argv[0]);
} else {
helper(argv[0]);
}
}
if (!addr) {
addr = linphone_address_new("sip:[email protected]:5060");
}
lp_config_set_string(lp_config,"sip","bind_address",linphone_address_get_domain(addr));
lp_config_set_string(lp_config,"rtp","bind_address",linphone_address_get_domain(addr));
lp_config_set_int(lp_config,"misc","history_max_size",100000);
vtable.call_state_changed=call_state_changed;
lc=linphone_core_new_with_config(&vtable,lp_config,NULL);
linphone_core_enable_video_capture(lc,TRUE);
linphone_core_enable_video_display(lc,FALSE);
linphone_core_set_video_policy(lc,&policy);
linphone_core_enable_keep_alive(lc,FALSE);
/*instead of using sound capture card, a file is played to the calling party*/
linphone_core_set_use_files(lc,TRUE);
linphone_core_enable_echo_cancellation(lc, FALSE); /*no need for local echo cancellation when playing files*/
if (!media_file){
linphone_core_set_play_file(lc,PACKAGE_DATA_DIR "/sounds/linphone/hello16000.wav");
linphone_core_set_preferred_framerate(lc,5);
}else{
PayloadType *pt = linphone_core_find_payload_type(lc, "opus", 48000, -1);
/*if opus is present, give it a bitrate for good quality with music, and stereo enabled*/
if (pt){
linphone_core_set_payload_type_bitrate(lc, pt, 150);
payload_type_set_send_fmtp(pt, "stereo=1");
payload_type_set_recv_fmtp(pt, "stereo=1");
}
linphone_core_set_play_file(lc, media_file);
linphone_core_set_preferred_video_size_by_name(lc, "720p");
}
{
MSWebCamDesc *desc = ms_mire_webcam_desc_get();
if (desc){
ms_web_cam_manager_add_cam(ms_factory_get_web_cam_manager(linphone_core_get_ms_factory(lc)),ms_web_cam_new(desc));
linphone_core_set_video_device(lc,"Mire: Mire (synthetic moving picture)");
}
}
memset(&tp,0,sizeof(LCSipTransports));
tp.udp_port = linphone_address_get_port(addr);
tp.tcp_port = linphone_address_get_port(addr);
linphone_core_set_sip_transports(lc,&tp);
linphone_core_set_audio_port_range(lc,1024,65000);
linphone_core_set_video_port_range(lc,1024,65000);
linphone_core_set_primary_contact(lc,tmp=linphone_address_as_string(addr));
ms_free(tmp);
/* main loop for receiving notifications and doing background linphonecore work: */
while(running){
const bctbx_list_t * iterator;
linphone_core_iterate(lc);
ms_usleep(50000);
if (print_stats) {
ms_message("*********************************");
ms_message("*Current number of calls [%10u] *", (unsigned int)bctbx_list_size(linphone_core_get_calls(lc)));
ms_message("*Number of calls until now [%10u] *", (unsigned int)bctbx_list_size(linphone_core_get_call_logs(lc)));
ms_message("*********************************");
print_stats=FALSE;
}
if (dump_stats) {
ms_message("*********************************");
for (iterator=linphone_core_get_call_logs(lc);iterator!=NULL;iterator=iterator->next) {
LinphoneCallLog *call_log=(LinphoneCallLog *)iterator->data;
char * tmp_str = linphone_call_log_to_str(call_log);
ms_message("\n%s",tmp_str);
ms_free(tmp_str);
}
dump_stats=FALSE;
ms_message("*********************************");
}
for (iterator=linphone_core_get_calls(lc);iterator!=NULL;iterator=iterator->next) {
LinphoneCall *call=(LinphoneCall *)iterator->data;
if (linphone_call_get_duration(call) > max_call_duration) {
ms_message("Terminating call [%p] after [%i] s",call,linphone_call_get_duration(call));
linphone_core_terminate_call(lc,call);
break;
}
}
}
ms_message("Shutting down...\n");
linphone_core_destroy(lc);
ms_message("Exited\n");
return 0;
}
StringPtr AddressAPI::getDomain() const {
CORE_MUTEX
FBLOG_DEBUG("AddressAPI::getDomain", "this=" << this);
return CHARPTR_TO_STRING(linphone_address_get_domain(mAddress));
}
static char* get_public_contact_ip(LinphoneCore* lc) {
const LinphoneAddress * contact = linphone_proxy_config_get_contact(linphone_core_get_default_proxy_config(lc));
BC_ASSERT_PTR_NOT_NULL(contact);
return ms_strdup(linphone_address_get_domain(contact));
}
static void call_with_tunnel_base(LinphoneTunnelMode tunnel_mode, bool_t with_sip, LinphoneMediaEncryption encryption, bool_t with_video_and_ice) {
if (linphone_core_tunnel_available()){
LinphoneCoreManager *pauline = linphone_core_manager_new( "pauline_rc");
LinphoneCoreManager *marie = linphone_core_manager_new( "marie_rc");
LinphoneCall *pauline_call, *marie_call;
LinphoneProxyConfig *proxy = linphone_core_get_default_proxy_config(pauline->lc);
LinphoneAddress *server_addr = linphone_address_new(linphone_proxy_config_get_server_addr(proxy));
LinphoneAddress *route = linphone_address_new(linphone_proxy_config_get_route(proxy));
const char * tunnel_ip = get_ip_from_hostname("tunnel.linphone.org");
char *public_ip, *public_ip2=NULL;
BC_ASSERT_TRUE(wait_for(pauline->lc,NULL,&pauline->stat.number_of_LinphoneRegistrationOk,1));
public_ip = get_public_contact_ip(pauline->lc);
BC_ASSERT_STRING_NOT_EQUAL(public_ip, tunnel_ip);
linphone_core_set_media_encryption(pauline->lc, encryption);
if (with_video_and_ice){
/*we want to test that tunnel is able to work with long SIP message, above mtu.
* Enable ICE and many codec to make the SIP message bigger*/
linphone_core_set_firewall_policy(marie->lc, LinphonePolicyUseIce);
linphone_core_set_firewall_policy(pauline->lc, LinphonePolicyUseIce);
linphone_core_enable_payload_type(pauline->lc,
linphone_core_find_payload_type(pauline->lc, "speex", 32000, 1), TRUE);
linphone_core_enable_payload_type(pauline->lc,
linphone_core_find_payload_type(pauline->lc, "speex", 16000, 1), TRUE);
linphone_core_enable_payload_type(pauline->lc,
linphone_core_find_payload_type(pauline->lc, "G722", 8000, 1), TRUE);
linphone_core_enable_payload_type(marie->lc,
linphone_core_find_payload_type(marie->lc, "speex", 32000, 1), TRUE);
linphone_core_enable_payload_type(marie->lc,
linphone_core_find_payload_type(marie->lc, "speex", 16000, 1), TRUE);
linphone_core_enable_payload_type(marie->lc,
linphone_core_find_payload_type(marie->lc, "G722", 8000, 1), TRUE);
}
if (tunnel_mode != LinphoneTunnelModeDisable){
LinphoneTunnel *tunnel = linphone_core_get_tunnel(pauline->lc);
LinphoneTunnelConfig *config = linphone_tunnel_config_new();
linphone_tunnel_config_set_host(config, "tunnel.linphone.org");
linphone_tunnel_config_set_port(config, 443);
linphone_tunnel_config_set_remote_udp_mirror_port(config, 12345);
linphone_tunnel_add_server(tunnel, config);
linphone_tunnel_set_mode(tunnel, tunnel_mode);
linphone_tunnel_enable_sip(tunnel, with_sip);
/*
* Enabling the tunnel with sip cause another REGISTER to be made.
* In automatic mode, the udp test should conclude (assuming we have a normal network), that no
* tunnel is needed. Thus the number of registrations should stay to 1.
* The library is missing a notification of "tunnel connectivity test finished" to enable the
* full testing of the automatic mode.
*/
if (tunnel_mode == LinphoneTunnelModeEnable && with_sip) {
BC_ASSERT_TRUE(wait_for(pauline->lc,NULL,&pauline->stat.number_of_LinphoneRegistrationOk,2));
/* Ensure that we did use the tunnel. If so, we should see contact changed from:
Contact: <sip:[email protected]>;.[...]
To:
Contact: <sip:[email protected]:43867>;[....] (91.121.209.194 must be tunnel.liphone.org)
*/
ms_free(public_ip);
public_ip = get_public_contact_ip(pauline->lc);
BC_ASSERT_STRING_EQUAL(public_ip, tunnel_ip);
} else {
public_ip2 = get_public_contact_ip(pauline->lc);
BC_ASSERT_STRING_EQUAL(public_ip, public_ip2);
}
}
BC_ASSERT_TRUE(call(pauline,marie));
pauline_call=linphone_core_get_current_call(pauline->lc);
BC_ASSERT_PTR_NOT_NULL(pauline_call);
if (pauline_call!=NULL){
BC_ASSERT_PTR_EQUAL(linphone_call_params_get_media_encryption(linphone_call_get_current_params(pauline_call)),
encryption);
}
if (tunnel_mode == LinphoneTunnelModeEnable && with_sip){
/* make sure the call from pauline arrived from the tunnel by checking the contact address*/
marie_call = linphone_core_get_current_call(marie->lc);
BC_ASSERT_PTR_NOT_NULL(marie_call);
if (marie_call){
const char *remote_contact = linphone_call_get_remote_contact(marie_call);
BC_ASSERT_PTR_NOT_NULL(remote_contact);
if (remote_contact){
LinphoneAddress *tmp = linphone_address_new(remote_contact);
BC_ASSERT_PTR_NOT_NULL(tmp);
if (tmp){
BC_ASSERT_STRING_EQUAL(linphone_address_get_domain(tmp), tunnel_ip);
linphone_address_destroy(tmp);
}
}
}
}
#ifdef VIDEO_ENABLED
if (with_video_and_ice){
BC_ASSERT_TRUE(add_video(pauline, marie, TRUE));
}
#endif
end_call(pauline,marie);
ms_free(public_ip);
if(public_ip2 != NULL) ms_free(public_ip2);
linphone_address_destroy(server_addr);
linphone_address_destroy(route);
linphone_core_manager_destroy(pauline);
linphone_core_manager_destroy(marie);
}else{
ms_warning("Could not test %s because tunnel functionality is not available",__FUNCTION__);
}
}
void account_create_on_server(Account *account, const LinphoneProxyConfig *refcfg){
LinphoneCoreVTable vtable={0};
LinphoneCore *lc;
LinphoneAddress *tmp_identity=linphone_address_clone(account->modified_identity);
LinphoneProxyConfig *cfg;
LinphoneAuthInfo *ai;
char *tmp;
LinphoneAddress *server_addr;
LCSipTransports tr;
vtable.registration_state_changed=account_created_on_server_cb;
vtable.auth_info_requested=account_created_auth_requested_cb;
lc=configure_lc_from(&vtable,bc_tester_read_dir_prefix,NULL,account);
tr.udp_port=LC_SIP_TRANSPORT_RANDOM;
tr.tcp_port=LC_SIP_TRANSPORT_RANDOM;
tr.tls_port=LC_SIP_TRANSPORT_RANDOM;
linphone_core_set_sip_transports(lc,&tr);
cfg=linphone_core_create_proxy_config(lc);
linphone_address_set_secure(tmp_identity, FALSE);
linphone_address_set_password(tmp_identity,account->password);
linphone_address_set_header(tmp_identity,"X-Create-Account","yes");
tmp=linphone_address_as_string(tmp_identity);
linphone_proxy_config_set_identity(cfg,tmp);
ms_free(tmp);
linphone_address_unref(tmp_identity);
server_addr=linphone_address_new(linphone_proxy_config_get_server_addr(refcfg));
linphone_address_set_secure(server_addr, FALSE);
linphone_address_set_transport(server_addr,LinphoneTransportTcp); /*use tcp for account creation, we may not have certificates configured at this stage*/
linphone_address_set_port(server_addr,0);
tmp=linphone_address_as_string(server_addr);
linphone_proxy_config_set_server_addr(cfg,tmp);
ms_free(tmp);
linphone_address_unref(server_addr);
linphone_proxy_config_set_expires(cfg,3600);
linphone_core_add_proxy_config(lc,cfg);
if (wait_for_until(lc,NULL,&account->auth_requested,1,10000)==FALSE){
ms_fatal("Account for %s could not be created on server.", linphone_proxy_config_get_identity(refcfg));
}
linphone_proxy_config_edit(cfg);
tmp_identity=linphone_address_clone(account->modified_identity);
linphone_address_set_secure(tmp_identity, FALSE);
tmp=linphone_address_as_string(tmp_identity);
linphone_proxy_config_set_identity(cfg,tmp); /*remove the X-Create-Account header*/
linphone_address_unref(tmp_identity);
ms_free(tmp);
linphone_proxy_config_done(cfg);
ai=linphone_auth_info_new(linphone_address_get_username(account->modified_identity),
NULL,
account->password,NULL,NULL,linphone_address_get_domain(account->modified_identity));
linphone_core_add_auth_info(lc,ai);
linphone_auth_info_destroy(ai);
if (wait_for_until(lc,NULL,&account->created,1,3000)==FALSE){
ms_fatal("Account for %s is not working on server.", linphone_proxy_config_get_identity(refcfg));
}
linphone_core_remove_proxy_config(lc,cfg);
linphone_proxy_config_unref(cfg);
if (wait_for_until(lc,NULL,&account->done,1,3000)==FALSE){
ms_error("Account creation could not clean the registration context.");
}
linphone_core_destroy(lc);
}
void linphone_gtk_call_log_update(GtkWidget *w){
GtkTreeView *v=GTK_TREE_VIEW(linphone_gtk_get_widget(w,"logs_view"));
GtkTreeStore *store;
const MSList *logs;
GtkTreeSelection *select;
GtkWidget *notebook=linphone_gtk_get_widget(w,"viewswitch");
gint nb;
store=(GtkTreeStore*)gtk_tree_view_get_model(v);
if (store==NULL){
store=gtk_tree_store_new(3,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_POINTER,G_TYPE_STRING);
gtk_tree_view_set_model(v,GTK_TREE_MODEL(store));
g_object_unref(G_OBJECT(store));
fill_renderers(GTK_TREE_VIEW(linphone_gtk_get_widget(w,"logs_view")));
select=gtk_tree_view_get_selection(v);
gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE);
g_signal_connect_swapped(G_OBJECT(select),"changed",(GCallback)call_log_selection_changed,v);
g_signal_connect(G_OBJECT(notebook),"focus-tab",(GCallback)linphone_gtk_call_log_reset_missed_call,NULL);
g_signal_connect(G_OBJECT(v),"button-press-event",(GCallback)linphone_gtk_call_log_button_pressed,NULL);
}
nb=linphone_core_get_missed_calls_count(linphone_gtk_get_core());
if(nb > 0)
linphone_gtk_call_log_display_missed_call(nb);
gtk_tree_store_clear (store);
for (logs=linphone_core_get_call_logs(linphone_gtk_get_core());logs!=NULL;logs=logs->next){
LinphoneCallLog *cl=(LinphoneCallLog*)logs->data;
GtkTreeIter iter, iter2;
LinphoneAddress *la=linphone_call_log_get_dir(cl)==LinphoneCallIncoming ? linphone_call_log_get_from(cl) : linphone_call_log_get_to(cl);
char *addr= linphone_address_as_string(la);
const char *display;
gchar *logtxt, *headtxt, *minutes, *seconds;
gchar quality[20];
const char *status=NULL;
gchar *start_date=NULL;
LinphoneFriend *lf=NULL;
int duration=linphone_call_log_get_duration(cl);
time_t start_date_time=linphone_call_log_get_start_date(cl);
const gchar *call_status_icon_name;
#if GLIB_CHECK_VERSION(2,30,0) // The g_date_time_format function exists since 2.26.0 but the '%c' format is only supported since 2.30.0
if (start_date_time){
GDateTime *dt=g_date_time_new_from_unix_local(start_date_time);
start_date=g_date_time_format(dt,"%c");
g_date_time_unref(dt);
}
#else
start_date=g_strdup(ctime(&start_date_time));
if (start_date[strlen(start_date) - 1] == '\n') {
start_date[strlen(start_date) - 1] = '\0';
}
#endif
lf=linphone_core_get_friend_by_address(linphone_gtk_get_core(),addr);
if(lf != NULL){
/*update display name from friend*/
display = linphone_friend_get_name(lf);
if (display != NULL) linphone_address_set_display_name(la, display);
} else {
display=linphone_address_get_display_name(la);
}
if (display==NULL){
display=linphone_address_get_username (la);
if (display==NULL){
display=linphone_address_get_domain (la);
}
}
if (linphone_call_log_get_quality(cl)!=-1){
snprintf(quality,sizeof(quality),"%.1f",linphone_call_log_get_quality(cl));
}else snprintf(quality,sizeof(quality)-1,"%s",_("n/a"));
switch(linphone_call_log_get_status(cl)){
case LinphoneCallAborted:
status=_("Aborted");
break;
case LinphoneCallMissed:
status=_("Missed");
break;
case LinphoneCallDeclined:
status=_("Declined");
break;
default:
break;
}
minutes=g_markup_printf_escaped(
ngettext("%i minute", "%i minutes", duration/60),
duration/60);
seconds=g_markup_printf_escaped(
ngettext("%i second", "%i seconds", duration%60),
duration%60);
if (status==NULL) {
headtxt=g_markup_printf_escaped("<big><b>%s</b></big>\t%s",display,start_date ? start_date : "");
logtxt=g_markup_printf_escaped(
_("<small><i>%s</i>\t"
"<i>Quality: %s</i></small>\n%s\t%s\t"),
addr, quality, minutes, seconds);
} else {
headtxt=g_markup_printf_escaped(_("<big><b>%s</b></big>\t%s"),display,start_date ? start_date : "");
logtxt=g_markup_printf_escaped(
"<small><i>%s</i></small>\t"
"\n%s",addr, status);
}
g_free(minutes);
g_free(seconds);
if (start_date) g_free(start_date);
gtk_tree_store_append (store,&iter,NULL);
call_status_icon_name = linphone_call_log_get_dir(cl) == LinphoneCallOutgoing ?
"linphone-call-status-outgoing" : "linphone-call-status-incoming";
gtk_tree_store_set (store,&iter,
0, call_status_icon_name,
1, headtxt,2,cl,-1);
gtk_tree_store_append (store,&iter2,&iter);
gtk_tree_store_set (store,&iter2,1,logtxt,-1);
ms_free(addr);
g_free(logtxt);
g_free(headtxt);
}
}
