osip_message.c

最新osip源代码

/*
  The oSIP library implements the Session Initiation Protocol (SIP -rfc3261-)
  Copyright (C) 2001,2002,2003,2004,2005  Aymeric MOIZARD [e-mail]
  
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
  
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/


#include <stdio.h>
#include <stdlib.h>

#include <osipparser2/osip_port.h>
#include <osipparser2/osip_message.h>

/* enable logging of memory accesses */

const char *osip_protocol_version = "SIP/2.0";


int
osip_message_init (osip_message_t ** sip)
{
  *sip = (osip_message_t *) osip_malloc (sizeof (osip_message_t));
  if (*sip == NULL)
    return -1;
  memset (*sip, 0, sizeof (osip_message_t));

  (*sip)->accepts = (osip_list_t *) osip_malloc (sizeof (osip_list_t));
  osip_list_init ((*sip)->accepts);
  (*sip)->accept_encodings = (osip_list_t *) osip_malloc (sizeof (osip_list_t));
  osip_list_init ((*sip)->accept_encodings);
  (*sip)->accept_languages = (osip_list_t *) osip_malloc (sizeof (osip_list_t));

  osip_list_init ((*sip)->accept_languages);
  (*sip)->alert_infos = (osip_list_t *) osip_malloc (sizeof (osip_list_t));
  osip_list_init ((*sip)->alert_infos);
  (*sip)->allows = (osip_list_t *) osip_malloc (sizeof (osip_list_t));
  osip_list_init ((*sip)->allows);
  (*sip)->authentication_infos =
    (osip_list_t *) osip_malloc (sizeof (osip_list_t));
  osip_list_init ((*sip)->authentication_infos);
  (*sip)->authorizations = (osip_list_t *) osip_malloc (sizeof (osip_list_t));
  osip_list_init ((*sip)->authorizations);
  (*sip)->call_id = NULL;
  (*sip)->call_infos = (osip_list_t *) osip_malloc (sizeof (osip_list_t));
  osip_list_init ((*sip)->call_infos);
  (*sip)->contacts = (osip_list_t *) osip_malloc (sizeof (osip_list_t));
  osip_list_init ((*sip)->contacts);

  /* forget it: this field is not suported */
  (*sip)->content_dispositions = NULL;

  (*sip)->content_encodings = (osip_list_t *) osip_malloc (sizeof (osip_list_t));
  osip_list_init ((*sip)->content_encodings);
  (*sip)->content_length = NULL;
  (*sip)->content_type = NULL;
  (*sip)->cseq = NULL;
  (*sip)->error_infos = (osip_list_t *) osip_malloc (sizeof (osip_list_t));
  osip_list_init ((*sip)->error_infos);
  (*sip)->from = NULL;
  (*sip)->mime_version = NULL;
  (*sip)->proxy_authenticates = (osip_list_t *) osip_malloc (sizeof (osip_list_t));
  osip_list_init ((*sip)->proxy_authenticates);
  (*sip)->proxy_authentication_infos =
    (osip_list_t *) osip_malloc (sizeof (osip_list_t));
  osip_list_init ((*sip)->proxy_authentication_infos);
  (*sip)->proxy_authorizations =
    (osip_list_t *) osip_malloc (sizeof (osip_list_t));
  osip_list_init ((*sip)->proxy_authorizations);
  (*sip)->record_routes = (osip_list_t *) osip_malloc (sizeof (osip_list_t));
  osip_list_init ((*sip)->record_routes);
  (*sip)->routes = (osip_list_t *) osip_malloc (sizeof (osip_list_t));
  osip_list_init ((*sip)->routes);
  (*sip)->to = NULL;
  (*sip)->vias = (osip_list_t *) osip_malloc (sizeof (osip_list_t));
  osip_list_init ((*sip)->vias);
  (*sip)->www_authenticates = (osip_list_t *) osip_malloc (sizeof (osip_list_t));
  osip_list_init ((*sip)->www_authenticates);

  (*sip)->bodies = (osip_list_t *) osip_malloc (sizeof (osip_list_t));
  osip_list_init ((*sip)->bodies);

  (*sip)->headers = (osip_list_t *) osip_malloc (sizeof (osip_list_t));
  osip_list_init ((*sip)->headers);

  (*sip)->message_property = 3;
  (*sip)->message = NULL;       /* buffer to avoid calling osip_message_to_str many times (for retransmission) */
  (*sip)->message_length = 0;

  (*sip)->application_data = NULL;
  return 0;                     /* ok */
}


void
osip_message_set_reason_phrase (osip_message_t * sip, char *reason)
{
  sip->reason_phrase = reason;
}

void
osip_message_set_status_code (osip_message_t * sip, int status_code)
{
  sip->status_code = status_code;
}

void
osip_message_set_method (osip_message_t * sip, char *sip_method)
{
  sip->sip_method = sip_method;
}

void
osip_message_set_version (osip_message_t * sip, char *sip_version)
{
  sip->sip_version = sip_version;
}

void
osip_message_set_uri (osip_message_t * sip, osip_uri_t * url)
{
  sip->req_uri = url;
}

void
osip_message_free (osip_message_t * sip)
{
  int pos = 0;

  if (sip == NULL)
    return;

  osip_free (sip->sip_method);
  osip_free (sip->sip_version);
  if (sip->req_uri != NULL)
    {
      osip_uri_free (sip->req_uri);
    }
  osip_free (sip->reason_phrase);

  {
    osip_accept_t *accept;

    while (!osip_list_eol (sip->accepts, pos))
      {
        accept = (osip_accept_t *) osip_list_get (sip->accepts, pos);
        osip_list_remove (sip->accepts, pos);
        osip_accept_free (accept);
      }
    osip_free (sip->accepts);
  }
  {
    osip_accept_encoding_t *accept_encoding;

    while (!osip_list_eol (sip->accept_encodings, pos))
      {
        accept_encoding =
          (osip_accept_encoding_t *) osip_list_get (sip->accept_encodings, pos);
        osip_list_remove (sip->accept_encodings, pos);
        osip_accept_encoding_free (accept_encoding);
      }
    osip_free (sip->accept_encodings);
  }
  {
    osip_accept_language_t *accept_language;

    while (!osip_list_eol (sip->accept_languages, pos))
      {
        accept_language =
          (osip_accept_language_t *) osip_list_get (sip->accept_languages, pos);
        osip_list_remove (sip->accept_languages, pos);
        osip_accept_language_free (accept_language);
      }
    osip_free (sip->accept_languages);
  }
  {
    osip_alert_info_t *alert_info;

    while (!osip_list_eol (sip->alert_infos, pos))
      {
        alert_info = (osip_alert_info_t *) osip_list_get (sip->alert_infos, pos);
        osip_list_remove (sip->alert_infos, pos);
        osip_alert_info_free (alert_info);
      }
    osip_free (sip->alert_infos);
  }
  {
    osip_allow_t *al;

    while (!osip_list_eol (sip->allows, pos))
      {
        al = (osip_allow_t *) osip_list_get (sip->allows, pos);
        osip_list_remove (sip->allows, pos);
        osip_allow_free (al);
      }
    osip_free (sip->allows);
  }
  {
    osip_authentication_info_t *al;

    while (!osip_list_eol (sip->authentication_infos, pos))
      {
        al =
          (osip_authentication_info_t *) osip_list_get (sip->
                                                        authentication_infos, pos);
        osip_list_remove (sip->authentication_infos, pos);
        osip_authentication_info_free (al);
      }
    osip_free (sip->authentication_infos);
  }
  {
    osip_authorization_t *al;

    while (!osip_list_eol (sip->authorizations, pos))
      {
        al = (osip_authorization_t *) osip_list_get (sip->authorizations, pos);
        osip_list_remove (sip->authorizations, pos);
        osip_authorization_free (al);
      }
    osip_free (sip->authorizations);
  }
  if (sip->call_id != NULL)
    {
      osip_call_id_free (sip->call_id);
    }
  {
    osip_call_info_t *call_info;

    while (!osip_list_eol (sip->call_infos, pos))
      {
        call_info = (osip_call_info_t *) osip_list_get (sip->call_infos, pos);
        osip_list_remove (sip->call_infos, pos);
        osip_call_info_free (call_info);
      }
    osip_free (sip->call_infos);
  }
  {
    osip_contact_t *contact;

    while (!osip_list_eol (sip->contacts, pos))
      {
        contact = (osip_contact_t *) osip_list_get (sip->contacts, pos);
        osip_list_remove (sip->contacts, pos);
        osip_contact_free (contact);
      }
    osip_free (sip->contacts);
  }
  {
    osip_content_encoding_t *ce;

    while (!osip_list_eol (sip->content_encodings, pos))
      {
        ce =
          (osip_content_encoding_t *) osip_list_get (sip->content_encodings, pos);
        osip_list_remove (sip->content_encodings, pos);
        osip_content_encoding_free (ce);
      }
    osip_free (sip->content_encodings);
  }
  if (sip->content_length != NULL)
    {
      osip_content_length_free (sip->content_length);
    }
  if (sip->content_type != NULL)
    {
      osip_content_type_free (sip->content_type);
    }
  if (sip->cseq != NULL)
    {
      osip_cseq_free (sip->cseq);
    }
  {
    osip_error_info_t *error_info;

    while (!osip_list_eol (sip->error_infos, pos))
      {
        error_info = (osip_error_info_t *) osip_list_get (sip->error_infos, pos);
        osip_list_remove (sip->error_infos, pos);
        osip_error_info_free (error_info);
      }
    osip_free (sip->error_infos);
  }
  if (sip->from != NULL)
    {
      osip_from_free (sip->from);
    }
  if (sip->mime_version != NULL)
    {
      osip_mime_version_free (sip->mime_version);
    }
  {
    osip_proxy_authenticate_t *al;

    while (!osip_list_eol (sip->proxy_authenticates, pos))
      {
        al =
          (osip_proxy_authenticate_t *) osip_list_get (sip->
                                                       proxy_authenticates, pos);
        osip_list_remove (sip->proxy_authenticates, pos);
        osip_proxy_authenticate_free (al);
      }
    osip_free (sip->proxy_authenticates);
  }
  {
    osip_proxy_authentication_info_t *al;

    while (!osip_list_eol (sip->proxy_authentication_infos, pos))
      {
        al =
          (osip_proxy_authentication_info_t *) osip_list_get (sip->
                                                              proxy_authentication_infos,
                                                              pos);
        osip_list_remove (sip->proxy_authentication_infos, pos);
        osip_proxy_authentication_info_free (al);
      }
    osip_free (sip->proxy_authentication_infos);
  }
  {
    osip_proxy_authorization_t *proxy_authorization;

    while (!osip_list_eol (sip->proxy_authorizations, pos))
      {
        proxy_authorization =
          (osip_proxy_authorization_t *) osip_list_get (sip->
                                                        proxy_authorizations, pos);
        osip_list_remove (sip->proxy_authorizations, pos);
        osip_proxy_authorization_free (proxy_authorization);
      }
    osip_free (sip->proxy_authorizations);
  }
  {
    osip_record_route_t *record_route;

    while (!osip_list_eol (sip->record_routes, pos))
      {
        record_route =
          (osip_record_route_t *) osip_list_get (sip->record_routes, pos);
        osip_list_remove (sip->record_routes, pos);
        osip_record_route_free (record_route);
      }
    osip_free (sip->record_routes);
  }
  {
    osip_route_t *route;

    while (!osip_list_eol (sip->routes, pos))
      {
        route = (osip_route_t *) osip_list_get (sip->routes, pos);
        osip_list_remove (sip->routes, pos);
        osip_route_free (route);
      }
    osip_free (sip->routes);
  }
  if (sip->to != NULL)
    {
      osip_to_free (sip->to);
    }
  {
    osip_via_t *via;

    while (!osip_list_eol (sip->vias, pos))
      {
        via = (osip_via_t *) osip_list_get (sip->vias, pos);
        osip_list_remove (sip->vias, pos);
        osip_via_free (via);
      }
    osip_free (sip->vias);
  }
  {
    osip_www_authenticate_t *al;

    while (!osip_list_eol (sip->www_authenticates, pos))
      {
        al =
          (osip_www_authenticate_t *) osip_list_get (sip->www_authenticates, pos);
        osip_list_remove (sip->www_authenticates, pos);
        osip_www_authenticate_free (al);
      }
    osip_free (sip->www_authenticates);
  }

  {
    osip_header_t *header;

    while (!osip_list_eol (sip->headers, pos))
      {
        header = (osip_header_t *) osip_list_get (sip->headers, pos);
        osip_list_remove (sip->headers, pos);
        osip_header_free (header);
      }
    osip_free (sip->headers);
  }

  {
    osip_body_t *body;

    while (!osip_list_eol (sip->bodies, pos))
      {
        body = (osip_body_t *) osip_list_get (sip->bodies, pos);
        osip_list_remove (sip->bodies, pos);
        osip_body_free (body);
      }