bool AreProxyConfigsTheSame(LinphoneProxyConfig *lpc1, LinphoneProxyConfig *lpc2) { if (!lpc1 || !lpc2) { return false; } QString proxyConfigIdentity1(linphone_proxy_config_get_identity(lpc1)); QString proxyConfigIdentity2(linphone_proxy_config_get_identity(lpc2)); return QString::compare(proxyConfigIdentity1, proxyConfigIdentity2) == 0; }
int linphone_proxy_config_send_publish(LinphoneProxyConfig *proxy, LinphoneOnlineStatus presence_mode){ int err; SalOp *op=sal_op_new(proxy->lc->sal); err=sal_publish(op,linphone_proxy_config_get_identity(proxy), linphone_proxy_config_get_identity(proxy),linphone_online_status_to_sal(presence_mode)); if (proxy->publish_op!=NULL) sal_op_release(proxy->publish_op); proxy->publish_op=op; return err; }
const char* linphone_gtk_get_used_identity(){ LinphoneCore *lc=linphone_gtk_get_core(); LinphoneProxyConfig *cfg; linphone_core_get_default_proxy(lc,&cfg); if (cfg) return linphone_proxy_config_get_identity(cfg); else return linphone_core_get_primary_contact(lc); }
void SIP_Account::set_proxy(LinphoneProxyConfig *cfg) { const char *tmp; QTextCodec::setCodecForCStrings(QTextCodec::codecForName("utf8")); QTextCodec *codec = QTextCodec::codecForCStrings(); QString a; _cfg = cfg; if (cfg){ linphone_proxy_config_edit(cfg); tmp = linphone_proxy_config_get_identity(cfg); a = codec->toUnicode(tmp); ui->lineEdit_account->setText(a); tmp = linphone_proxy_config_get_addr(cfg); a = codec->toUnicode(tmp); ui->lineEdit_proxy->setText(a); tmp=linphone_proxy_config_get_route(cfg); if (tmp) { a = codec->toUnicode(tmp); ui->lineEdit_route->setText(a); } ui->checkBox_register->setChecked(linphone_proxy_config_register_enabled(cfg)); ui->spinBox_Regtime->setValue(linphone_proxy_config_get_expires(cfg)); ui->checkBox_publish->setChecked(linphone_proxy_config_publish_enabled(cfg)); } }
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; }
int linphone_proxy_config_send_publish(LinphoneProxyConfig *proxy, LinphoneOnlineStatus presence_mode) { osip_message_t *pub; int i; const char *from=NULL; char buf[5000]; if (proxy->publish==FALSE) return 0; if (proxy!=NULL) { from=linphone_proxy_config_get_identity(proxy); } if (from==NULL) from=linphone_core_get_primary_contact(proxy->lc); if (presence_mode==LINPHONE_STATUS_ONLINE) { snprintf(buf, 5000, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n\ <presence xmlns=\"urn:ietf:params:xml:ns:pidf\"\n\ entity=\"%s\">\n\ <tuple id=\"sg89ae\">\n\ <status>\n\ <basic>open</basic>\n\ </status>\n\ <contact priority=\"0.8\">%s</contact>\n\ <note>online</note>\n\ </tuple>\n\ </presence>", from, from); }
const LinphoneAddress* linphone_gtk_get_used_identity(){ LinphoneCore *lc=linphone_gtk_get_core(); LinphoneProxyConfig *cfg; linphone_core_get_default_proxy(lc,&cfg); if (cfg) return linphone_address_new(linphone_proxy_config_get_identity(cfg)); else return linphone_core_get_primary_contact_parsed(lc); }
void linphone_core_manager_start(LinphoneCoreManager *mgr, const char* rc_file, int check_for_proxies) { LinphoneProxyConfig* proxy; int proxy_count; /*CU_ASSERT_EQUAL(ms_list_size(linphone_core_get_proxy_config_list(lc)),proxy_count);*/ 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); } } CU_ASSERT_EQUAL(mgr->stat.number_of_LinphoneRegistrationOk,proxy_count); enable_codec(mgr->lc,"PCMU",8000); linphone_core_get_default_proxy(mgr->lc,&proxy); if (proxy) { mgr->identity = linphone_address_new(linphone_proxy_config_get_identity(proxy)); linphone_address_clean(mgr->identity); } }
void linphone_core_send_initial_subscribes(LinphoneCore *lc){ const MSList *elem; if (lc->initial_subscribes_sent) return; lc->initial_subscribes_sent=TRUE; /*set to true and see if looping on friends will change this status*/ for(elem=lc->friends;elem!=NULL;elem=elem->next){ LinphoneFriend *f=(LinphoneFriend*)elem->data; LinphoneProxyConfig* cfg; if (f->subscribe && !f->initial_subscribes_sent) { lc->initial_subscribes_sent=FALSE; /*at least 1 was not sent */ if ((cfg=linphone_core_lookup_known_proxy(f->lc,linphone_friend_get_address(f)))) { /*check if already registered*/ if (linphone_proxy_config_get_state(cfg) != LinphoneRegistrationOk) continue; /*skip this friend because not registered yet*/ else { char* lf_string = linphone_address_as_string(linphone_friend_get_address(f)); ms_message("Identity [%s] registered, we can now subscribe to [%s]",linphone_proxy_config_get_identity(cfg),lf_string); ms_free(lf_string); } } linphone_friend_apply(f,lc); f->initial_subscribes_sent=TRUE; } } }
G_MODULE_EXPORT void linphone_gtk_login_frame_connect_clicked(GtkWidget *button){ GtkWidget *mw=gtk_widget_get_toplevel(button); const char *username; const char *password; char *identity; gboolean autologin; LinphoneProxyConfig *cfg=(LinphoneProxyConfig*)g_object_get_data(G_OBJECT(mw),"login_proxy_config"); LinphoneAddress *from; SipSetupContext *ssctx=linphone_proxy_config_get_sip_setup_context(cfg); username=gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(mw,"login_username"))); password=gtk_entry_get_text(GTK_ENTRY(linphone_gtk_get_widget(mw,"login_password"))); if (username==NULL || username[0]=='\0') return; autologin=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(linphone_gtk_get_widget(mw,"automatic_login"))); linphone_gtk_set_ui_config_int("automatic_login",autologin); linphone_gtk_set_ui_config("login_username",username); from=linphone_address_new(linphone_proxy_config_get_identity(cfg)); linphone_address_set_username(from,username); identity=linphone_address_as_string(from); do_login(ssctx,identity,password); /*we need to refresh the identities since the proxy config may have changed.*/ linphone_gtk_load_identities(); }
LinphoneCoreManager* linphone_core_manager_new2(const char* rc_file, int check_for_proxies) { LinphoneCoreManager* mgr= ms_new0(LinphoneCoreManager,1); LinphoneProxyConfig* proxy; char *rc_path = NULL; int proxy_count; mgr->v_table.registration_state_changed=registration_state_changed; mgr->v_table.auth_info_requested=auth_info_requested; mgr->v_table.call_state_changed=call_state_changed; mgr->v_table.text_received=text_message_received; mgr->v_table.message_received=message_received; mgr->v_table.file_transfer_recv=file_transfer_received; mgr->v_table.file_transfer_send=file_transfer_send; mgr->v_table.file_transfer_progress_indication=file_transfer_progress_indication; mgr->v_table.is_composing_received=is_composing_received; mgr->v_table.new_subscription_requested=new_subscription_requested; mgr->v_table.notify_presence_received=notify_presence_received; mgr->v_table.transfer_state_changed=linphone_transfer_state_changed; mgr->v_table.info_received=info_message_received; mgr->v_table.subscription_state_changed=linphone_subscription_state_change; mgr->v_table.notify_received=linphone_notify_received; mgr->v_table.publish_state_changed=linphone_publish_state_changed; mgr->v_table.configuring_status=linphone_configuration_status; mgr->v_table.call_encryption_changed=linphone_call_encryption_changed; mgr->v_table.network_reachable=network_reachable; reset_counters(&mgr->stat); if (rc_file) rc_path = ms_strdup_printf("rcfiles/%s", rc_file); mgr->lc=configure_lc_from(&mgr->v_table, liblinphone_tester_file_prefix, rc_path, mgr); /*CU_ASSERT_EQUAL(ms_list_size(linphone_core_get_proxy_config_list(lc)),proxy_count);*/ if (check_for_proxies && rc_file) /**/ proxy_count=ms_list_size(linphone_core_get_proxy_config_list(mgr->lc)); else proxy_count=0; #if TARGET_OS_IPHONE linphone_core_set_playback_device( mgr->lc, "AU: Audio Unit Tester"); linphone_core_set_capture_device( mgr->lc, "AU: Audio Unit Tester"); linphone_core_set_ringer_device( mgr->lc, "AQ: Audio Queue Device"); linphone_core_set_ringback(mgr->lc, NULL); #endif if (proxy_count) wait_for_until(mgr->lc,NULL,&mgr->stat.number_of_LinphoneRegistrationOk,proxy_count,5000*proxy_count); CU_ASSERT_EQUAL(mgr->stat.number_of_LinphoneRegistrationOk,proxy_count); enable_codec(mgr->lc,"PCMU",8000); linphone_core_get_default_proxy(mgr->lc,&proxy); if (proxy) { mgr->identity = linphone_address_new(linphone_proxy_config_get_identity(proxy)); linphone_address_clean(mgr->identity); } if (rc_path) ms_free(rc_path); return mgr; }
static void registration_state_changed(struct _LinphoneCore *lc, LinphoneProxyConfig *cfg, LinphoneRegistrationState cstate, const char *message) { Q_UNUSED(lc) Q_UNUSED(message) SipClient *sc = SipClient::instance(); sc->registrationStateChangedCb(cstate); printf("New registration state %s for user id [%s] at proxy [%s]\n", linphone_registration_state_to_string(cstate), linphone_proxy_config_get_identity(cfg), linphone_proxy_config_get_addr(cfg)); }
static void registration_state_changed(struct _LinphoneCore *lc, LinphoneProxyConfig *cfg, LinphoneRegistrationState cstate, const char *message) { // Q_UNUSED(message) qDebug() << __func__ << "New registration state:" << linphone_registration_state_to_string(cstate) << "User:"******"Proxy:" << linphone_proxy_config_get_addr(cfg) << "Message:" << message; QLinPhoneCore *lcc = static_cast<QLinPhoneCore *>(linphone_core_get_user_data(lc)); lcc->setRegistrationState(static_cast<enum QLinPhoneCore::RegistrationState>(cstate)); }
void AccountSettingsModel::setDisplayName(const QString& displayName) { if (!_proxyConfig) { return; } const char *identity = linphone_proxy_config_get_identity(_proxyConfig); LinphoneAddress *addr = linphone_core_create_address(LinphoneManager::getInstance()->getLc(), identity); linphone_address_set_display_name(addr, displayName.toUtf8().constData()); linphone_proxy_config_edit(_proxyConfig); linphone_proxy_config_set_identity_address(_proxyConfig, addr); linphone_proxy_config_done(_proxyConfig); linphone_address_destroy(addr); }
void registration_state_changed(struct _LinphoneCore *lc, LinphoneProxyConfig *cfg, LinphoneRegistrationState cstate, const char *message){ stats* counters; ms_message("New registration state %s for user id [%s] at proxy [%s]\n" ,linphone_registration_state_to_string(cstate) ,linphone_proxy_config_get_identity(cfg) ,linphone_proxy_config_get_addr(cfg)); counters = get_stats(lc); switch (cstate) { case LinphoneRegistrationNone:counters->number_of_LinphoneRegistrationNone++;break; case LinphoneRegistrationProgress:counters->number_of_LinphoneRegistrationProgress++;break; case LinphoneRegistrationOk:counters->number_of_LinphoneRegistrationOk++;break; case LinphoneRegistrationCleared:counters->number_of_LinphoneRegistrationCleared++;break; case LinphoneRegistrationFailed:counters->number_of_LinphoneRegistrationFailed++;break; default: BC_FAIL("unexpected event");break; } }
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 _linphone_chat_room_send_message(LinphoneChatRoom *cr, LinphoneChatMessage* msg){ SalOp *op=NULL; LinphoneCall *call; char* content_type; const char *identity=NULL; time_t t=time(NULL); if (lp_config_get_int(cr->lc->config,"sip","chat_use_call_dialogs",0)){ if((call = linphone_core_get_call_by_remote_address(cr->lc,cr->peer))!=NULL){ if (call->state==LinphoneCallConnected || call->state==LinphoneCallStreamsRunning || call->state==LinphoneCallPaused || call->state==LinphoneCallPausing || call->state==LinphoneCallPausedByRemote){ ms_message("send SIP message through the existing call."); op = call->op; call->pending_message=msg; identity=linphone_core_find_best_identity(cr->lc,linphone_call_get_remote_address(call)); } } } msg->time=t; if (op==NULL){ LinphoneProxyConfig *proxy=linphone_core_lookup_known_proxy(cr->lc,cr->peer_url); if (proxy){ identity=linphone_proxy_config_get_identity(proxy); }else identity=linphone_core_get_primary_contact(cr->lc); /*sending out of calls*/ op = sal_op_new(cr->lc->sal); linphone_configure_op(cr->lc,op,cr->peer_url,msg->custom_headers,lp_config_get_int(cr->lc->config,"sip","chat_msg_with_contact",0)); sal_op_set_user_pointer(op, msg); /*if out of call, directly store msg*/ } if (msg->external_body_url) { content_type=ms_strdup_printf("message/external-body; access-type=URL; URL=\"%s\"",msg->external_body_url); sal_message_send(op,identity,cr->peer,content_type, NULL); ms_free(content_type); } else { sal_text_send(op, identity, cr->peer,msg->message); } msg->dir=LinphoneChatMessageOutgoing; msg->from=linphone_address_new(identity); msg->storage_id=linphone_chat_message_store(msg); }
void AccountSettingsModel::setUsername(const QString& username) { if (!_authInfo || !_proxyConfig) { return; } LinphoneAuthInfo *ai = linphone_auth_info_clone(_authInfo); linphone_auth_info_set_username(ai, username.toUtf8().constData()); linphone_core_remove_auth_info(LinphoneManager::getInstance()->getLc(), _authInfo); linphone_core_add_auth_info(LinphoneManager::getInstance()->getLc(), ai); _authInfo = ai; const char *identity = linphone_proxy_config_get_identity(_proxyConfig); LinphoneAddress *addr = linphone_core_create_address(LinphoneManager::getInstance()->getLc(), identity); linphone_address_set_username(addr, username.toUtf8().constData()); linphone_proxy_config_edit(_proxyConfig); linphone_proxy_config_set_identity_address(_proxyConfig, addr); linphone_proxy_config_done(_proxyConfig); linphone_address_destroy(addr); }
static gboolean do_login_noprompt(LinphoneProxyConfig *cfg){ SipSetupContext *ssctx=linphone_proxy_config_get_sip_setup_context(cfg); LinphoneAddress *addr; const char *username; char *tmp; if (ssctx==NULL) return TRUE;/*not ready ?*/ username=linphone_gtk_get_ui_config ("login_username",NULL); if (username==NULL) { linphone_gtk_set_ui_config_int("automatic_login",0); linphone_gtk_show_login_frame(cfg); return FALSE; } addr=linphone_address_new(linphone_proxy_config_get_identity(cfg)); linphone_address_set_username(addr,username); tmp=linphone_address_as_string (addr); do_login(ssctx,tmp,NULL); linphone_address_destroy(addr); return FALSE; }
/* * updates the subscriptions. * If only_when_registered is TRUE, subscribe will be sent only if the friend's corresponding proxy config is in registered. * Otherwise if the proxy config goes to unregistered state, the subscription refresh will be suspended. * An optional proxy whose state has changed can be passed to optimize the processing. **/ void linphone_friend_update_subscribes(LinphoneFriend *fr, LinphoneProxyConfig *proxy, bool_t only_when_registered){ int can_subscribe=1; if (only_when_registered && (fr->subscribe || fr->subscribe_active)){ LinphoneProxyConfig *cfg=linphone_core_lookup_known_proxy(fr->lc,fr->uri); if (proxy && proxy!=cfg) return; if (cfg && cfg->state!=LinphoneRegistrationOk){ char *tmp=linphone_address_as_string(fr->uri); ms_message("Friend [%s] belongs to proxy config with identity [%s], but this one isn't registered. Subscription is suspended.", tmp,linphone_proxy_config_get_identity(cfg)); ms_free(tmp); can_subscribe=0; } } if (can_subscribe && fr->subscribe && fr->subscribe_active==FALSE){ ms_message("Sending a new SUBSCRIBE"); __linphone_friend_do_subscribe(fr); }else if (can_subscribe && fr->subscribe_active && !fr->subscribe){ linphone_friend_unsubscribe(fr); }else if (!can_subscribe && fr->outsub){ fr->subscribe_active=FALSE; sal_op_stop_refreshing(fr->outsub); } }
const char * get_identity(LinphoneCoreManager *mgr) { LinphoneProxyConfig *cfg = linphone_core_get_default_proxy_config(mgr->lc); return linphone_proxy_config_get_identity(cfg); }
/** * Registration state notification callback */ static void registration_state_changed(LinphoneCore *lc, LinphoneProxyConfig *cfg, LinphoneRegistrationState cstate, const char *message){ printf("New registration state %s for user id [%s] at proxy [%s]\n" ,linphone_registration_state_to_string(cstate) ,linphone_proxy_config_get_identity(cfg) ,linphone_proxy_config_get_addr(cfg)); }
void linphone_gtk_show_login_frame(LinphoneProxyConfig *cfg){ GtkWidget *mw=linphone_gtk_get_main_window(); GtkWidget *label=linphone_gtk_get_widget(mw,"login_label"); const LinphoneAuthInfo *ai; gchar *str; LinphoneAddress *from; LinphoneCore *lc=linphone_gtk_get_core(); int nettype; const char *passwd=NULL; if (linphone_core_get_download_bandwidth(lc)==512 && linphone_core_get_upload_bandwidth(lc)==512) nettype=NetworkKindOpticalFiber; else nettype=NetworkKindAdsl; gtk_combo_box_set_active(GTK_COMBO_BOX(linphone_gtk_get_widget(mw,"login_internet_kind")),nettype); gtk_combo_box_set_active(GTK_COMBO_BOX(linphone_gtk_get_widget(mw,"internet_kind")),nettype); if (linphone_gtk_get_ui_config_int("automatic_login",0) ){ g_timeout_add(250,(GSourceFunc)do_login_noprompt,cfg); return; } { const char *login_image=linphone_gtk_get_ui_config("login_image",NULL); if (login_image){ GdkPixbuf *pbuf=create_pixbuf (login_image); gtk_image_set_from_pixbuf (GTK_IMAGE(linphone_gtk_get_widget(mw,"login_image")), pbuf); g_object_unref(G_OBJECT(pbuf)); } } gtk_widget_hide(linphone_gtk_get_widget(mw,"disconnect_item")); gtk_widget_hide(linphone_gtk_get_widget(mw,"main_frame")); gtk_widget_show(linphone_gtk_get_widget(mw,"login_frame")); gtk_widget_set_sensitive(linphone_gtk_get_widget(mw,"main_menu"),FALSE); gtk_widget_set_sensitive(linphone_gtk_get_widget(mw,"options_menu"),FALSE); str=g_strdup_printf(_("Please enter login information for %s"),linphone_proxy_config_get_domain(cfg)); gtk_label_set_text(GTK_LABEL(label),str); g_object_set_data(G_OBJECT(mw),"login_proxy_config",cfg); g_free(str); from=linphone_address_new(linphone_proxy_config_get_identity(cfg)); if (linphone_address_get_username(from)[0]=='?'){ const char *username=linphone_gtk_get_ui_config ("login_username",NULL); if (username) linphone_address_set_username(from,username); } ai=linphone_core_find_auth_info(lc,linphone_proxy_config_get_domain(cfg),linphone_address_get_username(from)); /*display the last entered username, if not '?????'*/ if (linphone_address_get_username(from)[0]!='?') gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(mw,"login_username")), linphone_address_get_username(from)); if (ai) passwd=linphone_auth_info_get_passwd(ai); gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(mw,"login_password")), passwd!=NULL ? passwd : ""); linphone_address_destroy(from); }
LinphoneCoreManager* linphone_core_manager_new2(const char* rc_file, int check_for_proxies) { LinphoneCoreManager* mgr= ms_new0(LinphoneCoreManager,1); LinphoneProxyConfig* proxy; char *rc_path = NULL; int proxy_count; mgr->v_table.registration_state_changed=registration_state_changed; mgr->v_table.auth_info_requested=auth_info_requested; mgr->v_table.call_state_changed=call_state_changed; mgr->v_table.text_received=text_message_received; mgr->v_table.message_received=message_received; mgr->v_table.is_composing_received=is_composing_received; mgr->v_table.new_subscription_requested=new_subscription_requested; mgr->v_table.notify_presence_received=notify_presence_received; mgr->v_table.transfer_state_changed=linphone_transfer_state_changed; mgr->v_table.info_received=info_message_received; mgr->v_table.subscription_state_changed=linphone_subscription_state_change; mgr->v_table.notify_received=linphone_notify_received; mgr->v_table.publish_state_changed=linphone_publish_state_changed; mgr->v_table.configuring_status=linphone_configuration_status; mgr->v_table.call_encryption_changed=linphone_call_encryption_changed; mgr->v_table.network_reachable=network_reachable; mgr->v_table.dtmf_received=dtmf_received; mgr->v_table.call_stats_updated=call_stats_updated; reset_counters(&mgr->stat); if (rc_file) rc_path = ms_strdup_printf("rcfiles/%s", rc_file); mgr->lc=configure_lc_from(&mgr->v_table, liblinphone_tester_file_prefix, rc_path, mgr); linphone_core_manager_check_accounts(mgr); /*CU_ASSERT_EQUAL(ms_list_size(linphone_core_get_proxy_config_list(lc)),proxy_count);*/ if (check_for_proxies && rc_file) /**/ proxy_count=ms_list_size(linphone_core_get_proxy_config_list(mgr->lc)); else proxy_count=0; manager_count++; #if TARGET_OS_IPHONE linphone_core_set_ringer_device( mgr->lc, "AQ: Audio Queue Device"); linphone_core_set_ringback(mgr->lc, NULL); #endif if( manager_count >= 2){ char hellopath[512]; ms_message("Manager for '%s' using files", rc_file ? rc_file : "--"); linphone_core_use_files(mgr->lc, TRUE); snprintf(hellopath,sizeof(hellopath), "%s/sounds/hello8000.wav", liblinphone_tester_file_prefix); linphone_core_set_play_file(mgr->lc,hellopath); } 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); } } CU_ASSERT_EQUAL(mgr->stat.number_of_LinphoneRegistrationOk,proxy_count); enable_codec(mgr->lc,"PCMU",8000); linphone_core_get_default_proxy(mgr->lc,&proxy); if (proxy) { mgr->identity = linphone_address_new(linphone_proxy_config_get_identity(proxy)); linphone_address_clean(mgr->identity); } if (rc_path) ms_free(rc_path); return mgr; }
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); }
extern "C" jint Java_com_acsoftware_android_domophone_LibLP_nRegistered(JNIEnv* env, jobject thiz, jstring jIdent, jstring jHost) { jint result = 0; if ( lc ) { char* ident = jIdent?(char*)env->GetStringUTFChars(jIdent, NULL):NULL; char* host = jHost?(char*)env->GetStringUTFChars(jHost, NULL):NULL; int s; if ( ident ) { char *i = NULL; if ( ident != NULL && host != NULL ) { s = strlen(ident)+strlen(host)+6; i = (char*)malloc(s+1); snprintf(i, s, "sip:%s@%s", ident, host); } env->ReleaseStringUTFChars(jIdent, ident); ident = i; } if ( host ) { s = strlen(host)+7; char *h = (char*)malloc(s+1); snprintf(h, s, "sip:%s", host); env->ReleaseStringUTFChars(jHost, host); host = h; } LinphoneProxyConfig* proxy_cfg = linphone_core_get_default_proxy_config(lc); if ( proxy_cfg && linphone_proxy_config_is_registered(proxy_cfg) == 1 ) { if ( ( ident && strlen(ident) > 0 ) || ( host && strlen(host) > 0 ) ) { const char *cident = linphone_proxy_config_get_identity(proxy_cfg); const char *chost = linphone_proxy_config_get_addr(proxy_cfg); __android_log_write(ANDROID_LOG_DEBUG, "LIBLP-cident", cident); __android_log_write(ANDROID_LOG_DEBUG, "LIBLP-ident", ident); __android_log_write(ANDROID_LOG_DEBUG, "LIBLP-chost", chost); __android_log_write(ANDROID_LOG_DEBUG, "LIBLP-host", host); if ( strcmp(cident, ident) == 0 && strcmp(chost, host) == 0 ) result = 2; }; if ( result == 0 ) { result = 1; } if ( ident ) { free(ident); } if ( host ) { free(host); } }; }; return result; }