userapps/opensource/libosip2/src/osipparser2/osip_accept_encoding.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
  29 /* Accept-Encoding = token
  30    token possible values are gzip,compress,deflate,identity
  31 */
  32 int
  33 osip_message_set_accept_encoding (osip_message_t * sip, const char *hvalue)
  34 {
  35   osip_accept_encoding_t *accept_encoding;
  36   int i;
  37
  38   if (hvalue == NULL || hvalue[0] == '\0')
  39     return 0;
  40
  41   i = osip_accept_encoding_init (&accept_encoding);
  42   if (i != 0)
  43     return -1;
  44   i = osip_accept_encoding_parse (accept_encoding, hvalue);
  45   if (i != 0)
  46     {
  47       osip_accept_encoding_free (accept_encoding);
  48       return -1;
  49     }
  50   sip->message_property = 2;
  51   osip_list_add (sip->accept_encodings, accept_encoding, -1);
  52   return 0;
  53 }
  54
  55 int
  56 osip_message_get_accept_encoding (const osip_message_t * sip, int pos,
  57                                   osip_accept_encoding_t ** dest)
  58 {
  59   osip_accept_encoding_t *accept_encoding;
  60
  61   *dest = NULL;
  62   if (osip_list_size (sip->accept_encodings) <= pos)
  63     return -1;                  /* does not exist */
  64   accept_encoding =
  65     (osip_accept_encoding_t *) osip_list_get (sip->accept_encodings, pos);
  66   *dest = accept_encoding;
  67   return pos;
  68 }
  69
  70 int
  71 osip_accept_encoding_init (osip_accept_encoding_t ** accept_encoding)
  72 {
  73   *accept_encoding =
  74     (osip_accept_encoding_t *) osip_malloc (sizeof (osip_accept_encoding_t));
  75   if (*accept_encoding == NULL)
  76     return -1;
  77   (*accept_encoding)->element = NULL;
  78
  79   (*accept_encoding)->gen_params =
  80     (osip_list_t *) osip_malloc (sizeof (osip_list_t));
  81   if ((*accept_encoding)->gen_params == NULL)
  82     {
  83       osip_free (*accept_encoding);
  84       *accept_encoding = NULL;
  85       return -1;
  86     }
  87   osip_list_init ((*accept_encoding)->gen_params);
  88
  89   return 0;
  90 }
  91
  92 int
  93 osip_accept_encoding_parse (osip_accept_encoding_t * accept_encoding,
  94                             const char *hvalue)
  95 {
  96   const char *osip_accept_encoding_params;
  97
  98   osip_accept_encoding_params = strchr (hvalue, ';');
  99
 100   if (osip_accept_encoding_params != NULL)
 101     {
 102       if (__osip_generic_param_parseall (accept_encoding->gen_params,
 103                                          osip_accept_encoding_params) == -1)
 104         return -1;
 105     }
 106   else
 107     osip_accept_encoding_params = hvalue + strlen (hvalue);
 108
 109   if (osip_accept_encoding_params - hvalue + 1 < 2)
 110     return -1;
 111   accept_encoding->element =
 112     (char *) osip_malloc (osip_accept_encoding_params - hvalue + 1);
 113   if (accept_encoding->element == NULL)
 114     return -1;
 115   osip_strncpy (accept_encoding->element, hvalue,
 116                 osip_accept_encoding_params - hvalue);
 117   osip_clrspace (accept_encoding->element);
 118
 119   return 0;
 120 }
 121
 122 /* returns the accept_encoding header as a string.  */
 123 /* INPUT : osip_accept_encoding_t *accept_encoding | accept_encoding header.   */
 124 /* returns null on error. */
 125 int
 126 osip_accept_encoding_to_str (const osip_accept_encoding_t * accept_encoding,
 127                              char **dest)
 128 {
 129   char *buf;
 130   char *tmp;
 131   size_t len;
 132
 133   *dest = NULL;
 134   if ((accept_encoding == NULL) || (accept_encoding->element == NULL))
 135     return -1;
 136
 137   len = strlen (accept_encoding->element) + 2;
 138   buf = (char *) osip_malloc (len);
 139   if (buf == NULL)
 140     return -1;
 141
 142   sprintf (buf, "%s", accept_encoding->element);
 143   {
 144     int pos = 0;
 145     size_t plen;
 146     osip_generic_param_t *u_param;
 147
 148     while (!osip_list_eol (accept_encoding->gen_params, pos))
 149       {
 150         u_param =
 151           (osip_generic_param_t *) osip_list_get (accept_encoding->gen_params,
 152                                                   pos);
 153         if (u_param->gvalue == NULL)
 154           plen = strlen (u_param->gname) + 2;
 155         else
 156           plen = strlen (u_param->gname) + strlen (u_param->gvalue) + 3;
 157         len = len + plen;
 158         buf = (char *) realloc (buf, len);
 159         tmp = buf;
 160         tmp = tmp + strlen (tmp);
 161         if (u_param->gvalue == NULL)
 162           sprintf (tmp, ";%s", u_param->gname);
 163         else
 164           sprintf (tmp, ";%s=%s", u_param->gname, u_param->gvalue);
 165         pos++;
 166       }
 167   }
 168   *dest = buf;
 169   return 0;
 170 }
 171
 172 /* deallocates a osip_accept_encoding_t structure.  */
 173 /* INPUT : osip_accept_encoding_t *accept_encoding | accept_encoding. */
 174 void
 175 osip_accept_encoding_free (osip_accept_encoding_t * accept_encoding)
 176 {
 177   if (accept_encoding == NULL)
 178     return;
 179   osip_free (accept_encoding->element);
 180
 181   osip_generic_param_freelist (accept_encoding->gen_params);
 182
 183   accept_encoding->element = NULL;
 184   accept_encoding->gen_params = NULL;
 185   osip_free (accept_encoding);
 186 }
 187
 188 int
 189 osip_accept_encoding_clone (const osip_accept_encoding_t * ctt,
 190                             osip_accept_encoding_t ** dest)
 191 {
 192   int i;
 193   osip_accept_encoding_t *ct;
 194
 195   *dest = NULL;
 196   if (ctt == NULL)
 197     return -1;
 198   if (ctt->element == NULL)
 199     return -1;
 200
 201   i = osip_accept_encoding_init (&ct);
 202   if (i != 0)                   /* allocation failed */
 203     return -1;
 204   ct->element = osip_strdup (ctt->element);
 205   if (ctt->element != NULL && ct->element == NULL)
 206     {
 207       osip_accept_encoding_free (ct);
 208       return -1;
 209     }
 210   {
 211     int pos = 0;
 212     osip_generic_param_t *u_param;
 213     osip_generic_param_t *dest_param;
 214
 215     while (!osip_list_eol (ctt->gen_params, pos))
 216       {
 217         u_param =
 218           (osip_generic_param_t *) osip_list_get (ctt->gen_params, pos);
 219         i = osip_generic_param_clone (u_param, &dest_param);
 220         if (i != 0)
 221           {
 222             osip_accept_encoding_free (ct);
 223             return -1;
 224           }
 225         osip_list_add (ct->gen_params, dest_param, -1);
 226         pos++;
 227       }
 228   }
 229   *dest = ct;
 230   return 0;
 231 }
 232
 233
 234 char *
 235 osip_accept_encoding_get_element (const osip_accept_encoding_t * ae)
 236 {
 237   return ae->element;
 238 }
 239
 240 void
 241 osip_accept_encoding_set_element (osip_accept_encoding_t * ae, char *element)
 242 {
 243   ae->element = element;
 244 }