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

   1 /*
   2 linphone
   3 Copyright (C) 2010  Simon MORLAT (simon.morlat@free.fr)
   4
   5 This program is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU General Public License
   7 as published by the Free Software Foundation; either version 2
   8 of the License, or (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18 */
  19
  20 /**
  21  This header files defines the Signaling Abstraction Layer.
  22  The purpose of this layer is too allow experiment different call signaling
  23  protocols and implementations under linphone, for example SIP, JINGLE...
  24 **/
  25
  26 #include "sal.h"
  27
  28 SalMediaDescription *sal_media_description_new(){
  29         SalMediaDescription *md=ms_new0(SalMediaDescription,1);
  30         md->refcount=1;
  31         return md;
  32 }
  33
  34 static void sal_media_description_destroy(SalMediaDescription *md){
  35         int i;
  36         for(i=0;i<SAL_MEDIA_DESCRIPTION_MAX_STREAMS;i++){
  37                 ms_list_for_each(md->streams[i].payloads,(void (*)(void *))payload_type_destroy);
  38                 ms_list_free(md->streams[i].payloads);
  39                 md->streams[i].payloads=NULL;
  40         }
  41         ms_free(md);
  42 }
  43
  44 void sal_media_description_ref(SalMediaDescription *md){
  45         md->refcount++;
  46 }
  47
  48 void sal_media_description_unref(SalMediaDescription *md){
  49         md->refcount--;
  50         if (md->refcount==0){
  51                 sal_media_description_destroy (md);
  52         }
  53 }
  54
  55 const SalStreamDescription *sal_media_description_find_stream(const SalMediaDescription *md,
  56     SalMediaProto proto, SalStreamType type){
  57         int i;
  58         for(i=0;i<md->nstreams;++i){
  59                 const SalStreamDescription *ss=&md->streams[i];
  60                 if (ss->proto==proto && ss->type==type) return ss;
  61         }
  62         return NULL;
  63 }
  64
  65 bool_t sal_media_description_empty(SalMediaDescription *md){
  66         int i;
  67         for(i=0;i<md->nstreams;++i){
  68                 SalStreamDescription *ss=&md->streams[i];
  69                 if (ss->port!=0) return FALSE;
  70         }
  71         return TRUE;
  72 }
  73
  74 static void assign_string(char **str, const char *arg){
  75         if (*str){
  76                 ms_free(*str);
  77                 *str=NULL;
  78         }
  79         if (arg)
  80                 *str=ms_strdup(arg);
  81 }
  82
  83 void sal_op_set_contact(SalOp *op, const char *contact){
  84         assign_string(&((SalOpBase*)op)->contact,contact);
  85 }
  86
  87 void sal_op_set_route(SalOp *op, const char *route){
  88         assign_string(&((SalOpBase*)op)->route,route);
  89 }
  90
  91 void sal_op_set_from(SalOp *op, const char *from){
  92         assign_string(&((SalOpBase*)op)->from,from);
  93 }
  94
  95 void sal_op_set_to(SalOp *op, const char *to){
  96         assign_string(&((SalOpBase*)op)->to,to);
  97 }
  98
  99 void sal_op_set_user_pointer(SalOp *op, void *up){
 100         ((SalOpBase*)op)->user_pointer=up;
 101 }
 102
 103 Sal *sal_op_get_sal(const SalOp *op){
 104         return ((SalOpBase*)op)->root;
 105 }
 106
 107 const char *sal_op_get_from(const SalOp *op){
 108         return ((SalOpBase*)op)->from;
 109 }
 110
 111 const char *sal_op_get_to(const SalOp *op){
 112         return ((SalOpBase*)op)->to;
 113 }
 114
 115 const char *sal_op_get_contact(const SalOp *op){
 116         return ((SalOpBase*)op)->contact;
 117 }
 118
 119 const char *sal_op_get_route(const SalOp *op){
 120         return ((SalOpBase*)op)->route;
 121 }
 122
 123 void *sal_op_get_user_pointer(const SalOp *op){
 124         return ((SalOpBase*)op)->user_pointer;
 125 }
 126
 127 const char *sal_op_get_proxy(const SalOp *op){
 128         return ((SalOpBase*)op)->route;
 129 }
 130
 131 void __sal_op_init(SalOp *b, Sal *sal){
 132         memset(b,0,sizeof(SalOpBase));
 133         ((SalOpBase*)b)->root=sal;
 134 }
 135
 136 void __sal_op_free(SalOp *op){
 137         SalOpBase *b=(SalOpBase *)op;
 138         if (b->from) {
 139                 ms_free(b->from);
 140                 b->from=NULL;
 141         }
 142         if (b->to) {
 143                 ms_free(b->to);
 144                 b->to=NULL;
 145         }
 146         if (b->route) {
 147                 ms_free(b->route);
 148                 b->route=NULL;
 149         }
 150         if (b->contact) {
 151                 ms_free(b->contact);
 152                 b->contact=NULL;
 153         }
 154         if (b->local_media)
 155                 sal_media_description_unref(b->local_media);
 156         if (b->remote_media)
 157                 sal_media_description_unref(b->remote_media);
 158         ms_free(op);
 159 }