sjero.net Git - linphone/blob - coreapi/friend.c

   1 /***************************************************************************
   2  *            friend.c
   3  *
   4  *  Sat May 15 15:25:16 2004
   5  *  Copyright  2004-2009  Simon Morlat
   6  *  Email
   7  ****************************************************************************/
   8
   9 /*
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU Library General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23  */
  24
  25 #include "linphonecore.h"
  26 #include "private.h"
  27 #include <eXosip2/eXosip.h>
  28 #include <osipparser2/osip_message.h>
  29 #include "lpconfig.h"
  30
  31 const char *linphone_online_status_to_string(LinphoneOnlineStatus ss){
  32         const char *str=NULL;
  33         switch(ss){
  34                 case LINPHONE_STATUS_ONLINE:
  35                 str=_("Online");
  36                 break;
  37                 case LINPHONE_STATUS_BUSY:
  38                 str=_("Busy");
  39                 break;
  40                 case LINPHONE_STATUS_BERIGHTBACK:
  41                 str=_("Be right back");
  42                 break;
  43                 case LINPHONE_STATUS_AWAY:
  44                 str=_("Away");
  45                 break;
  46                 case LINPHONE_STATUS_ONTHEPHONE:
  47                 str=_("On the phone");
  48                 break;
  49                 case LINPHONE_STATUS_OUTTOLUNCH:
  50                 str=_("Out to lunch");
  51                 break;
  52                 case LINPHONE_STATUS_NOT_DISTURB:
  53                 str=_("Do not disturb");
  54                 break;
  55                 case LINPHONE_STATUS_MOVED:
  56                 str=_("Moved");
  57                 break;
  58                 case LINPHONE_STATUS_ALT_SERVICE:
  59                 str=_("Using another messaging service");
  60                 break;
  61                 case LINPHONE_STATUS_OFFLINE:
  62                 str=_("Offline");
  63                 break;
  64                 case LINPHONE_STATUS_PENDING:
  65                 str=_("Pending");
  66                 break;
  67                 default:
  68                 str=_("Unknown-bug");
  69         }
  70         return str;
  71 }
  72
  73 static int friend_data_compare(const void * a, const void * b, void * data){
  74         LinphoneAddress *fa=((LinphoneFriend*)a)->uri;
  75         LinphoneAddress *fb=((LinphoneFriend*)b)->uri;
  76         const char *ua,*ub;
  77         ua=linphone_address_get_username(fa);
  78         ub=linphone_address_get_username(fb);
  79         if (ua!=NULL && ub!=NULL) {
  80                 //printf("Comparing usernames %s,%s\n",ua,ub);
  81                 return strcasecmp(ua,ub);
  82         }
  83         else {
  84                 /* compare hosts*/
  85                 ua=linphone_address_get_domain(fa);
  86                 ub=linphone_address_get_domain(fb);
  87                 if (ua!=NULL && ub!=NULL){
  88                         int ret=strcasecmp(ua,ub);
  89                         //printf("Comparing hostnames %s,%s,res=%i\n",ua,ub,ret);
  90                         return ret;
  91                 }
  92                 else return -1;
  93         }
  94 }
  95
  96 static int friend_compare(const void * a, const void * b){
  97         return friend_data_compare(a,b,NULL);
  98 }
  99
 100
 101 MSList *linphone_find_friend(MSList *fl, const LinphoneAddress *friend, LinphoneFriend **lf){
 102         MSList *res=NULL;
 103         LinphoneFriend dummy;
 104         if (lf!=NULL) *lf=NULL;
 105         dummy.uri=(LinphoneAddress*)friend;
 106         res=ms_list_find_custom(fl,friend_compare,&dummy);
 107         if (lf!=NULL && res!=NULL) *lf=(LinphoneFriend*)res->data;
 108         return res;
 109 }
 110
 111 LinphoneFriend *linphone_find_friend_by_inc_subscribe(MSList *l, SalOp *op){
 112         MSList *elem;
 113         for (elem=l;elem!=NULL;elem=elem->next){
 114                 LinphoneFriend *lf=(LinphoneFriend*)elem->data;
 115                 if (lf->insub==op) return lf;
 116         }
 117         return NULL;
 118 }
 119
 120 LinphoneFriend *linphone_find_friend_by_out_subscribe(MSList *l, SalOp *op){
 121         MSList *elem;
 122         for (elem=l;elem!=NULL;elem=elem->next){
 123                 LinphoneFriend *lf=(LinphoneFriend*)elem->data;
 124                 if (lf->outsub==op) return lf;
 125         }
 126         return NULL;
 127 }
 128
 129 void __linphone_friend_do_subscribe(LinphoneFriend *fr){
 130         char *friend=NULL;
 131         const char *route=NULL;
 132         const char *from=NULL;
 133         LinphoneProxyConfig *cfg;
 134
 135         friend=linphone_address_as_string(fr->uri);
 136         cfg=linphone_core_lookup_known_proxy(fr->lc,linphone_friend_get_address(fr));
 137         if (cfg!=NULL){
 138                 route=linphone_proxy_config_get_route(cfg);
 139                 from=linphone_proxy_config_get_identity(cfg);
 140         }else from=linphone_core_get_primary_contact(fr->lc);
 141         if (fr->outsub==NULL){
 142                 /* people for which we don't have yet an answer should appear as offline */
 143                 fr->status=LINPHONE_STATUS_OFFLINE;
 144                 /*
 145                 if (fr->lc->vtable.notify_recv)
 146                         fr->lc->vtable.notify_recv(fr->lc,(LinphoneFriend*)fr);
 147                  */
 148         }else{
 149                 sal_op_release(fr->outsub);
 150                 fr->outsub=NULL;
 151         }
 152         fr->outsub=sal_op_new(fr->lc->sal);
 153         sal_op_set_route(fr->outsub,route);
 154         sal_subscribe_presence(fr->outsub,from,friend);
 155         fr->subscribe_active=TRUE;
 156         ms_free(friend);
 157 }
 158
 159 LinphoneFriend * linphone_friend_new(){
 160         LinphoneFriend *obj=ms_new0(LinphoneFriend,1);
 161         obj->pol=LinphoneSPAccept;
 162         obj->status=LINPHONE_STATUS_OFFLINE;
 163         obj->subscribe=TRUE;
 164         return obj;
 165 }
 166
 167 LinphoneFriend *linphone_friend_new_with_addr(const char *addr){
 168         LinphoneFriend *fr=linphone_friend_new();
 169         if (linphone_friend_set_sip_addr(fr,addr)<0){
 170                 linphone_friend_destroy(fr);
 171                 return NULL;
 172         }
 173         return fr;
 174 }
 175
 176 bool_t linphone_friend_in_list(const LinphoneFriend *lf){
 177         return lf->lc!=NULL;
 178 }
 179
 180 void linphone_core_interpret_friend_uri(LinphoneCore *lc, const char *uri, char **result){
 181         LinphoneAddress *fr=NULL;
 182         *result=NULL;
 183         fr=linphone_address_new(uri);
 184         if (fr==NULL){
 185                 char *tmp=NULL;
 186                 if (strchr(uri,'@')!=NULL){
 187                         LinphoneAddress *u;
 188                         /*try adding sip:*/
 189                         tmp=ms_strdup_printf("sip:%s",uri);
 190                         u=linphone_address_new(tmp);
 191                         if (u!=NULL){
 192                                 *result=tmp;
 193                         }
 194                 }else if (lc->default_proxy!=NULL){
 195                         /*try adding domain part from default current proxy*/
 196                         LinphoneAddress * id=linphone_address_new(linphone_core_get_identity(lc));
 197                         if (id!=NULL){
 198                                 linphone_address_set_username(id,uri);
 199                                 *result=linphone_address_as_string(id);
 200                                 linphone_address_destroy(id);
 201                         }
 202                 }
 203                 if (*result){
 204                         /*looks good */
 205                         ms_message("%s interpreted as %s",uri,*result);
 206                 }else{
 207                         ms_warning("Fail to interpret friend uri %s",uri);
 208                 }
 209         }else *result=linphone_address_as_string(fr);
 210         linphone_address_destroy(fr);
 211 }
 212
 213 int linphone_friend_set_sip_addr(LinphoneFriend *lf, const char *addr){
 214         LinphoneAddress *fr=linphone_address_new(addr);
 215         if (fr==NULL) {
 216                 ms_warning("Invalid friend sip uri: %s",addr);
 217                 return -1;
 218         }
 219         linphone_address_clean(fr);
 220         if (lf->uri!=NULL) linphone_address_destroy(lf->uri);
 221         lf->uri=fr;
 222         return 0;
 223 }
 224
 225 int linphone_friend_set_name(LinphoneFriend *lf, const char *name){
 226         LinphoneAddress *fr=lf->uri;
 227         if (fr==NULL){
 228                 ms_error("linphone_friend_set_sip_addr() must be called before linphone_friend_set_name().");
 229                 return -1;
 230         }
 231         linphone_address_set_display_name(fr,name);
 232         return 0;
 233 }
 234
 235 int linphone_friend_send_subscribe(LinphoneFriend *fr, bool_t val){
 236         fr->subscribe=val;
 237         return 0;
 238 }
 239
 240 int linphone_friend_set_inc_subscribe_policy(LinphoneFriend *fr, LinphoneSubscribePolicy pol)
 241 {
 242         fr->pol=pol;
 243         return 0;
 244 }
 245
 246 SalPresenceStatus linphone_online_status_to_sal(LinphoneOnlineStatus os){
 247         switch(os){
 248                 case LINPHONE_STATUS_OFFLINE:
 249                         return SalPresenceOffline;
 250                 break;
 251                 case LINPHONE_STATUS_ONLINE:
 252                         return SalPresenceOnline;
 253                 break;
 254                 case LINPHONE_STATUS_BUSY:
 255                         return SalPresenceBusy;
 256                 break;
 257                 case LINPHONE_STATUS_BERIGHTBACK:
 258                         return SalPresenceBerightback;
 259                 break;
 260                 case LINPHONE_STATUS_AWAY:
 261                         return SalPresenceAway;
 262                 break;
 263                 case LINPHONE_STATUS_ONTHEPHONE:
 264                         return SalPresenceOnthephone;
 265                 break;
 266                 case LINPHONE_STATUS_OUTTOLUNCH:
 267                         return SalPresenceOuttolunch;
 268                 break;
 269                 case LINPHONE_STATUS_NOT_DISTURB:
 270                         return SalPresenceDonotdisturb;
 271                 break;
 272                 case LINPHONE_STATUS_MOVED:
 273                         return SalPresenceMoved;
 274                 break;
 275                 case LINPHONE_STATUS_ALT_SERVICE:
 276                         return SalPresenceAltService;
 277                 break;
 278                 case LINPHONE_STATUS_PENDING:
 279                         return SalPresenceOffline;
 280                 break;
 281                 default:
 282                         return SalPresenceOffline;
 283                 break;
 284         }
 285         return SalPresenceOffline;
 286 }
 287
 288 void linphone_friend_notify(LinphoneFriend *lf, LinphoneOnlineStatus os){
 289         //printf("Wish to notify %p, lf->nid=%i\n",lf,lf->nid);
 290         if (lf->insub!=NULL){
 291                 sal_notify_presence(lf->insub,linphone_online_status_to_sal(os),NULL);
 292         }
 293 }
 294
 295 static void linphone_friend_unsubscribe(LinphoneFriend *lf){
 296         if (lf->outsub!=NULL) {
 297                 sal_unsubscribe(lf->outsub);
 298                 sal_op_release(lf->outsub);
 299                 lf->outsub=NULL;
 300                 lf->subscribe_active=FALSE;
 301         }
 302 }
 303
 304 void linphone_friend_close_subscriptions(LinphoneFriend *lf){
 305         linphone_friend_unsubscribe(lf);
 306         if (lf->insub){
 307                 sal_notify_close(lf->insub);
 308                 sal_op_release(lf->insub);
 309                 lf->insub=NULL;
 310         }
 311 }
 312
 313 void linphone_friend_destroy(LinphoneFriend *lf){
 314
 315         if (lf->uri!=NULL) linphone_address_destroy(lf->uri);
 316         if (lf->info!=NULL) buddy_info_free(lf->info);
 317         ms_free(lf);
 318 }
 319
 320 const LinphoneAddress *linphone_friend_get_address(const LinphoneFriend *lf){
 321         return lf->uri;
 322 }
 323
 324 bool_t linphone_friend_get_send_subscribe(const LinphoneFriend *lf){
 325         return lf->subscribe;
 326 }
 327
 328 LinphoneSubscribePolicy linphone_friend_get_inc_subscribe_policy(const LinphoneFriend *lf){
 329         return lf->pol;
 330 }
 331
 332 LinphoneOnlineStatus linphone_friend_get_status(const LinphoneFriend *lf){
 333         return lf->status;
 334 }
 335
 336 BuddyInfo * linphone_friend_get_info(const LinphoneFriend *lf){
 337         return lf->info;
 338 }
 339
 340 void linphone_friend_apply(LinphoneFriend *fr, LinphoneCore *lc){
 341         if (fr->uri==NULL) {
 342                 ms_warning("No sip url defined.");
 343                 return;
 344         }
 345         fr->lc=lc;
 346
 347         linphone_core_write_friends_config(lc);
 348
 349         if (fr->inc_subscribe_pending){
 350                 switch(fr->pol){
 351                         case LinphoneSPWait:
 352                                 linphone_friend_notify(fr,LINPHONE_STATUS_PENDING);
 353                                 break;
 354                         case LinphoneSPAccept:
 355                                 if (fr->lc!=NULL)
 356                                   {
 357                                         linphone_friend_notify(fr,fr->lc->presence_mode);
 358                                   }
 359                                 break;
 360                         case LinphoneSPDeny:
 361                                 linphone_friend_notify(fr,LINPHONE_STATUS_OFFLINE);
 362                                 break;
 363                 }
 364                 fr->inc_subscribe_pending=FALSE;
 365         }
 366         if (fr->subscribe && fr->subscribe_active==FALSE){
 367                 ms_message("Sending a new SUBSCRIBE");
 368                 __linphone_friend_do_subscribe(fr);
 369         }
 370         ms_message("linphone_friend_apply() done.");
 371         lc->bl_refresh=TRUE;
 372 }
 373
 374 void linphone_friend_edit(LinphoneFriend *fr){
 375 }
 376
 377 void linphone_friend_done(LinphoneFriend *fr){
 378         ms_return_if_fail(fr!=NULL);
 379         if (fr->lc==NULL) return;
 380         linphone_friend_apply(fr,fr->lc);
 381 }
 382
 383 void linphone_core_add_friend(LinphoneCore *lc, LinphoneFriend *lf)
 384 {
 385         ms_return_if_fail(lf->lc==NULL);
 386         ms_return_if_fail(lf->uri!=NULL);
 387         if (ms_list_find(lc->friends,lf)!=NULL){
 388                 char *tmp=NULL;
 389                 const LinphoneAddress *addr=linphone_friend_get_address(lf);
 390                 if (addr) tmp=linphone_address_as_string(addr);
 391                 ms_warning("Friend %s already in list, ignored.", tmp ? tmp : "unknown");
 392                 if (tmp) ms_free(tmp);
 393                 return ;
 394         }
 395         lc->friends=ms_list_append(lc->friends,lf);
 396         linphone_friend_apply(lf,lc);
 397         return ;
 398 }
 399
 400 void linphone_core_remove_friend(LinphoneCore *lc, LinphoneFriend* fl){
 401         MSList *el=ms_list_find(lc->friends,(void *)fl);
 402         if (el!=NULL){
 403                 lc->friends=ms_list_remove_link(lc->friends,el);
 404                 linphone_friend_destroy((LinphoneFriend*)el->data);
 405                 linphone_core_write_friends_config(lc);
 406         }
 407 }
 408
 409 void linphone_friend_set_ref_key(LinphoneFriend *lf, const char *key){
 410         if (lf->refkey!=NULL){
 411                 ms_free(lf->refkey);
 412                 lf->refkey=NULL;
 413         }
 414         if (key)
 415                 lf->refkey=ms_strdup(key);
 416         if (lf->lc)
 417                 linphone_core_write_friends_config(lf->lc);
 418 }
 419
 420 const char *linphone_friend_get_ref_key(const LinphoneFriend *lf){
 421         return lf->refkey;
 422 }
 423
 424 static bool_t username_match(const char *u1, const char *u2){
 425         if (u1==NULL && u2==NULL) return TRUE;
 426         if (u1 && u2 && strcasecmp(u1,u2)==0) return TRUE;
 427         return FALSE;
 428 }
 429
 430 LinphoneFriend *linphone_core_get_friend_by_address(const LinphoneCore *lc, const char *uri){
 431         LinphoneAddress *puri=linphone_address_new(uri);
 432         const MSList *elem;
 433         const char *username=linphone_address_get_username(puri);
 434         const char *domain=linphone_address_get_domain(puri);
 435         LinphoneFriend *lf=NULL;
 436
 437         if (puri==NULL){
 438                 return NULL;
 439         }
 440         for(elem=lc->friends;elem!=NULL;elem=ms_list_next(elem)){
 441                 lf=(LinphoneFriend*)elem->data;
 442                 const char *it_username=linphone_address_get_username(lf->uri);
 443                 const char *it_host=linphone_address_get_domain(lf->uri);;
 444                 if (strcasecmp(domain,it_host)==0 && username_match(username,it_username)){
 445                         break;
 446                 }
 447                 lf=NULL;
 448         }
 449         linphone_address_destroy(puri);
 450         return lf;
 451 }
 452
 453 LinphoneFriend *linphone_core_get_friend_by_ref_key(const LinphoneCore *lc, const char *key){
 454         const MSList *elem;
 455         if (key==NULL) return NULL;
 456         for(elem=linphone_core_get_friend_list(lc);elem!=NULL;elem=elem->next){
 457                 LinphoneFriend *lf=(LinphoneFriend*)elem->data;
 458                 if (lf->refkey!=NULL && strcmp(lf->refkey,key)==0){
 459                         return lf;
 460                 }
 461         }
 462         return NULL;
 463 }
 464
 465 #define key_compare(s1,s2)      strcmp(s1,s2)
 466
 467 LinphoneSubscribePolicy __policy_str_to_enum(const char* pol){
 468         if (key_compare("accept",pol)==0){
 469                 return LinphoneSPAccept;
 470         }
 471         if (key_compare("deny",pol)==0){
 472                 return LinphoneSPDeny;
 473         }
 474         if (key_compare("wait",pol)==0){
 475                 return LinphoneSPWait;
 476         }
 477         ms_warning("Unrecognized subscribe policy: %s",pol);
 478         return LinphoneSPWait;
 479 }
 480
 481 LinphoneProxyConfig *__index_to_proxy(LinphoneCore *lc, int index){
 482         if (index>=0) return (LinphoneProxyConfig*)ms_list_nth_data(lc->sip_conf.proxies,index);
 483         else return NULL;
 484 }
 485
 486 LinphoneFriend * linphone_friend_new_from_config_file(LinphoneCore *lc, int index){
 487         const char *tmp;
 488         char item[50];
 489         int a;
 490         LinphoneFriend *lf;
 491         LpConfig *config=lc->config;
 492
 493         sprintf(item,"friend_%i",index);
 494
 495         if (!lp_config_has_section(config,item)){
 496                 return NULL;
 497         }
 498
 499         tmp=lp_config_get_string(config,item,"url",NULL);
 500         if (tmp==NULL) {
 501                 return NULL;
 502         }
 503         lf=linphone_friend_new_with_addr(tmp);
 504         if (lf==NULL) {
 505                 return NULL;
 506         }
 507         tmp=lp_config_get_string(config,item,"pol",NULL);
 508         if (tmp==NULL) linphone_friend_set_inc_subscribe_policy(lf,LinphoneSPWait);
 509         else{
 510                 linphone_friend_set_inc_subscribe_policy(lf,__policy_str_to_enum(tmp));
 511         }
 512         a=lp_config_get_int(config,item,"subscribe",0);
 513         linphone_friend_send_subscribe(lf,a);
 514
 515         linphone_friend_set_ref_key(lf,lp_config_get_string(config,item,"refkey",NULL));
 516         return lf;
 517 }
 518
 519 const char *__policy_enum_to_str(LinphoneSubscribePolicy pol){
 520         switch(pol){
 521                 case LinphoneSPAccept:
 522                         return "accept";
 523                         break;
 524                 case LinphoneSPDeny:
 525                         return "deny";
 526                         break;
 527                 case LinphoneSPWait:
 528                         return "wait";
 529                         break;
 530         }
 531         ms_warning("Invalid policy enum value.");
 532         return "wait";
 533 }
 534
 535 void linphone_friend_write_to_config_file(LpConfig *config, LinphoneFriend *lf, int index){
 536         char key[50];
 537         char *tmp;
 538         const char *refkey;
 539
 540         sprintf(key,"friend_%i",index);
 541
 542         if (lf==NULL){
 543                 lp_config_clean_section(config,key);
 544                 return;
 545         }
 546         if (lf->uri!=NULL){
 547                 tmp=linphone_address_as_string(lf->uri);
 548                 if (tmp==NULL) {
 549                         return;
 550                 }
 551                 lp_config_set_string(config,key,"url",tmp);
 552                 osip_free(tmp);
 553         }
 554         lp_config_set_string(config,key,"pol",__policy_enum_to_str(lf->pol));
 555         lp_config_set_int(config,key,"subscribe",lf->subscribe);
 556
 557         refkey=linphone_friend_get_ref_key(lf);
 558         if (refkey){
 559                 lp_config_set_string(config,key,"refkey",refkey);
 560         }
 561 }
 562
 563 void linphone_core_write_friends_config(LinphoneCore* lc)
 564 {
 565         MSList *elem;
 566         int i;
 567         if (!lc->ready) return; /*dont write config when reading it !*/
 568         for (elem=lc->friends,i=0; elem!=NULL; elem=ms_list_next(elem),i++){
 569                 linphone_friend_write_to_config_file(lc->config,(LinphoneFriend*)elem->data,i);
 570         }
 571         linphone_friend_write_to_config_file(lc->config,NULL,i);        /* set the end */
 572 }
 573