int
osip_dialog_update_route_set_as_uas (osip_dialog_t * dialog, osip_message_t * invite)
{
  osip_contact_t *contact;
  int i;

  if (dialog == NULL)
    return OSIP_BADPARAMETER;
  if (invite == NULL)
    return OSIP_BADPARAMETER;

  if (osip_list_eol (&invite->contacts, 0)) {
    OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_WARNING, NULL, "missing a contact in invite!\n"));
  }
  else {
    if (dialog->remote_contact_uri != NULL) {
      osip_contact_free (dialog->remote_contact_uri);
    }
    dialog->remote_contact_uri = NULL;
    contact = osip_list_get (&invite->contacts, 0);
    i = osip_contact_clone (contact, &(dialog->remote_contact_uri));
    if (i != 0)
      return i;
  }
  return OSIP_SUCCESS;
}
Exemple #2
0
static int
_eXosip_call_reuse_contact (osip_message_t * invite, osip_message_t * msg)
{
  osip_contact_t *co_invite = NULL;
  osip_contact_t *co_msg = NULL;
  int i;
  i = osip_message_get_contact (invite, 0, &co_invite);
  if (i < 0 || co_invite == NULL || co_invite->url == NULL)
    {
      return i;
    }

  i = osip_message_get_contact (msg, 0, &co_msg);
  if (i >= 0 && co_msg != NULL)
    {
      osip_list_remove (&msg->contacts, 0);
      osip_contact_free (co_msg);
    }

  co_msg = NULL;
  i = osip_contact_clone (co_invite, &co_msg);
  if (i >= 0 && co_msg != NULL)
    {
      osip_list_add (&msg->contacts, co_msg, 0);
      return OSIP_SUCCESS;
    }
  return i;
}
Exemple #3
0
int
osip_dialog_update_route_set_as_uac (osip_dialog_t * dialog,
                                     osip_message_t * response)
{
  /* only the remote target URI is updated here... */
  osip_contact_t *contact;
  int i;

  if (dialog == NULL)
    return -1;
  if (response == NULL)
    return -1;

  if (osip_list_eol (&response->contacts, 0))
    {                           /* no contact header in response? */
      OSIP_TRACE (osip_trace
                  (__FILE__, __LINE__, OSIP_WARNING, NULL,
                   "missing a contact in response!\n"));
  } else
    {
      /* I personally think it's a bad idea to keep the old
         value in case the new one is broken... */
      if (dialog->remote_contact_uri != NULL)
        {
          osip_contact_free (dialog->remote_contact_uri);
        }
      dialog->remote_contact_uri = NULL;
      contact = osip_list_get (&response->contacts, 0);
      i = osip_contact_clone (contact, &(dialog->remote_contact_uri));
      if (i != 0)
        return -1;
    }

  if (dialog->state == DIALOG_EARLY && osip_list_size (&dialog->route_set) == 0)
    {                           /* update the route set */
      int pos = 0;

      while (!osip_list_eol (&response->record_routes, pos))
        {
          osip_record_route_t *rr;
          osip_record_route_t *rr2;

          rr =
            (osip_record_route_t *) osip_list_get (&response->record_routes, pos);
          i = osip_record_route_clone (rr, &rr2);
          if (i != 0)
            return -1;
          osip_list_add (&dialog->route_set, rr2, 0);
          pos++;
        }
    }

  if (MSG_IS_STATUS_2XX (response))
    dialog->state = DIALOG_CONFIRMED;
  return 0;
}
Exemple #4
0
/*
 * create a reply template from an given SIP request
 *
 * RETURNS a pointer to osip_message_t
 */
osip_message_t *msg_make_template_reply (sip_ticket_t *ticket, int code) {
   osip_message_t *request=ticket->sipmsg;
   osip_message_t *response;
   int pos;

   osip_message_init (&response);
   response->message=NULL;
   osip_message_set_version (response, osip_strdup ("SIP/2.0"));
   osip_message_set_status_code (response, code);
   osip_message_set_reason_phrase (response, 
                                   osip_strdup(osip_message_get_reason (code)));

   if (request->to==NULL) {
      ERROR("msg_make_template_reply: empty To in request header");
      return NULL;
   }

   if (request->from==NULL) {
      ERROR("msg_make_template_reply: empty From in request header");
      return NULL;
   }

   osip_to_clone (request->to, &response->to);
   osip_from_clone (request->from, &response->from);

   /* if 3xx, also include 1st contact header */
   if ((code==200) || ((code>=300) && (code<400))) {
      osip_contact_t *req_contact = NULL;
      osip_contact_t *res_contact = NULL;
      osip_message_get_contact(request, 0, &req_contact);
      if (req_contact) osip_contact_clone (req_contact, &res_contact);
      if (res_contact) osip_list_add(response->contacts,res_contact,0);
   }

   /* via headers */
   pos = 0;
   while (!osip_list_eol (request->vias, pos)) {
      char *tmp;
      osip_via_t *via;
      via = (osip_via_t *) osip_list_get (request->vias, pos);
      osip_via_to_str (via, &tmp);

      osip_message_set_via (response, tmp);
      osip_free (tmp);
      pos++;
   }

   osip_call_id_clone(request->call_id,&response->call_id);
   
   osip_cseq_clone(request->cseq,&response->cseq);

   return response;
}
Exemple #5
0
osip_message_t* init_sip_msg_from_src (const osip_message_t *sipmsg, const int code)
{
    __tri(init_sip_msg_from_src);

    if (sipmsg->to && sipmsg->from)
    {
       osip_message_t* sipgen;
       osip_message_init (&sipgen);

       if (sipgen)
       {
           sipgen->message = NULL;
           osip_message_set_version (sipgen, osip_strdup ("SIP/2.0"));
           osip_message_set_status_code (sipgen, code);
           osip_message_set_reason_phrase (sipgen,
                                   osip_strdup(osip_message_get_reason (code)));


           if (code == SIP_MOVED_TEMPORARILY)
           {
               char contact[100];
                snprintf (contact, sizeof(contact), "<sip:%s@%s:%s>",
                          sipmsg->to->url->username, "sip.voipcheap.com", "5060");

                osip_message_set_contact(sipgen, contact);

                osip_to_clone   (sipmsg->to,   &sipgen->from);
                osip_from_clone (sipmsg->from, &sipgen->to);

           }
           else
           {
               /*include 1st contact header  if 3xx*/
               if (code < SIP_BAD_REQUEST && (SIP_OK == code || code >= SIP_MULTIPLE_CHOICES) )
               {
                   osip_contact_t* src_contact = NULL;
                   osip_message_get_contact(sipmsg, 0, &src_contact);

                   if (src_contact)
                   {
                       osip_contact_t* res_contact = NULL;
                       osip_contact_clone (src_contact, &res_contact);

                       if (res_contact)
                       {
                           osip_list_add(&(sipgen->contacts),res_contact,0);
                       }
                   }
               }

               osip_to_clone   (sipmsg->to,   &sipgen->to);
               osip_from_clone (sipmsg->from, &sipgen->from);
           }

           /* via headers */
           int pos = 0;
           while (!osip_list_eol (&sipmsg->vias, pos))
           {
               osip_via_t*via = (osip_via_t*)osip_list_get (&sipmsg->vias, pos);
               char *tmp;
               osip_via_to_str (via, &tmp);
               osip_message_set_via (sipgen, tmp);
               osip_free (tmp);
               pos++;
           }

           osip_call_id_clone (sipmsg->call_id, &sipgen->call_id);
           osip_cseq_clone    (sipmsg->cseq,    &sipgen->cseq);
           __tre(return) sipgen;
       }
   }
static int
__osip_dialog_init (osip_dialog_t ** dialog, osip_message_t * invite, osip_message_t * response, osip_from_t * local, osip_to_t * remote, osip_message_t * remote_msg)
{
  int i;
  int pos;
  osip_generic_param_t *tag;

  *dialog = NULL;
  if (response == NULL)
    return OSIP_BADPARAMETER;
  if (response->cseq == NULL || local == NULL || remote == NULL)
    return OSIP_SYNTAXERROR;

  (*dialog) = (osip_dialog_t *) osip_malloc (sizeof (osip_dialog_t));
  if (*dialog == NULL)
    return OSIP_NOMEM;

  memset (*dialog, 0, sizeof (osip_dialog_t));
  (*dialog)->your_instance = NULL;

  if (MSG_IS_STATUS_2XX (response))
    (*dialog)->state = DIALOG_CONFIRMED;
  else                          /* 1XX */
    (*dialog)->state = DIALOG_EARLY;

  i = osip_call_id_to_str (response->call_id, &((*dialog)->call_id));
  if (i != 0) {
    OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_ERROR, NULL, "Could not establish dialog!\n"));
    osip_dialog_free (*dialog);
    *dialog = NULL;
    return i;
  }

  i = osip_to_get_tag (local, &tag);
  if (i != 0) {
    OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_ERROR, NULL, "Could not establish dialog!\n"));
    osip_dialog_free (*dialog);
    *dialog = NULL;
    return i;
  }

  (*dialog)->local_tag = osip_strdup (tag->gvalue);

  i = osip_from_get_tag (remote, &tag);
  if (i == 0)
    (*dialog)->remote_tag = osip_strdup (tag->gvalue);

  /* VR-2785: remember line value */
  if (invite) {
    osip_uri_param_t *line_param;

    i = osip_uri_param_get_byname (&invite->req_uri->url_params, "line", &line_param);
    if (i == 0 && line_param != NULL && line_param->gvalue != NULL)
      (*dialog)->line_param = osip_strdup (line_param->gvalue);
  }

  osip_list_init (&(*dialog)->route_set);

  pos = 0;
  while (!osip_list_eol (&response->record_routes, pos)) {
    osip_record_route_t *rr;
    osip_record_route_t *rr2;

    rr = (osip_record_route_t *) osip_list_get (&response->record_routes, pos);
    i = osip_record_route_clone (rr, &rr2);
    if (i != 0) {
      OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_ERROR, NULL, "Could not establish dialog!\n"));
      osip_dialog_free (*dialog);
      *dialog = NULL;
      return i;
    }
    if (invite == NULL)
      osip_list_add (&(*dialog)->route_set, rr2, 0);
    else
      osip_list_add (&(*dialog)->route_set, rr2, -1);

    pos++;
  }

  /* local_cseq is set to response->cseq->number for better
     handling of bad UA */
  (*dialog)->local_cseq = osip_atoi (response->cseq->number);

  i = osip_from_clone (remote, &((*dialog)->remote_uri));
  if (i != 0) {
    OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_ERROR, NULL, "Could not establish dialog!\n"));
    osip_dialog_free (*dialog);
    *dialog = NULL;
    return i;
  }

  i = osip_to_clone (local, &((*dialog)->local_uri));
  if (i != 0) {
    OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_ERROR, NULL, "Could not establish dialog!\n"));
    osip_dialog_free (*dialog);
    *dialog = NULL;
    return i;
  }

  {
    osip_contact_t *contact;

    if (!osip_list_eol (&remote_msg->contacts, 0)) {
      contact = osip_list_get (&remote_msg->contacts, 0);
      i = osip_contact_clone (contact, &((*dialog)->remote_contact_uri));
      if (i != 0) {
        OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_ERROR, NULL, "Could not establish dialog!\n"));
        osip_dialog_free (*dialog);
        *dialog = NULL;
        return i;
      }
    }
    else {
      (*dialog)->remote_contact_uri = NULL;
      OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_WARNING, NULL, "Remote UA is not compliant: missing a contact in remote message!\n"));
    }
  }
  (*dialog)->secure = -1;       /* non secure */

  return OSIP_SUCCESS;
}
Exemple #7
0
int
osip_dialog_init_as_uas (osip_dialog_t ** dialog, osip_message_t * invite, osip_message_t * response)
{
    int i;
    int pos;
    osip_generic_param_t *tag;

    (*dialog) = (osip_dialog_t *) osip_malloc (sizeof (osip_dialog_t));
    if (*dialog == NULL)
        return -1;

    (*dialog)->type = CALLEE;
    if (MSG_IS_STATUS_2XX (response))
        (*dialog)->state = DIALOG_CONFIRMED;
    else				/* 1XX */
        (*dialog)->state = DIALOG_EARLY;

    i = osip_call_id_to_str (response->call_id, &((*dialog)->call_id));
    if (i != 0)
        goto diau_error_0;

    i = osip_to_get_tag (response->to, &tag);
    if (i != 0)
        goto diau_error_1;
    (*dialog)->local_tag = osip_strdup (tag->gvalue);

    i = osip_from_get_tag (response->from, &tag);
    if (i != 0)
    {
        OSIP_TRACE (osip_trace
                    (__FILE__, __LINE__, OSIP_WARNING, NULL,
                     "Remote UA is not compliant: missing a tag in response!\n"));
        (*dialog)->remote_tag = NULL;
    }
    else
        (*dialog)->remote_tag = osip_strdup (tag->gvalue);

    (*dialog)->route_set = (osip_list_t *) osip_malloc (sizeof (osip_list_t));
    osip_list_init ((*dialog)->route_set);

    pos = 0;
    while (!osip_list_eol (response->record_routes, pos))
    {
        osip_record_route_t *rr;
        osip_record_route_t *rr2;

        rr = (osip_record_route_t *) osip_list_get (response->record_routes, pos);
        i = osip_record_route_clone (rr, &rr2);
        if (i != 0)
            goto diau_error_2;
        osip_list_add ((*dialog)->route_set, rr2, -1);
        pos++;
    }

    /* local_cseq is set to response->cseq->number for better
       handling of bad UA */
    (*dialog)->local_cseq = osip_atoi (response->cseq->number);
    (*dialog)->remote_cseq = osip_atoi (response->cseq->number);


    i = osip_from_clone (response->from, &((*dialog)->remote_uri));
    if (i != 0)
        goto diau_error_3;

    i = osip_to_clone (response->to, &((*dialog)->local_uri));
    if (i != 0)
        goto diau_error_4;

    {
        osip_contact_t *contact;

        if (!osip_list_eol (invite->contacts, 0))
        {
            contact = osip_list_get (invite->contacts, 0);
            i = osip_contact_clone (contact, &((*dialog)->remote_contact_uri));
            if (i != 0)
                goto diau_error_5;
        }
        else
        {
            (*dialog)->remote_contact_uri = NULL;
            OSIP_TRACE (osip_trace
                        (__FILE__, __LINE__, OSIP_WARNING, NULL,
                         "Remote UA is not compliant: missing a contact in response!\n"));
        }
    }
    (*dialog)->secure = -1;	/* non secure */

    return 0;

diau_error_5:
    osip_from_free ((*dialog)->local_uri);
diau_error_4:
    osip_from_free ((*dialog)->remote_uri);
diau_error_3:
diau_error_2:
    osip_list_special_free ((*dialog)->route_set,
                            (void *(*)(void *)) &osip_record_route_free);
    osip_free ((*dialog)->remote_tag);
    osip_free ((*dialog)->local_tag);
diau_error_1:
    osip_free ((*dialog)->call_id);
diau_error_0:
    OSIP_TRACE (osip_trace
                (__FILE__, __LINE__, OSIP_ERROR, NULL,
                 "Could not establish dialog!\n"));
    osip_free (*dialog);
    *dialog = NULL;
    return -1;
}
Exemple #8
0
  /* we don't have to compare
     remote_uri with from
     && local_uri with to.    ----> we have both tag recognized, it's enough..
   */
  if (0 == strcmp (tag_param_remote->gvalue, dlg->remote_tag))
    return 0;

  return -1;
}

int
osip_dialog_init_as_uac (osip_dialog_t ** dialog, osip_message_t * response)
{
  int i;
  int pos;
  osip_generic_param_t *tag;

  *dialog = NULL;

  (*dialog) = (osip_dialog_t *) osip_malloc (sizeof (osip_dialog_t));
  if (*dialog == NULL)
    return -1;

  memset (*dialog, 0, sizeof (osip_dialog_t));

  (*dialog)->your_instance = NULL;

  (*dialog)->type = CALLER;
  if (MSG_IS_STATUS_2XX (response))
    (*dialog)->state = DIALOG_CONFIRMED;
  else                          /* 1XX */
    (*dialog)->state = DIALOG_EARLY;

  i = osip_call_id_to_str (response->call_id, &((*dialog)->call_id));
  if (i != 0)
    goto diau_error_0;

  i = osip_from_get_tag (response->from, &tag);
  if (i != 0)
    goto diau_error_1;
  (*dialog)->local_tag = osip_strdup (tag->gvalue);

  i = osip_to_get_tag (response->to, &tag);
  if (i != 0)
    {
      OSIP_TRACE (osip_trace
                  (__FILE__, __LINE__, OSIP_WARNING, NULL,
                   "Remote UA is not compliant: missing a tag in response!\n"));
      (*dialog)->remote_tag = NULL;
  } else
    (*dialog)->remote_tag = osip_strdup (tag->gvalue);

  osip_list_init (&(*dialog)->route_set);

  pos = 0;
  while (!osip_list_eol (&response->record_routes, pos))
    {
      osip_record_route_t *rr;
      osip_record_route_t *rr2;

      rr = (osip_record_route_t *) osip_list_get (&response->record_routes, pos);
      i = osip_record_route_clone (rr, &rr2);
      if (i != 0)
        goto diau_error_2;
      osip_list_add (&(*dialog)->route_set, rr2, 0);
      pos++;
    }

  (*dialog)->local_cseq = osip_atoi (response->cseq->number);
  (*dialog)->remote_cseq = -1;

  i = osip_to_clone (response->to, &((*dialog)->remote_uri));
  if (i != 0)
    goto diau_error_3;

  i = osip_from_clone (response->from, &((*dialog)->local_uri));
  if (i != 0)
    goto diau_error_4;

  {
    osip_contact_t *contact;

    if (!osip_list_eol (&response->contacts, 0))
      {
        contact = osip_list_get (&response->contacts, 0);
        i = osip_contact_clone (contact, &((*dialog)->remote_contact_uri));
        if (i != 0)
          goto diau_error_5;
    } else
      {
        (*dialog)->remote_contact_uri = NULL;
        OSIP_TRACE (osip_trace
                    (__FILE__, __LINE__, OSIP_WARNING, NULL,
                     "Remote UA is not compliant: missing a contact in response!\n"));
      }
  }
  (*dialog)->secure = -1;       /* non secure */

  return 0;

diau_error_5:
  osip_from_free ((*dialog)->local_uri);
diau_error_4:
  osip_from_free ((*dialog)->remote_uri);
diau_error_3:
diau_error_2:
  osip_list_special_free (&(*dialog)->route_set,
                          (void *(*)(void *)) &osip_record_route_free);
  osip_free ((*dialog)->remote_tag);
  osip_free ((*dialog)->local_tag);
diau_error_1:
  osip_free ((*dialog)->call_id);
diau_error_0:
  OSIP_TRACE (osip_trace
              (__FILE__, __LINE__, OSIP_ERROR, NULL,
               "Could not establish dialog!\n"));
  osip_free (*dialog);
  *dialog = NULL;
  return -1;
}

#if 1                           /* SIPIT13 */
int
osip_dialog_init_as_uac_with_remote_request (osip_dialog_t ** dialog,
                                             osip_message_t * next_request,
                                             int local_cseq)
{
  int i;
  osip_generic_param_t *tag;

  *dialog = NULL;

  (*dialog) = (osip_dialog_t *) osip_malloc (sizeof (osip_dialog_t));
  if (*dialog == NULL)
    return -1;

  memset (*dialog, 0, sizeof (osip_dialog_t));
  (*dialog)->your_instance = NULL;

  (*dialog)->type = CALLER;
#if 0
  (*dialog)->state = DIALOG_CONFIRMED;
#endif
  (*dialog)->state = DIALOG_EARLY;

  i = osip_call_id_to_str (next_request->call_id, &((*dialog)->call_id));
  if (i != 0)
    goto diau_error_0;

  i = osip_from_get_tag (next_request->to, &tag);
  if (i != 0)
    goto diau_error_1;
  (*dialog)->local_tag = osip_strdup (tag->gvalue);

  i = osip_to_get_tag (next_request->from, &tag);
  if (i != 0)
    {
      OSIP_TRACE (osip_trace
                  (__FILE__, __LINE__, OSIP_WARNING, NULL,
                   "Remote UA is not compliant: missing a tag in next request!\n"));
      (*dialog)->remote_tag = NULL;
  } else
    (*dialog)->remote_tag = osip_strdup (tag->gvalue);

  osip_list_init (&(*dialog)->route_set);

  (*dialog)->local_cseq = local_cseq;   /* -1 osip_atoi (xxx->cseq->number); */
  (*dialog)->remote_cseq = osip_atoi (next_request->cseq->number);

  i = osip_to_clone (next_request->from, &((*dialog)->remote_uri));
  if (i != 0)
    goto diau_error_3;

  i = osip_from_clone (next_request->to, &((*dialog)->local_uri));
  if (i != 0)
    goto diau_error_4;

  {
    osip_contact_t *contact;

    if (!osip_list_eol (&next_request->contacts, 0))
      {
        contact = osip_list_get (&next_request->contacts, 0);
        i = osip_contact_clone (contact, &((*dialog)->remote_contact_uri));
        if (i != 0)
          goto diau_error_5;
    } else
      {
        (*dialog)->remote_contact_uri = NULL;
        OSIP_TRACE (osip_trace
                    (__FILE__, __LINE__, OSIP_WARNING, NULL,
                     "Remote UA is not compliant? missing a contact in response!\n"));
      }
  }

  (*dialog)->secure = -1;       /* non secure */

  return 0;

diau_error_5:
  osip_from_free ((*dialog)->local_uri);
diau_error_4:
  osip_from_free ((*dialog)->remote_uri);
diau_error_3:
  osip_free ((*dialog)->remote_tag);
  osip_free ((*dialog)->local_tag);
diau_error_1:
  osip_free ((*dialog)->call_id);
diau_error_0:
  OSIP_TRACE (osip_trace
              (__FILE__, __LINE__, OSIP_ERROR, NULL,
               "Could not establish dialog!\n"));
  osip_free (*dialog);
  *dialog = NULL;
  return -1;
}
Exemple #9
0
int
osip_message_clone (const osip_message_t * sip, osip_message_t ** dest)
{
    osip_message_t *copy;
    int pos = 0;
    int i;

    if (sip == NULL)
        return -1;
    *dest = NULL;

    i = osip_message_init (&copy);
    if (i != 0)
        return -1;

    copy->sip_method = osip_strdup (sip->sip_method);
    copy->sip_version = osip_strdup (sip->sip_version);
    copy->status_code = sip->status_code;
    copy->reason_phrase = osip_strdup (sip->reason_phrase);
    if (sip->req_uri != NULL)
    {
        i = osip_uri_clone (sip->req_uri, &(copy->req_uri));
        if (i != 0)
            goto mc_error1;
    }

    {
        osip_accept_t *accept;
        osip_accept_t *accept2;

        pos = 0;
        while (!osip_list_eol (&sip->accepts, pos))
        {
            accept = (osip_accept_t *) osip_list_get (&sip->accepts, pos);
            i = osip_accept_clone (accept, &accept2);
            if (i != 0)
                goto mc_error1;
            osip_list_add (&copy->accepts, accept2, -1);     /* insert as last element */
            pos++;
        }
    }
    {
        osip_accept_encoding_t *accept_encoding;
        osip_accept_encoding_t *accept_encoding2;

        pos = 0;
        while (!osip_list_eol (&sip->accept_encodings, pos))
        {
            accept_encoding =
                (osip_accept_encoding_t *) osip_list_get (&sip->accept_encodings, pos);
            i = osip_accept_encoding_clone (accept_encoding, &accept_encoding2);
            if (i != 0)
                goto mc_error1;
            osip_list_add (&copy->accept_encodings, accept_encoding2, -1);
            pos++;
        }
    }
    {
        osip_accept_language_t *accept_language;
        osip_accept_language_t *accept_language2;

        pos = 0;
        while (!osip_list_eol (&sip->accept_languages, pos))
        {
            accept_language =
                (osip_accept_language_t *) osip_list_get (&sip->accept_languages, pos);
            i = osip_accept_language_clone (accept_language, &accept_language2);
            if (i != 0)
                goto mc_error1;
            osip_list_add (&copy->accept_languages, accept_language2, -1);
            pos++;
        }
    }
    {
        osip_alert_info_t *alert_info;
        osip_alert_info_t *alert_info2;

        pos = 0;
        while (!osip_list_eol (&sip->alert_infos, pos))
        {
            alert_info = (osip_alert_info_t *) osip_list_get (&sip->alert_infos, pos);
            i = osip_alert_info_clone (alert_info, &alert_info2);
            if (i != 0)
                goto mc_error1;
            osip_list_add (&copy->alert_infos, alert_info2, -1);
            pos++;
        }
    }
    {
        osip_allow_t *allow;
        osip_allow_t *allow2;

        pos = 0;
        while (!osip_list_eol (&sip->allows, pos))
        {
            allow = (osip_allow_t *) osip_list_get (&sip->allows, pos);
            i = osip_allow_clone (allow, &allow2);
            if (i != 0)
                goto mc_error1;
            osip_list_add (&copy->allows, allow2, -1);
            pos++;
        }
    }
    {
        osip_authentication_info_t *authentication_info;
        osip_authentication_info_t *authentication_info2;

        pos = 0;
        while (!osip_list_eol (&sip->authentication_infos, pos))
        {
            authentication_info =
                (osip_authentication_info_t *) osip_list_get (&sip->
                        authentication_infos, pos);
            i =
                osip_authentication_info_clone (authentication_info,
                                                &authentication_info2);
            if (i != 0)
                goto mc_error1;
            osip_list_add (&copy->authentication_infos, authentication_info2, -1);
            pos++;
        }
    }
    {
        osip_authorization_t *authorization;
        osip_authorization_t *authorization2;

        pos = 0;
        while (!osip_list_eol (&sip->authorizations, pos))
        {
            authorization =
                (osip_authorization_t *) osip_list_get (&sip->authorizations, pos);
            i = osip_authorization_clone (authorization, &authorization2);
            if (i != 0)
                goto mc_error1;
            osip_list_add (&copy->authorizations, authorization2, -1);
            pos++;
        }
    }
    if (sip->call_id != NULL)
    {
        i = osip_call_id_clone (sip->call_id, &(copy->call_id));
        if (i != 0)
            goto mc_error1;
    }
    {
        osip_call_info_t *call_info;
        osip_call_info_t *call_info2;

        pos = 0;
        while (!osip_list_eol (&sip->call_infos, pos))
        {
            call_info = (osip_call_info_t *) osip_list_get (&sip->call_infos, pos);
            i = osip_call_info_clone (call_info, &call_info2);
            if (i != 0)
                goto mc_error1;
            osip_list_add (&copy->call_infos, call_info2, -1);
            pos++;
        }
    }
    {
        osip_contact_t *contact;
        osip_contact_t *contact2;

        pos = 0;
        while (!osip_list_eol (&sip->contacts, pos))
        {
            contact = (osip_contact_t *) osip_list_get (&sip->contacts, pos);
            i = osip_contact_clone (contact, &contact2);
            if (i != 0)
                goto mc_error1;
            osip_list_add (&copy->contacts, contact2, -1);
            pos++;
        }
    }
    {
        osip_content_encoding_t *content_encoding;
        osip_content_encoding_t *content_encoding2;

        pos = 0;
        while (!osip_list_eol (&sip->content_encodings, pos))
        {
            content_encoding =
                (osip_content_encoding_t *) osip_list_get (&sip->content_encodings, pos);
            i = osip_content_encoding_clone (content_encoding, &content_encoding2);
            if (i != 0)
                goto mc_error1;
            osip_list_add (&copy->content_encodings, content_encoding2, -1);
            pos++;
        }
    }
    if (sip->content_length != NULL)
    {
        i = osip_content_length_clone (sip->content_length, &(copy->content_length));
        if (i != 0)
            goto mc_error1;
    }
    if (sip->content_type != NULL)
    {
        i = osip_content_type_clone (sip->content_type, &(copy->content_type));
        if (i != 0)
            goto mc_error1;
    }
    if (sip->cseq != NULL)
    {
        i = osip_cseq_clone (sip->cseq, &(copy->cseq));
        if (i != 0)
            goto mc_error1;
    }
    {
        osip_error_info_t *error_info;
        osip_error_info_t *error_info2;

        pos = 0;
        while (!osip_list_eol (&sip->error_infos, pos))
        {
            error_info = (osip_error_info_t *) osip_list_get (&sip->error_infos, pos);
            i = osip_error_info_clone (error_info, &error_info2);
            if (i != 0)
                goto mc_error1;
            osip_list_add (&copy->error_infos, error_info2, -1);
            pos++;
        }
    }
    if (sip->from != NULL)
    {
        i = osip_from_clone (sip->from, &(copy->from));
        if (i != 0)
            goto mc_error1;
    }
    if (sip->mime_version != NULL)
    {
        i = osip_mime_version_clone (sip->mime_version, &(copy->mime_version));
        if (i != 0)
            goto mc_error1;
    }
    {
        osip_proxy_authenticate_t *proxy_authenticate;
        osip_proxy_authenticate_t *proxy_authenticate2;

        pos = 0;
        while (!osip_list_eol (&sip->proxy_authenticates, pos))
        {
            proxy_authenticate =
                (osip_proxy_authenticate_t *) osip_list_get (&sip->
                        proxy_authenticates, pos);
            i =
                osip_proxy_authenticate_clone (proxy_authenticate, &proxy_authenticate2);
            if (i != 0)
                goto mc_error1;
            osip_list_add (&copy->proxy_authenticates, proxy_authenticate2, -1);
            pos++;
        }
    }
    {
        osip_proxy_authentication_info_t *proxy_authentication_info;
        osip_proxy_authentication_info_t *proxy_authentication_info2;

        pos = 0;
        while (!osip_list_eol (&sip->proxy_authentication_infos, pos))
        {
            proxy_authentication_info =
                (osip_proxy_authentication_info_t *) osip_list_get (&sip->
                        proxy_authentication_infos,
                        pos);
            i =
                osip_proxy_authentication_info_clone (proxy_authentication_info,
                        &proxy_authentication_info2);
            if (i != 0)
                goto mc_error1;
            osip_list_add (&copy->proxy_authentication_infos,
                           proxy_authentication_info2, -1);
            pos++;
        }
    }
    {
        osip_proxy_authorization_t *proxy_authorization;
        osip_proxy_authorization_t *proxy_authorization2;

        pos = 0;
        while (!osip_list_eol (&sip->proxy_authorizations, pos))
        {
            proxy_authorization =
                (osip_proxy_authorization_t *) osip_list_get (&sip->
                        proxy_authorizations, pos);
            i =
                osip_proxy_authorization_clone (proxy_authorization,
                                                &proxy_authorization2);
            if (i != 0)
                goto mc_error1;
            osip_list_add (&copy->proxy_authorizations, proxy_authorization2, -1);
            pos++;
        }
    }
    {
        osip_record_route_t *record_route;
        osip_record_route_t *record_route2;

        pos = 0;
        while (!osip_list_eol (&sip->record_routes, pos))
        {
            record_route =
                (osip_record_route_t *) osip_list_get (&sip->record_routes, pos);
            i = osip_record_route_clone (record_route, &record_route2);
            if (i != 0)
                goto mc_error1;
            osip_list_add (&copy->record_routes, record_route2, -1);
            pos++;
        }
    }
    {
        osip_route_t *route;
        osip_route_t *route2;

        pos = 0;
        while (!osip_list_eol (&sip->routes, pos))
        {
            route = (osip_route_t *) osip_list_get (&sip->routes, pos);
            i = osip_route_clone (route, &route2);
            if (i != 0)
                goto mc_error1;
            osip_list_add (&copy->routes, route2, -1);
            pos++;
        }
    }
    if (sip->to != NULL)
    {
        i = osip_to_clone (sip->to, &(copy->to));
        if (i != 0)
            goto mc_error1;
    }
    {
        osip_via_t *via;
        osip_via_t *via2;

        pos = 0;
        while (!osip_list_eol (&sip->vias, pos))
        {
            via = (osip_via_t *) osip_list_get (&sip->vias, pos);
            i = osip_via_clone (via, &via2);
            if (i != 0)
                goto mc_error1;
            osip_list_add (&copy->vias, via2, -1);
            pos++;
        }
    }
    {
        osip_www_authenticate_t *www_authenticate;
        osip_www_authenticate_t *www_authenticate2;

        pos = 0;
        while (!osip_list_eol (&sip->www_authenticates, pos))
        {
            www_authenticate =
                (osip_www_authenticate_t *) osip_list_get (&sip->www_authenticates, pos);
            i = osip_www_authenticate_clone (www_authenticate, &www_authenticate2);
            if (i != 0)
                goto mc_error1;
            osip_list_add (&copy->www_authenticates, www_authenticate2, -1);
            pos++;
        }
    }

    {
        osip_header_t *header;
        osip_header_t *header2;

        pos = 0;
        while (!osip_list_eol (&sip->headers, pos))
        {
            header = (osip_header_t *) osip_list_get (&sip->headers, pos);
            i = osip_header_clone (header, &header2);
            if (i != 0)
                goto mc_error1;
            osip_list_add (&copy->headers, header2, -1);
            pos++;
        }
    }

    {
        osip_body_t *body;
        osip_body_t *body2;

        pos = 0;
        while (!osip_list_eol (&sip->bodies, pos))
        {
            body = (osip_body_t *) osip_list_get (&sip->bodies, pos);
            i = osip_body_clone (body, &body2);
            if (i != 0)
                goto mc_error1;
            osip_list_add (&copy->bodies, body2, -1);
            pos++;
        }
    }

    copy->message_length = sip->message_length;
    copy->message = osip_strdup (sip->message);
    copy->message_property = sip->message_property;

    *dest = copy;
    return 0;
mc_error1:
    osip_message_free (copy);
    return -1;

}