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 const char *sal_op_get_network_origin(const SalOp *op){
 132         return ((SalOpBase*)op)->origin;
 133 }
 134
 135 void __sal_op_init(SalOp *b, Sal *sal){
 136         memset(b,0,sizeof(SalOpBase));
 137         ((SalOpBase*)b)->root=sal;
 138 }
 139
 140 void __sal_op_set_network_origin(SalOp *op, const char *origin){
 141         assign_string(&((SalOpBase*)op)->origin,origin);
 142 }
 143
 144
 145 void __sal_op_free(SalOp *op){
 146         SalOpBase *b=(SalOpBase *)op;
 147         if (b->from) {
 148                 ms_free(b->from);
 149                 b->from=NULL;
 150         }
 151         if (b->to) {
 152                 ms_free(b->to);
 153                 b->to=NULL;
 154         }
 155         if (b->route) {
 156                 ms_free(b->route);
 157                 b->route=NULL;
 158         }
 159         if (b->contact) {
 160                 ms_free(b->contact);
 161                 b->contact=NULL;
 162         }
 163         if (b->origin){
 164                 ms_free(b->origin);
 165                 b->origin=NULL;
 166         }
 167         if (b->local_media)
 168                 sal_media_description_unref(b->local_media);
 169         if (b->remote_media)
 170                 sal_media_description_unref(b->remote_media);
 171         ms_free(op);
 172 }