userapps/opensource/libosip2/src/osipparser2/osip_call_info.c

   1 /*
   2   The oSIP library implements the Session Initiation Protocol (SIP -rfc3261-)
   3   Copyright (C) 2001,2002,2003  Aymeric MOIZARD jack@atosc.org
   4
   5   This library is free software; you can redistribute it and/or
   6   modify it under the terms of the GNU Lesser General Public
   7   License as published by the Free Software Foundation; either
   8   version 2.1 of the License, or (at your option) any later version.
   9
  10   This library 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 GNU
  13   Lesser General Public License for more details.
  14
  15   You should have received a copy of the GNU Lesser General Public
  16   License along with this library; if not, write to the Free Software
  17   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18 */
  19
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22
  23 #include <osipparser2/osip_port.h>
  24 #include <osipparser2/osip_message.h>
  25 #include <osipparser2/osip_parser.h>
  26 #include "parser.h"
  27
  28 int
  29 osip_message_set_call_info (osip_message_t * sip, const char *hvalue)
  30 {
  31   osip_call_info_t *call_info;
  32   int i;
  33
  34   if (hvalue == NULL || hvalue[0] == '\0')
  35     return 0;
  36
  37   i = osip_call_info_init (&call_info);
  38   if (i != 0)
  39     return -1;
  40   i = osip_call_info_parse (call_info, hvalue);
  41   if (i != 0)                   /* allocation failed */
  42     {
  43       osip_call_info_free (call_info);
  44       return -1;
  45     }
  46   sip->message_property = 2;
  47   osip_list_add (sip->call_infos, call_info, -1);
  48   return 0;
  49 }
  50
  51 int
  52 osip_message_get_call_info (const osip_message_t * sip, int pos,
  53                             osip_call_info_t ** dest)
  54 {
  55   osip_call_info_t *call_info;
  56
  57   *dest = NULL;
  58   if (osip_list_size (sip->call_infos) <= pos)
  59     return -1;                  /* does not exist */
  60   call_info = (osip_call_info_t *) osip_list_get (sip->call_infos, pos);
  61   *dest = call_info;
  62   return pos;
  63 }
  64
  65 int
  66 osip_call_info_init (osip_call_info_t ** call_info)
  67 {
  68   *call_info = (osip_call_info_t *) osip_malloc (sizeof (osip_call_info_t));
  69   if (*call_info == NULL)
  70     return -1;
  71
  72   (*call_info)->element = NULL;
  73
  74   (*call_info)->gen_params =
  75     (osip_list_t *) osip_malloc (sizeof (osip_list_t));
  76   if ((*call_info)->gen_params == NULL)
  77     {
  78       osip_free (*call_info);
  79       *call_info = NULL;
  80       return -1;
  81     }
  82   osip_list_init ((*call_info)->gen_params);
  83
  84   return 0;
  85 }
  86
  87 int
  88 osip_call_info_parse (osip_call_info_t * call_info, const char *hvalue)
  89 {
  90   const char *osip_call_info_params;
  91
  92   osip_call_info_params = strchr (hvalue, '<');
  93   if (osip_call_info_params == NULL)
  94     return -1;
  95
  96   osip_call_info_params = strchr (osip_call_info_params + 1, '>');
  97   if (osip_call_info_params == NULL)
  98     return -1;
  99
 100   osip_call_info_params = strchr (osip_call_info_params + 1, ';');
 101
 102   if (osip_call_info_params != NULL)
 103     {
 104       if (__osip_generic_param_parseall
 105           (call_info->gen_params, osip_call_info_params) == -1)
 106         return -1;
 107     }
 108   else
 109     osip_call_info_params = hvalue + strlen (hvalue);
 110
 111   if (osip_call_info_params - hvalue + 1 < 2)
 112     return -1;
 113   call_info->element =
 114     (char *) osip_malloc (osip_call_info_params - hvalue + 1);
 115   if (call_info->element == NULL)
 116     return -1;
 117   osip_strncpy (call_info->element, hvalue, osip_call_info_params - hvalue);
 118   osip_clrspace (call_info->element);
 119
 120   return 0;
 121 }
 122
 123 /* returns the call_info header as a string.  */
 124 /* INPUT : osip_call_info_t *call_info | call_info header.   */
 125 /* returns null on error. */
 126 int
 127 osip_call_info_to_str (const osip_call_info_t * call_info, char **dest)
 128 {
 129   char *buf;
 130   char *tmp;
 131   size_t len;
 132   size_t plen;
 133
 134   *dest = NULL;
 135   if ((call_info == NULL) || (call_info->element == NULL))
 136     return -1;
 137
 138   len = strlen (call_info->element) + 2;
 139   buf = (char *) osip_malloc (len);
 140   if (buf == NULL)
 141     return -1;
 142   *dest = buf;
 143
 144   sprintf (buf, "%s", call_info->element);
 145
 146   {
 147     int pos = 0;
 148     osip_generic_param_t *u_param;
 149
 150     while (!osip_list_eol (call_info->gen_params, pos))
 151       {
 152         u_param =
 153           (osip_generic_param_t *) osip_list_get (call_info->gen_params, pos);
 154         if (u_param->gvalue == NULL)
 155           plen = strlen (u_param->gname) + 2;
 156         else
 157           plen = strlen (u_param->gname) + strlen (u_param->gvalue) + 3;
 158         len = len + plen;
 159         buf = (char *) realloc (buf, len);
 160         tmp = buf;
 161         tmp = tmp + strlen (tmp);
 162         if (u_param->gvalue == NULL)
 163           sprintf (tmp, ";%s", u_param->gname);
 164         else
 165           sprintf (tmp, ";%s=%s", u_param->gname, u_param->gvalue);
 166         pos++;
 167       }
 168   }
 169   *dest = buf;
 170   return 0;
 171 }
 172
 173
 174 /* deallocates a osip_call_info_t structure.  */
 175 /* INPUT : osip_call_info_t *call_info | call_info. */
 176 void
 177 osip_call_info_free (osip_call_info_t * call_info)
 178 {
 179   if (call_info == NULL)
 180     return;
 181   osip_free (call_info->element);
 182
 183   osip_generic_param_freelist (call_info->gen_params);
 184
 185   call_info->element = NULL;
 186   call_info->gen_params = NULL;
 187
 188   osip_free (call_info);
 189 }
 190
 191 int
 192 osip_call_info_clone (const osip_call_info_t * ctt, osip_call_info_t ** dest)
 193 {
 194   int i;
 195   osip_call_info_t *ct;
 196
 197   *dest = NULL;
 198   if (ctt == NULL)
 199     return -1;
 200   if (ctt->element == NULL)
 201     return -1;
 202
 203   i = osip_call_info_init (&ct);
 204   if (i != 0)                   /* allocation failed */
 205     return -1;
 206   ct->element = osip_strdup (ctt->element);
 207
 208   {
 209     int pos = 0;
 210     osip_generic_param_t *u_param;
 211     osip_generic_param_t *dest_param;
 212
 213     while (!osip_list_eol (ctt->gen_params, pos))
 214       {
 215         u_param =
 216           (osip_generic_param_t *) osip_list_get (ctt->gen_params, pos);
 217         i = osip_generic_param_clone (u_param, &dest_param);
 218         if (i != 0)
 219           {
 220             osip_call_info_free (ct);
 221             return -1;
 222           }
 223         osip_list_add (ct->gen_params, dest_param, -1);
 224         pos++;
 225       }
 226   }
 227   *dest = ct;
 228   return 0;
 229 }
 230
 231
 232 char *
 233 osip_call_info_get_uri (osip_call_info_t * ae)
 234 {
 235   return ae->element;
 236 }
 237
 238 void
 239 osip_call_info_set_uri (osip_call_info_t * ae, char *uri)
 240 {
 241   ae->element = uri;
 242 }