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