static LinphoneAccountCreatorStatus validate_uri(const char* username, const char* domain, const char* route, const char* display_name) {
LinphoneAddress* addr;
LinphoneAccountCreatorStatus status = LinphoneAccountCreatorOK;
LinphoneProxyConfig* proxy = linphone_proxy_config_new();
linphone_proxy_config_set_identity(proxy, "sip:[email protected]");
if (route && linphone_proxy_config_set_route(proxy, route) != 0) {
status = LinphoneAccountCreatorRouteInvalid;
goto end;
}
if (username) {
addr = linphone_proxy_config_normalize_sip_uri(proxy, username);
} else {
addr = linphone_address_clone(linphone_proxy_config_get_identity_address(proxy));
}
if (addr == NULL) {
status = LinphoneAccountCreatorUsernameInvalid;
goto end;
}
if (domain && linphone_address_set_domain(addr, domain) != 0) {
status = LinphoneAccountCreatorDomainInvalid;
}
if (display_name && (!strlen(display_name) || linphone_address_set_display_name(addr, display_name) != 0)) {
status = LinphoneAccountCreatorDisplayNameInvalid;
}
linphone_address_unref(addr);
end:
linphone_proxy_config_destroy(proxy);
return status;
}
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;
}
void AccountSettingsModel::setOutboundProxy(const bool& yes) {
if (!_proxyConfig) {
return;
}
linphone_proxy_config_edit(_proxyConfig);
if (yes) {
linphone_proxy_config_set_route(_proxyConfig, linphone_proxy_config_get_server_addr(_proxyConfig));
} else {
linphone_proxy_config_set_route(_proxyConfig, NULL);
}
linphone_proxy_config_done(_proxyConfig);
}
static void linphone_core_migrate_proxy_config(LinphoneCore *lc, LinphoneTransportType type){
const MSList *elem;
for(elem=linphone_core_get_proxy_config_list(lc);elem!=NULL;elem=elem->next){
LinphoneProxyConfig *cfg=(LinphoneProxyConfig*)elem->data;
const char *proxy=linphone_proxy_config_get_addr(cfg);
const char *route=linphone_proxy_config_get_route(cfg);
LinphoneAddress *proxy_addr=linphone_address_new(proxy);
LinphoneAddress *route_addr=NULL;
char *tmp;
if (route) route_addr=linphone_address_new(route);
if (proxy_addr){
linphone_address_set_transport(proxy_addr,type);
tmp=linphone_address_as_string(proxy_addr);
linphone_proxy_config_set_server_addr(cfg,tmp);
ms_free(tmp);
linphone_address_destroy(proxy_addr);
}
if (route_addr){
linphone_address_set_transport(route_addr,type);
tmp=linphone_address_as_string(route_addr);
linphone_proxy_config_set_route(cfg,tmp);
ms_free(tmp);
linphone_address_destroy(route_addr);
}
}
}
static LinphoneAccountCreatorStatus validate_uri(const char* username, const char* domain, const char* route, const char* display_name) {
LinphoneProxyConfig* proxy = linphone_proxy_config_new();
LinphoneAddress* addr;
linphone_proxy_config_set_identity(proxy, "sip:[email protected]");
if (route && linphone_proxy_config_set_route(proxy, route) != 0) {
linphone_proxy_config_destroy(proxy);
return LinphoneAccountCreatorRouteInvalid;
}
if (username) {
addr = linphone_proxy_config_normalize_sip_uri(proxy, username);
} else {
addr = linphone_address_clone(linphone_proxy_config_get_identity_address(proxy));
}
linphone_proxy_config_destroy(proxy);
if (addr == NULL) {
return LinphoneAccountCreatorUsernameInvalid;
}
if (domain) {
ms_error("TODO: detect invalid domain");
linphone_address_set_domain(addr, domain);
}
if (display_name) {
ms_error("TODO: detect invalid display name");
linphone_address_set_display_name(addr, display_name);
}
linphone_address_unref(addr);
return LinphoneAccountCreatorOk;
}
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);
}
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;
}
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);
}
void AccountSettingsModel::setProxy(const QString& proxy) {
if (!_proxyConfig) {
return;
}
linphone_proxy_config_edit(_proxyConfig);
LinphoneAddress *addr = linphone_core_create_address(LinphoneManager::getInstance()->getLc(), proxy.toUtf8().constData());
linphone_proxy_config_set_server_addr(_proxyConfig, linphone_address_as_string(addr));
if (outboundProxy()) {
linphone_proxy_config_set_route(_proxyConfig, linphone_address_as_string(addr));
}
linphone_address_destroy(addr);
linphone_proxy_config_done(_proxyConfig);
emit accountUpdated();
}
void SIP_Account::on_buttonBox_accepted()
{
QString a;
QTextCodec::setCodecForCStrings(QTextCodec::codecForName("utf8"));
QTextCodec *codec = QTextCodec::codecForCStrings();
LinphoneProxyConfig *cfg = _cfg;
bool was_editing = true;
if (!cfg){
was_editing = false;
cfg=linphone_proxy_config_new();
}
a = ui->lineEdit_account->text();
linphone_proxy_config_set_identity(cfg, a.toUtf8().data());
a = ui->lineEdit_proxy->text();
linphone_proxy_config_set_server_addr(cfg, a.toUtf8().data());
a = ui->lineEdit_route->text();
linphone_proxy_config_set_route(cfg, a.toUtf8().data());
linphone_proxy_config_expires(cfg, ui->spinBox_Regtime->value());
bool publish = ui->checkBox_publish->isChecked();
bool_t published = FALSE;
if (publish) published = TRUE;
linphone_proxy_config_enable_publish(cfg, published);
bool reg = ui->checkBox_register->isChecked();
bool_t reged = FALSE;
if (reg) reged = TRUE;
linphone_proxy_config_enable_register(cfg, reged);
if (was_editing){
if (linphone_proxy_config_done(cfg)==-1)
return;
}
else {
if (linphone_core_add_proxy_config(linphone_qt_get_core(),cfg)==-1) return;
linphone_core_set_default_proxy(linphone_qt_get_core(),cfg);
}
_cfg = cfg;
preferencewindow->linphone_qt_show_sip_accounts();
w->qt_load_identities();
this->clear_proxy();
this->close();
}
static void text_message_compatibility_mode(void) {
char route[256];
LinphoneCoreManager* marie = linphone_core_manager_new( "marie_rc");
LinphoneCoreManager* pauline = linphone_core_manager_new( "pauline_rc");
LinphoneProxyConfig* proxy;
LinphoneAddress* proxy_address;
char*tmp;
LCSipTransports transport;
char* to = linphone_address_as_string(pauline->identity);
LinphoneChatRoom* chat_room;
linphone_core_get_default_proxy(marie->lc,&proxy);
CU_ASSERT_PTR_NOT_NULL (proxy);
proxy_address=linphone_address_new(linphone_proxy_config_get_addr(proxy));
linphone_address_clean(proxy_address);
tmp=linphone_address_as_string_uri_only(proxy_address);
linphone_proxy_config_set_server_addr(proxy,tmp);
sprintf(route,"sip:%s",test_route);
linphone_proxy_config_set_route(proxy,route);
ms_free(tmp);
linphone_address_destroy(proxy_address);
linphone_core_get_sip_transports(marie->lc,&transport);
transport.udp_port=0;
transport.tls_port=0;
transport.dtls_port=0;
/*only keep tcp*/
linphone_core_set_sip_transports(marie->lc,&transport);
marie->stat.number_of_LinphoneRegistrationOk=0;
CU_ASSERT_TRUE (wait_for(marie->lc,marie->lc,&marie->stat.number_of_LinphoneRegistrationOk,1));
chat_room = linphone_core_create_chat_room(marie->lc,to);
{
int dummy=0;
wait_for_until(marie->lc,pauline->lc,&dummy,1,100); /*just to have time to purge message stored in the server*/
reset_counters(&marie->stat);
reset_counters(&pauline->stat);
}
linphone_chat_room_send_message(chat_room,"Bla bla bla bla");
CU_ASSERT_TRUE(wait_for(pauline->lc,marie->lc,&pauline->stat.number_of_LinphoneMessageReceived,1));
CU_ASSERT_EQUAL(pauline->stat.number_of_LinphoneMessageReceivedLegacy,1);
linphone_core_manager_destroy(marie);
linphone_core_manager_destroy(pauline);
}
LinphoneProxyConfig *linphone_proxy_config_new_from_config_file(LpConfig *config, int index)
{
const char *tmp;
const char *identity;
const char *proxy;
LinphoneProxyConfig *cfg;
char key[50];
sprintf(key,"proxy_%i",index);
if (!lp_config_has_section(config,key)){
return NULL;
}
cfg=linphone_proxy_config_new();
identity=lp_config_get_string(config,key,"reg_identity",NULL);
proxy=lp_config_get_string(config,key,"reg_proxy",NULL);
linphone_proxy_config_set_identity(cfg,identity);
linphone_proxy_config_set_server_addr(cfg,proxy);
tmp=lp_config_get_string(config,key,"reg_route",NULL);
if (tmp!=NULL) linphone_proxy_config_set_route(cfg,tmp);
linphone_proxy_config_expires(cfg,lp_config_get_int(config,key,"reg_expires",600));
linphone_proxy_config_enableregister(cfg,lp_config_get_int(config,key,"reg_sendregister",0));
linphone_proxy_config_enable_publish(cfg,lp_config_get_int(config,key,"publish",0));
linphone_proxy_config_set_dial_escape_plus(cfg,lp_config_get_int(config,key,"dial_escape_plus",0));
linphone_proxy_config_set_dial_prefix(cfg,lp_config_get_string(config,key,"dial_prefix",NULL));
tmp=lp_config_get_string(config,key,"type",NULL);
if (tmp!=NULL && strlen(tmp)>0)
linphone_proxy_config_set_sip_setup(cfg,tmp);
return cfg;
}
void AccountSettingsModel::setTransportIndex(const int& transport) {
if (!_proxyConfig) {
return;
}
const char *proxy = linphone_proxy_config_get_server_addr(_proxyConfig);
LinphoneAddress *addr = linphone_core_create_address(LinphoneManager::getInstance()->getLc(), proxy);
if (transport == 0) {
linphone_address_set_transport(addr, LinphoneTransportUdp);
} else if (transport == 1) {
linphone_address_set_transport(addr, LinphoneTransportTcp);
} else if (transport == 2) {
linphone_address_set_transport(addr, LinphoneTransportTls);
}
linphone_proxy_config_edit(_proxyConfig);
linphone_proxy_config_set_server_addr(_proxyConfig, linphone_address_as_string(addr));
if (outboundProxy()) {
linphone_proxy_config_set_route(_proxyConfig, linphone_address_as_string(addr));
}
linphone_address_destroy(addr);
linphone_proxy_config_done(_proxyConfig);
emit accountUpdated();
}
