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;
}
void linphone_core_manager_start(LinphoneCoreManager *mgr, const char* rc_file, int check_for_proxies) {
LinphoneProxyConfig* proxy;
int proxy_count;
/*BC_ASSERT_EQUAL(ms_list_size(linphone_core_get_proxy_config_list(lc)),proxy_count, int, "%d");*/
if (check_for_proxies && rc_file) /**/
proxy_count=ms_list_size(linphone_core_get_proxy_config_list(mgr->lc));
else
proxy_count=0;
if (proxy_count){
#define REGISTER_TIMEOUT 20 /* seconds */
int success = wait_for_until(mgr->lc,NULL,&mgr->stat.number_of_LinphoneRegistrationOk,
proxy_count,(REGISTER_TIMEOUT * 1000 * proxy_count));
if( !success ){
ms_error("Did not register after %d seconds for %d proxies", REGISTER_TIMEOUT, proxy_count);
}
}
BC_ASSERT_EQUAL(mgr->stat.number_of_LinphoneRegistrationOk,proxy_count, int, "%d");
enable_codec(mgr->lc,"PCMU",8000);
linphone_core_get_default_proxy(mgr->lc,&proxy);
if (proxy) {
mgr->identity = linphone_address_clone(linphone_proxy_config_get_identity_address(proxy));
linphone_address_clean(mgr->identity);
}
}
QString AccountSettingsModel::displayName() const {
if (!_proxyConfig) {
return NULL;
}
const LinphoneAddress *addr = linphone_proxy_config_get_identity_address(_proxyConfig);
return linphone_address_get_display_name(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;
}
void AccountSettingsModel::selectDefaultProxy() {
_proxyConfig = linphone_core_get_default_proxy_config(LinphoneManager::getInstance()->getLc());
if (!_proxyConfig) {
return;
}
const LinphoneAddress *addr = linphone_proxy_config_get_identity_address(_proxyConfig);
_authInfo = linphone_proxy_config_find_auth_info(_proxyConfig);
if (_proxyConfig && _authInfo) {
emit accountUpdated();
}
}
LinphoneProxyConfig * linphone_account_creator_configure(const LinphoneAccountCreator *creator) {
const 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_proxy_config_get_identity_address(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);
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 linphone_core_manager_start(LinphoneCoreManager *mgr, int check_for_proxies) {
LinphoneProxyConfig* proxy;
int proxy_count;
/*BC_ASSERT_EQUAL(ms_list_size(linphone_core_get_proxy_config_list(lc)),proxy_count, int, "%d");*/
if (check_for_proxies){ /**/
proxy_count=ms_list_size(linphone_core_get_proxy_config_list(mgr->lc));
}else{
proxy_count=0;
/*this is to prevent registration to go on*/
linphone_core_set_network_reachable(mgr->lc, FALSE);
}
if (proxy_count){
#define REGISTER_TIMEOUT 20 /* seconds */
int success = wait_for_until(mgr->lc,NULL,&mgr->stat.number_of_LinphoneRegistrationOk,
proxy_count,(REGISTER_TIMEOUT * 1000 * proxy_count));
if( !success ){
ms_error("Did not register after %d seconds for %d proxies", REGISTER_TIMEOUT, proxy_count);
}
}
BC_ASSERT_EQUAL(mgr->stat.number_of_LinphoneRegistrationOk,proxy_count, int, "%d");
enable_codec(mgr->lc,"PCMU",8000);
proxy = linphone_core_get_default_proxy_config(mgr->lc);
if (proxy) {
if (mgr->identity){
linphone_address_destroy(mgr->identity);
}
mgr->identity = linphone_address_clone(linphone_proxy_config_get_identity_address(proxy));
linphone_address_clean(mgr->identity);
}
if (linphone_core_get_stun_server(mgr->lc) != NULL){
/*before we go, ensure that the stun server is resolved, otherwise all ice related test will fail*/
BC_ASSERT_TRUE(wait_for_stun_resolution(mgr));
}
if (!check_for_proxies){
/*now that stun server resolution is done, we can start registering*/
linphone_core_set_network_reachable(mgr->lc, TRUE);
}
}
void AccountSettingsModel::setSelectedAccount(QString sipUri) {
const MSList *proxy_configs = linphone_core_get_proxy_config_list(LinphoneManager::getInstance()->getLc());
sipUri = QString("sip:") + sipUri;
while (proxy_configs) {
LinphoneProxyConfig *lpc = (LinphoneProxyConfig *)proxy_configs->data;
const LinphoneAddress *addr = linphone_proxy_config_get_identity_address(lpc);
const char *uri = linphone_address_as_string_uri_only(addr);
if (strcmp(uri, sipUri.toUtf8().constData()) == 0) {
_proxyConfig = lpc;
_authInfo = linphone_proxy_config_find_auth_info(_proxyConfig);
if (_proxyConfig && _authInfo) {
emit accountUpdated();
}
return;
}
proxy_configs = ms_list_next(proxy_configs);
}
}
