/**
* Sets the proxy address
*
* Examples of valid sip proxy address are:
* - IP address: sip:87.98.157.38
* - IP address with port: sip:87.98.157.38:5062
* - hostnames : sip:sip.example.net
**/
int linphone_proxy_config_set_server_addr(LinphoneProxyConfig *obj, const char *server_addr){
LinphoneAddress *addr=NULL;
char *modified=NULL;
if (obj->reg_proxy!=NULL) ms_free(obj->reg_proxy);
obj->reg_proxy=NULL;
if (server_addr!=NULL && strlen(server_addr)>0){
if (strstr(server_addr,"sip:")==NULL){
modified=ms_strdup_printf("sip:%s",server_addr);
addr=linphone_address_new(modified);
ms_free(modified);
}
if (addr==NULL)
addr=linphone_address_new(server_addr);
if (addr){
obj->reg_proxy=linphone_address_as_string_uri_only(addr);
linphone_address_destroy(addr);
}else{
ms_warning("Could not parse %s",server_addr);
return -1;
}
}
return 0;
}
/* DB layout:
* | 0 | storage_id
* | 1 | from
* | 2 | to
* | 3 | direction flag
* | 4 | duration
* | 5 | start date time (time_t)
* | 6 | connected date time (time_t)
* | 7 | status
* | 8 | video enabled (1 or 0)
* | 9 | quality
* | 10 | call_id
* | 11 | refkey
*/
static int create_call_log(void *data, int argc, char **argv, char **colName) {
MSList **list = (MSList **)data;
LinphoneAddress *from;
LinphoneAddress *to;
LinphoneCallDir dir;
LinphoneCallLog *log;
unsigned int storage_id = atoi(argv[0]);
from = linphone_address_new(argv[1]);
to = linphone_address_new(argv[2]);
dir = (LinphoneCallDir) atoi(argv[3]);
log = linphone_call_log_new(dir, from, to);
log->storage_id = storage_id;
log->duration = atoi(argv[4]);
log->start_date_time = (time_t)atol(argv[5]);
log->connected_date_time = (time_t)atol(argv[6]);
log->status = (LinphoneCallStatus) atoi(argv[7]);
log->video_enabled = atoi(argv[8]) == 1;
log->quality = atof(argv[9]);
if (argc > 10) {
if (argv[10] != NULL) {
log->call_id = ms_strdup(argv[10]);
}
if (argv[10] != NULL) {
log->refkey = ms_strdup(argv[11]);
}
}
*list = ms_list_append(*list, log);
return 0;
}
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;
}
void linphone_core_interpret_friend_uri(LinphoneCore *lc, const char *uri, char **result){
LinphoneAddress *fr=NULL;
*result=NULL;
fr=linphone_address_new(uri);
if (fr==NULL){
char *tmp=NULL;
if (strchr(uri,'@')!=NULL){
LinphoneAddress *u;
/*try adding sip:*/
tmp=ms_strdup_printf("sip:%s",uri);
u=linphone_address_new(tmp);
if (u!=NULL){
*result=tmp;
}
}else if (lc->default_proxy!=NULL){
/*try adding domain part from default current proxy*/
LinphoneAddress * id=linphone_address_new(linphone_core_get_identity(lc));
if ((id!=NULL) && (uri[0] != '\0')){
linphone_address_set_display_name(id,NULL);
linphone_address_set_username(id,uri);
*result=linphone_address_as_string(id);
linphone_address_unref(id);
}
}
if (*result){
/*looks good */
ms_message("%s interpreted as %s",uri,*result);
}else{
ms_warning("Fail to interpret friend uri %s",uri);
}
}else {
*result=linphone_address_as_string(fr);
linphone_address_unref(fr);
}
}
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);
}
}
}
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;
}
static void linphone_vcard_phone_numbers_and_sip_addresses(void) {
LinphoneCoreManager* manager = linphone_core_manager_new2("empty_rc", FALSE);
LinphoneVcard *lvc = linphone_vcard_context_get_vcard_from_buffer(manager->lc->vcard_context, "BEGIN:VCARD\r\nVERSION:4.0\r\nFN:Sylvain Berfini\r\nIMPP:sip:[email protected]\r\nIMPP;TYPE=home:sip:[email protected]\r\nTEL;TYPE=work:0952636505\r\nEND:VCARD\r\n");
LinphoneFriend *lf = linphone_friend_new_from_vcard(lvc);
bctbx_list_t *sip_addresses = linphone_friend_get_addresses(lf);
bctbx_list_t *phone_numbers = linphone_friend_get_phone_numbers(lf);
LinphoneAddress *addr = NULL;
BC_ASSERT_EQUAL(bctbx_list_size(sip_addresses), 2, int, "%i");
BC_ASSERT_EQUAL(bctbx_list_size(phone_numbers), 1, int, "%i");
if (sip_addresses) bctbx_list_free_with_data(sip_addresses, (void (*)(void *))linphone_address_unref);
if (phone_numbers) bctbx_list_free(phone_numbers);
linphone_friend_unref(lf);
lvc = linphone_vcard_context_get_vcard_from_buffer(manager->lc->vcard_context, "BEGIN:VCARD\r\nVERSION:4.0\r\nFN:Sylvain Berfini\r\nTEL;TYPE=work:0952636505\r\nTEL:0476010203\r\nEND:VCARD\r\n");
lf = linphone_friend_new_from_vcard(lvc);
sip_addresses = linphone_friend_get_addresses(lf);
phone_numbers = linphone_friend_get_phone_numbers(lf);
BC_ASSERT_EQUAL(bctbx_list_size(sip_addresses), 0, int, "%i");
BC_ASSERT_EQUAL(bctbx_list_size(phone_numbers), 2, int, "%i");
if (sip_addresses) bctbx_list_free_with_data(sip_addresses, (void (*)(void *))linphone_address_unref);
if (phone_numbers) bctbx_list_free(phone_numbers);
addr = linphone_address_new("sip:[email protected]");
linphone_friend_add_address(lf, addr);
linphone_address_unref(addr);
sip_addresses = linphone_friend_get_addresses(lf);
BC_ASSERT_EQUAL(bctbx_list_size(sip_addresses), 1, int, "%i");
if (sip_addresses) bctbx_list_free_with_data(sip_addresses, (void (*)(void *))linphone_address_unref);
linphone_friend_remove_phone_number(lf, "0952636505");
phone_numbers = linphone_friend_get_phone_numbers(lf);
BC_ASSERT_EQUAL(bctbx_list_size(phone_numbers), 1, int, "%i");
if (phone_numbers) bctbx_list_free(phone_numbers);
linphone_friend_remove_phone_number(lf, "0476010203");
phone_numbers = linphone_friend_get_phone_numbers(lf);
BC_ASSERT_EQUAL(bctbx_list_size(phone_numbers), 0, int, "%i");
if (phone_numbers) bctbx_list_free(phone_numbers);
addr = linphone_address_new("sip:[email protected]");
linphone_friend_remove_address(lf, addr);
linphone_address_unref(addr);
sip_addresses = linphone_friend_get_addresses(lf);
BC_ASSERT_EQUAL(bctbx_list_size(sip_addresses), 0, int, "%i");
if (sip_addresses) bctbx_list_free_with_data(sip_addresses, (void (*)(void *))linphone_address_unref);
linphone_friend_add_phone_number(lf, "+33952636505");
phone_numbers = linphone_friend_get_phone_numbers(lf);
BC_ASSERT_EQUAL(bctbx_list_size(phone_numbers), 1, int, "%i");
if (phone_numbers) bctbx_list_free(phone_numbers);
linphone_friend_unref(lf);
lf = NULL;
lvc = NULL;
linphone_core_manager_destroy(manager);
}
static void linphone_vcard_phone_numbers_and_sip_addresses(void) {
LinphoneVcard *lvc = linphone_vcard_new_from_vcard4_buffer("BEGIN:VCARD\r\nVERSION:4.0\r\nFN:Sylvain Berfini\r\nIMPP:sip:[email protected]\r\nIMPP;TYPE=home:sip:[email protected]\r\nTEL;TYPE=work:0952636505\r\nEND:VCARD\r\n");
LinphoneFriend *lf = linphone_friend_new_from_vcard(lvc);
MSList *sip_addresses = linphone_friend_get_addresses(lf);
MSList *phone_numbers = linphone_friend_get_phone_numbers(lf);
LinphoneAddress *addr = NULL;
BC_ASSERT_EQUAL(ms_list_size(sip_addresses), 2, int, "%i");
BC_ASSERT_EQUAL(ms_list_size(phone_numbers), 1, int, "%i");
if (sip_addresses) ms_list_free_with_data(sip_addresses, (void (*)(void *))linphone_address_unref);
if (phone_numbers) ms_list_free(phone_numbers);
linphone_friend_unref(lf);
lvc = linphone_vcard_new_from_vcard4_buffer("BEGIN:VCARD\r\nVERSION:4.0\r\nFN:Sylvain Berfini\r\nTEL;TYPE=work:0952636505\r\nTEL:0476010203\r\nEND:VCARD\r\n");
lf = linphone_friend_new_from_vcard(lvc);
sip_addresses = linphone_friend_get_addresses(lf);
phone_numbers = linphone_friend_get_phone_numbers(lf);
BC_ASSERT_EQUAL(ms_list_size(sip_addresses), 0, int, "%i");
BC_ASSERT_EQUAL(ms_list_size(phone_numbers), 2, int, "%i");
if (sip_addresses) ms_list_free_with_data(sip_addresses, (void (*)(void *))linphone_address_unref);
if (phone_numbers) ms_list_free(phone_numbers);
addr = linphone_address_new("sip:[email protected]");
linphone_friend_add_address(lf, addr);
linphone_address_unref(addr);
sip_addresses = linphone_friend_get_addresses(lf);
BC_ASSERT_EQUAL(ms_list_size(sip_addresses), 1, int, "%i");
if (sip_addresses) ms_list_free_with_data(sip_addresses, (void (*)(void *))linphone_address_unref);
linphone_friend_remove_phone_number(lf, "0952636505");
phone_numbers = linphone_friend_get_phone_numbers(lf);
BC_ASSERT_EQUAL(ms_list_size(phone_numbers), 1, int, "%i");
if (phone_numbers) ms_list_free(phone_numbers);
linphone_friend_remove_phone_number(lf, "0476010203");
phone_numbers = linphone_friend_get_phone_numbers(lf);
BC_ASSERT_EQUAL(ms_list_size(phone_numbers), 0, int, "%i");
if (phone_numbers) ms_list_free(phone_numbers);
addr = linphone_address_new("sip:[email protected]");
linphone_friend_remove_address(lf, addr);
linphone_address_unref(addr);
sip_addresses = linphone_friend_get_addresses(lf);
BC_ASSERT_EQUAL(ms_list_size(sip_addresses), 0, int, "%i");
if (sip_addresses) ms_list_free_with_data(sip_addresses, (void (*)(void *))linphone_address_unref);
linphone_friend_add_phone_number(lf, "+33952636505");
phone_numbers = linphone_friend_get_phone_numbers(lf);
BC_ASSERT_EQUAL(ms_list_size(phone_numbers), 1, int, "%i");
if (phone_numbers) ms_list_free(phone_numbers);
linphone_friend_unref(lf);
lf = NULL;
lvc = NULL;
}
/* DB layout:
* | 0 | storage_id
* | 1 | localContact
* | 2 | remoteContact
* | 3 | direction flag
* | 4 | message
* | 5 | time (unused now, used to be string-based timestamp)
* | 6 | read flag
* | 7 | status
* | 8 | external body url
* | 9 | utc timestamp
* | 10 | app data text
* | 11 | linphone content
*/
static void create_chat_message(char **argv, void *data){
LinphoneChatRoom *cr = (LinphoneChatRoom *)data;
LinphoneAddress *from;
LinphoneAddress *to;
unsigned int storage_id = atoi(argv[0]);
// check if the message exists in the transient list, in which case we should return that one.
LinphoneChatMessage* new_message = get_transient_message(cr, storage_id);
if( new_message == NULL ){
new_message = linphone_chat_room_create_message(cr, argv[4]);
if(atoi(argv[3])==LinphoneChatMessageIncoming){
new_message->dir=LinphoneChatMessageIncoming;
from=linphone_address_new(argv[2]);
to=linphone_address_new(argv[1]);
} else {
new_message->dir=LinphoneChatMessageOutgoing;
from=linphone_address_new(argv[1]);
to=linphone_address_new(argv[2]);
}
linphone_chat_message_set_from(new_message,from);
linphone_address_destroy(from);
if (to){
linphone_chat_message_set_to(new_message,to);
linphone_address_destroy(to);
}
if( argv[9] != NULL ){
new_message->time = (time_t)atol(argv[9]);
} else {
new_message->time = time(NULL);
}
new_message->is_read=atoi(argv[6]);
new_message->state=atoi(argv[7]);
new_message->storage_id=storage_id;
new_message->external_body_url= argv[8] ? ms_strdup(argv[8]) : NULL;
new_message->appdata = argv[10]? ms_strdup(argv[10]) : NULL;
if (argv[11] != NULL) {
int id = atoi(argv[11]);
if (id >= 0) {
fetch_content_from_database(cr->lc->db, new_message, id);
}
}
}
cr->messages_hist=ms_list_prepend(cr->messages_hist,new_message);
}
/** * 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; }
static void proxy_transport_change(){
LinphoneCoreManager* lcm = create_lcm();
stats* counters = &lcm->stat;
LinphoneProxyConfig* proxy_config;
LinphoneAddress* addr;
char* addr_as_string;
LinphoneAuthInfo *info=linphone_auth_info_new(test_username,NULL,test_password,NULL,auth_domain,NULL); /*create authentication structure from identity*/
linphone_core_add_auth_info(lcm->lc,info); /*add authentication info to LinphoneCore*/
register_with_refresh_base(lcm->lc,FALSE,auth_domain,NULL);
linphone_core_get_default_proxy(lcm->lc,&proxy_config);
reset_counters(counters); /*clear stats*/
linphone_proxy_config_edit(proxy_config);
CU_ASSERT_FALSE(wait_for_until(lcm->lc,lcm->lc,&counters->number_of_LinphoneRegistrationCleared,1,3000));
addr = linphone_address_new(linphone_proxy_config_get_addr(proxy_config));
if (LinphoneTransportTcp == linphone_address_get_transport(addr)) {
linphone_address_set_transport(addr,LinphoneTransportUdp);
} else {
linphone_address_set_transport(addr,LinphoneTransportTcp);
}
linphone_proxy_config_set_server_addr(proxy_config,addr_as_string=linphone_address_as_string(addr));
linphone_proxy_config_done(proxy_config);
CU_ASSERT(wait_for(lcm->lc,lcm->lc,&counters->number_of_LinphoneRegistrationOk,1));
/*as we change p[roxy server destination, we should'nt be notified about the clear*/
CU_ASSERT_EQUAL(counters->number_of_LinphoneRegistrationCleared,0);
ms_free(addr_as_string);
linphone_address_destroy(addr);
linphone_core_manager_destroy(lcm);
}
static int sip_login_do_login(SipSetupContext * ctx, const char *uri, const char *passwd){
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),NULL,passwd,NULL,NULL);
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;
}
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;
}
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;
}
void linphone_subscription_new(LinphoneCore *lc, SalOp *op, const char *from){
LinphoneFriend *lf=NULL;
char *tmp;
LinphoneAddress *uri;
uri=linphone_address_new(from);
linphone_address_clean(uri);
tmp=linphone_address_as_string(uri);
ms_message("Receiving new subscription from %s.",from);
/* check if we answer to this subscription */
if (linphone_find_friend(lc->friends,uri,&lf)!=NULL){
lf->insub=op;
lf->inc_subscribe_pending=TRUE;
sal_subscribe_accept(op);
linphone_friend_done(lf); /*this will do all necessary actions */
}else{
/* check if this subscriber is in our black list */
if (linphone_find_friend(lc->subscribers,uri,&lf)){
if (lf->pol==LinphoneSPDeny){
ms_message("Rejecting %s because we already rejected it once.",from);
sal_subscribe_decline(op);
}
else {
/* else it is in wait for approval state, because otherwise it is in the friend list.*/
ms_message("New subscriber found in friend list, in %s state.",__policy_enum_to_str(lf->pol));
}
}else {
sal_subscribe_accept(op);
linphone_core_add_subscriber(lc,tmp,op);
}
}
linphone_address_destroy(uri);
ms_free(tmp);
}
LinphoneFriend *linphone_friend_new_from_vcard(LinphoneVcard *vcard) {
LinphoneAddress* linphone_address = NULL;
LinphoneFriend *fr;
char *name = NULL;
bctbx_list_t *sipAddresses = NULL;
if (vcard == NULL) {
ms_error("Cannot create friend from null vcard");
return NULL;
}
name = ms_strdup(linphone_vcard_get_full_name(vcard));
sipAddresses = linphone_vcard_get_sip_addresses(vcard);
fr = linphone_friend_new();
// Currently presence takes too much time when dealing with hundreds of friends, so I disabled it for now
fr->pol = LinphoneSPDeny;
fr->subscribe = FALSE;
if (sipAddresses) {
const char *sipAddress = (const char *)sipAddresses->data;
linphone_address = linphone_address_new(sipAddress);
if (linphone_address) {
linphone_friend_set_address(fr, linphone_address);
linphone_address_unref(linphone_address);
}
bctbx_list_free(sipAddresses);
}
fr->vcard = vcard;
if (name) {
linphone_friend_set_name(fr, name);
}
ms_free(name);
return fr;
}
bctbx_list_t* linphone_friend_get_addresses(LinphoneFriend *lf) {
LinphoneVcard *vcard = NULL;
bctbx_list_t *sipAddresses = NULL;
bctbx_list_t *addresses = NULL;
bctbx_list_t *iterator = NULL;
if (!lf) {
return NULL;
}
vcard = lf->vcard;
if (!vcard) {
return lf->uri ? bctbx_list_append(addresses, lf->uri) : NULL;
}
sipAddresses = linphone_vcard_get_sip_addresses(vcard);
iterator = sipAddresses;
while (iterator) {
const char *sipAddress = (const char *)iterator->data;
LinphoneAddress *addr = linphone_address_new(sipAddress);
if (addr) {
addresses = bctbx_list_append(addresses, addr);
}
iterator = bctbx_list_next(iterator);
}
if (sipAddresses) bctbx_list_free(sipAddresses);
return addresses;
}
/* DB layout:
* | 0 | storage_id
* | 1 | friend_list_id
* | 2 | sip_uri
* | 3 | subscribe_policy
* | 4 | send_subscribe
* | 5 | ref_key
* | 6 | vCard
* | 7 | vCard eTag
* | 8 | vCard URL
* | 9 | presence_received
*/
static int create_friend(void *data, int argc, char **argv, char **colName) {
LinphoneVcardContext *context = (LinphoneVcardContext *)data;
bctbx_list_t **list = (bctbx_list_t **)linphone_vcard_context_get_user_data(context);
LinphoneFriend *lf = NULL;
LinphoneVcard *vcard = NULL;
unsigned int storage_id = (unsigned int)atoi(argv[0]);
vcard = linphone_vcard_context_get_vcard_from_buffer(context, argv[6]);
if (vcard) {
linphone_vcard_set_etag(vcard, argv[7]);
linphone_vcard_set_url(vcard, argv[8]);
lf = linphone_friend_new_from_vcard(vcard);
}
if (!lf) {
LinphoneAddress *addr = linphone_address_new(argv[2]);
lf = linphone_friend_new();
linphone_friend_set_address(lf, addr);
linphone_address_unref(addr);
}
linphone_friend_set_inc_subscribe_policy(lf, atoi(argv[3]));
linphone_friend_send_subscribe(lf, atoi(argv[4]));
linphone_friend_set_ref_key(lf, ms_strdup(argv[5]));
lf->presence_received = atoi(argv[9]);
lf->storage_id = storage_id;
*list = bctbx_list_append(*list, linphone_friend_ref(lf));
linphone_friend_unref(lf);
return 0;
}
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();
}
void linphone_core_message_received(LinphoneCore *lc, const char *from, const char *raw_msg,const char* external_url) {
MSList *elem;
LinphoneChatRoom *cr=NULL;
LinphoneAddress *addr;
char *cleanfrom;
LinphoneChatMessage* msg;
addr=linphone_address_new(from);
linphone_address_clean(addr);
for(elem=lc->chatrooms; elem!=NULL; elem=ms_list_next(elem)) {
cr=(LinphoneChatRoom*)elem->data;
if (linphone_chat_room_matches(cr,addr)) {
break;
}
cr=NULL;
}
cleanfrom=linphone_address_as_string(addr);
if (cr==NULL) {
/* create a new chat room */
cr=linphone_core_create_chat_room(lc,cleanfrom);
}
msg = linphone_chat_room_create_message(cr, raw_msg);
linphone_chat_message_set_from(msg, cr->peer_url);
if (external_url) {
linphone_chat_message_set_external_body_url(msg, external_url);
}
linphone_address_destroy(addr);
linphone_chat_room_message_received(cr,lc,msg);
ms_free(cleanfrom);
}
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);
}
}
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);
}
/* DB layout:
* | 0 | storage_id
* | 1 | from
* | 2 | to
* | 3 | direction flag
* | 4 | duration
* | 5 | start date time (time_t)
* | 6 | connected date time (time_t)
* | 7 | status
* | 8 | video enabled (1 or 0)
* | 9 | quality
* | 10 | call_id
* | 11 | refkey
*/
static int create_call_log(void *data, int argc, char **argv, char **colName) {
bctbx_list_t **list = (bctbx_list_t **)data;
LinphoneAddress *from;
LinphoneAddress *to;
LinphoneCallDir dir;
LinphoneCallLog *log;
unsigned int storage_id = (unsigned int)atoi(argv[0]);
from = linphone_address_new(argv[1]);
to = linphone_address_new(argv[2]);
if (from == NULL || to == NULL) goto error;
dir = (LinphoneCallDir) atoi(argv[3]);
log = linphone_call_log_new(dir, from, to);
log->storage_id = storage_id;
log->duration = atoi(argv[4]);
log->start_date_time = (time_t)atol(argv[5]);
set_call_log_date(log,log->start_date_time);
log->connected_date_time = (time_t)atol(argv[6]);
log->status = (LinphoneCallStatus) atoi(argv[7]);
log->video_enabled = atoi(argv[8]) == 1;
log->quality = (float)atof(argv[9]);
if (argc > 10) {
if (argv[10] != NULL) {
log->call_id = ms_strdup(argv[10]);
}
if (argv[10] != NULL) {
log->refkey = ms_strdup(argv[11]);
}
}
*list = bctbx_list_append(*list, log);
return 0;
error:
if (from){
linphone_address_destroy(from);
}
if (to){
linphone_address_destroy(to);
}
ms_error("Bad call log at storage_id %u", storage_id);
return 0;
}
// Implementation of setUsername method.
void PhpLinphoneAuth::setUsername(Php::Parameters ¶meters) {
std::string user = parameters[0];
this->username = user;
this->from = linphone_address_new((this->username).c_str());
if (this->from == nullptr) {
Php::error<<"The username specified is not a valid sip URI."<<std::endl;
}
}
AddressAPI::AddressAPI(StringPtr const &uri) :
WrapperAPI(APIDescription(this)) {
FBLOG_DEBUG("AddressAPI::AddressAPI", "this=" << this);
mAddress = linphone_address_new(STRING_TO_CHARPTR(uri));
if(mAddress == NULL) {
throw std::invalid_argument("uri is invalid");
}
}
static void history_messages_count() {
LinphoneCoreManager *marie = linphone_core_manager_new("marie_rc");
LinphoneAddress *jehan_addr = linphone_address_new("<sip:[email protected]>");
LinphoneChatRoom *chatroom;
MSList *messages;
char src_db[256];
char tmp_db[256];
snprintf(src_db,sizeof(src_db), "%s/messages.db", liblinphone_tester_file_prefix);
snprintf(tmp_db,sizeof(tmp_db), "%s/tmp.db", liblinphone_tester_writable_dir_prefix);
CU_ASSERT_EQUAL_FATAL(message_tester_copy_file(src_db, tmp_db), 0);
linphone_core_set_chat_database_path(marie->lc, tmp_db);
chatroom = linphone_core_get_chat_room(marie->lc, jehan_addr);
CU_ASSERT_PTR_NOT_NULL(chatroom);
if (chatroom){
messages=linphone_chat_room_get_history(chatroom,10);
CU_ASSERT_EQUAL(ms_list_size(messages), 10);
ms_list_free_with_data(messages, (void (*)(void*))linphone_chat_message_unref);
messages=linphone_chat_room_get_history(chatroom,1);
CU_ASSERT_EQUAL(ms_list_size(messages), 1);
ms_list_free_with_data(messages, (void (*)(void*))linphone_chat_message_unref);
messages=linphone_chat_room_get_history(chatroom,0);
CU_ASSERT_EQUAL(linphone_chat_room_get_history_size(chatroom), 1270);
CU_ASSERT_EQUAL(ms_list_size(messages), 1270);
/*check the second most recent message*/
CU_ASSERT_STRING_EQUAL(linphone_chat_message_get_text((LinphoneChatMessage *)messages->next->data), "Fore and aft follow each other.");
ms_list_free_with_data(messages, (void (*)(void*))linphone_chat_message_unref);
/*test offset+limit: retrieve the 42th latest message only and check its content*/
messages=linphone_chat_room_get_history_range(chatroom, 42, 42);
CU_ASSERT_EQUAL(ms_list_size(messages), 1);
CU_ASSERT_STRING_EQUAL(linphone_chat_message_get_text((LinphoneChatMessage *)messages->data), "If you open yourself to the Tao is intangible and evasive, yet prefers to keep us at the mercy of the kingdom, then all of the streams of hundreds of valleys because of its limitless possibilities.");
ms_list_free_with_data(messages, (void (*)(void*))linphone_chat_message_unref);
/*test offset without limit*/
messages = linphone_chat_room_get_history_range(chatroom, 1265, -1);
CU_ASSERT_EQUAL(ms_list_size(messages), 1270-1265);
ms_list_free_with_data(messages, (void (*)(void*))linphone_chat_message_unref);
/*test limit without offset*/
messages = linphone_chat_room_get_history_range(chatroom, 0, 5);
CU_ASSERT_EQUAL(ms_list_size(messages), 6);
ms_list_free_with_data(messages, (void (*)(void*))linphone_chat_message_unref);
/*test invalid start*/
messages = linphone_chat_room_get_history_range(chatroom, 1265, 1260);
CU_ASSERT_EQUAL(ms_list_size(messages), 1270-1265);
ms_list_free_with_data(messages, (void (*)(void*))linphone_chat_message_unref);
}
linphone_core_manager_destroy(marie);
linphone_address_destroy(jehan_addr);
remove(tmp_db);
}
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;
}
// Called when fetching all conversations from database
static int callback_all(void *data, int argc, char **argv, char **colName){
LinphoneCore* lc = (LinphoneCore*) data;
char* address = argv[0];
LinphoneAddress *addr = linphone_address_new(address);
if (addr){
linphone_core_get_chat_room(lc, addr);
linphone_address_destroy(addr);
}
return 0;
}
void linphone_core_message_received(LinphoneCore *lc, SalOp *op, const SalMessage *sal_msg){
LinphoneChatRoom *cr=NULL;
LinphoneAddress *addr;
char *cleanfrom;
char *from;
LinphoneChatMessage* msg;
const SalCustomHeader *ch;
addr=linphone_address_new(sal_msg->from);
linphone_address_clean(addr);
cr=linphone_core_get_chat_room(lc,addr);
cleanfrom=linphone_address_as_string(addr);
from=linphone_address_as_string_uri_only(addr);
if (cr==NULL){
/* create a new chat room */
cr=linphone_core_create_chat_room(lc,cleanfrom);
}
msg = linphone_chat_room_create_message(cr, sal_msg->text);
linphone_chat_message_set_from(msg, cr->peer_url);
{
LinphoneAddress *to;
to=sal_op_get_to(op) ? linphone_address_new(sal_op_get_to(op)) : linphone_address_new(linphone_core_get_identity(lc));
msg->to=to;
}
msg->time=sal_msg->time;
msg->state=LinphoneChatMessageStateDelivered;
msg->is_read=FALSE;
msg->dir=LinphoneChatMessageIncoming;
ch=sal_op_get_recv_custom_header(op);
if (ch) msg->custom_headers=sal_custom_header_clone(ch);
if (sal_msg->url) {
linphone_chat_message_set_external_body_url(msg, sal_msg->url);
}
linphone_address_destroy(addr);
msg->storage_id=linphone_chat_message_store(msg);
linphone_chat_room_message_received(cr,lc,msg);
ms_free(cleanfrom);
ms_free(from);
}
void linphone_friend_list_update_subscriptions(LinphoneFriendList *list, LinphoneProxyConfig *cfg, bool_t only_when_registered) {
const bctbx_list_t *elem;
if (list->rls_uri != NULL) {
if (list->enable_subscriptions) {
LinphoneAddress *address = linphone_address_new(list->rls_uri);
char *xml_content = create_resource_list_xml(list);
if ((address != NULL) && (xml_content != NULL) && (linphone_friend_list_has_subscribe_inactive(list) == TRUE)) {
unsigned char digest[16];
bctbx_md5((unsigned char *)xml_content, strlen(xml_content), digest);
if ((list->event != NULL) && (list->content_digest != NULL) && (memcmp(list->content_digest, digest, sizeof(digest)) == 0)) {
/* The content has not changed, only refresh the event. */
linphone_event_refresh_subscribe(list->event);
} else {
LinphoneContent *content;
int expires = lp_config_get_int(list->lc->config, "sip", "rls_presence_expires", 3600);
list->expected_notification_version = 0;
if (list->content_digest != NULL) ms_free(list->content_digest);
list->content_digest = ms_malloc(sizeof(digest));
memcpy(list->content_digest, digest, sizeof(digest));
if (list->event != NULL) {
linphone_event_terminate(list->event);
linphone_event_unref(list->event);
}
list->event = linphone_core_create_subscribe(list->lc, address, "presence", expires);
linphone_event_ref(list->event);
linphone_event_set_internal(list->event, TRUE);
linphone_event_add_custom_header(list->event, "Require", "recipient-list-subscribe");
linphone_event_add_custom_header(list->event, "Supported", "eventlist");
linphone_event_add_custom_header(list->event, "Accept", "multipart/related, application/pidf+xml, application/rlmi+xml");
linphone_event_add_custom_header(list->event, "Content-Disposition", "recipient-list");
content = linphone_core_create_content(list->lc);
linphone_content_set_type(content, "application");
linphone_content_set_subtype(content, "resource-lists+xml");
linphone_content_set_string_buffer(content, xml_content);
if (linphone_core_content_encoding_supported(list->lc, "deflate")) {
linphone_content_set_encoding(content, "deflate");
linphone_event_add_custom_header(list->event, "Accept-Encoding", "deflate");
}
linphone_event_send_subscribe(list->event, content);
linphone_content_unref(content);
linphone_event_set_user_data(list->event, list);
}
}
if (address != NULL) linphone_address_unref(address);
if (xml_content != NULL) ms_free(xml_content);
} else {
ms_message("Friends list [%p] subscription update skipped since subscriptions not enabled yet", list);
}
} else if (list->enable_subscriptions) {
for (elem = list->friends; elem != NULL; elem = elem->next) {
LinphoneFriend *lf = (LinphoneFriend *)elem->data;
linphone_friend_update_subscribes(lf, cfg, only_when_registered);
}
}
}
