libsip/common/sip_msg.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <stdio.h>
#include <assert.h>
#include <errno.h>
#include <pthread.h>
#include <stdlib.h>
#include <string.h>
#include <sip.h>

#include "sip_msg.h"
#include "sip_miscdefs.h"
#include "sip_parse_generic.h"

/*
 * Response consists of SIP version, response code, response phrase and CRLF.
 */
#define	SIP_RESPONSE	"%s %d %s%s"

void sip_free_content(_sip_msg_t *);

/*
 * Allocate a new sip msg struct.
 */
sip_msg_t
sip_new_msg()
{
	_sip_msg_t *sip_msg;

	sip_msg = calloc(1, sizeof (_sip_msg_t));
	if (sip_msg != NULL) {
		sip_msg->sip_msg_ref_cnt = 1;
		(void) pthread_mutex_init(&sip_msg->sip_msg_mutex, NULL);
	}
	return ((sip_msg_t)sip_msg);
}

/*
 * Free all resources. The lock is taken by SIP_MSG_REFCNT_DECR. The
 * thread that decrements the last refcount should take care that
 * the message is not accessible to other threads before doing so.
 * Else, if the message is still accessible to others, it is
 * possible that the other thread could be waiting to take the
 * lock when we proceed to destroy it.
 */
void
sip_destroy_msg(_sip_msg_t *_sip_msg)
{
#ifdef	__solaris__
	assert(mutex_held(&_sip_msg->sip_msg_mutex));
#endif
	(void) sip_delete_start_line_locked(_sip_msg);
	assert(_sip_msg->sip_msg_ref_cnt == 0);
	sip_delete_all_headers((sip_msg_t)_sip_msg);
	sip_free_content(_sip_msg);
	if (_sip_msg->sip_msg_buf != NULL)
		free(_sip_msg->sip_msg_buf);

	if (_sip_msg->sip_msg_old_buf != NULL)
		free(_sip_msg->sip_msg_old_buf);

	while (_sip_msg->sip_msg_req_res != NULL) {
		sip_message_type_t	*sip_msg_type_ptr;

		sip_msg_type_ptr = _sip_msg->sip_msg_req_res->sip_next;
		if (_sip_msg->sip_msg_req_res->is_request) {
			sip_request_t	*reqline;

			reqline = &_sip_msg->sip_msg_req_res->U.sip_request;
			if (reqline->sip_parse_uri != NULL) {
				sip_free_parsed_uri(reqline->sip_parse_uri);
				reqline->sip_parse_uri = NULL;
			}
		}
		free(_sip_msg->sip_msg_req_res);
		_sip_msg->sip_msg_req_res = sip_msg_type_ptr;
	}
	(void) pthread_mutex_destroy(&_sip_msg->sip_msg_mutex);
	free(_sip_msg);
}

/*
 * Free a sip msg struct.
 */
void
sip_free_msg(sip_msg_t sip_msg)
{
	if (sip_msg == NULL)
		return;

	SIP_MSG_REFCNT_DECR((_sip_msg_t *)sip_msg);
}

/*
 * Hold a sip msg struct.
 */
void
sip_hold_msg(sip_msg_t sip_msg)
{

	if (sip_msg == NULL)
		return;

	SIP_MSG_REFCNT_INCR((_sip_msg_t *)sip_msg);
}

/*
 * Clone a message
 */
sip_msg_t
sip_clone_msg(sip_msg_t sip_msg)
{
	_sip_msg_t	*new_msg;
	_sip_msg_t	*_sip_msg;
	sip_content_t	*sip_content;
	sip_content_t	*msg_content;
	sip_content_t	*new_content = NULL;
	int		len;

	if (sip_msg == NULL)
		return (NULL);
	new_msg = (_sip_msg_t *)sip_new_msg();
	if (new_msg == NULL)
		return (NULL);
	_sip_msg = (_sip_msg_t *)sip_msg;
	/*
	 * Get start line
	 */
	if (sip_copy_start_line(_sip_msg, new_msg) != 0) {
		sip_free_msg((sip_msg_t)new_msg);
		return (NULL);
	}
	if (sip_copy_all_headers(_sip_msg, new_msg) != 0) {
		sip_free_msg((sip_msg_t)new_msg);
		return (NULL);
	}
	(void) pthread_mutex_lock(&_sip_msg->sip_msg_mutex);
	sip_content = _sip_msg->sip_msg_content;
	while (sip_content != NULL) {
		msg_content = calloc(1, sizeof (sip_content_t));
		if (msg_content == NULL) {
			sip_free_msg((sip_msg_t)new_msg);
			(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
			return (NULL);
		}
		len = sip_content->sip_content_end -
		    sip_content->sip_content_start;
		msg_content->sip_content_start = malloc(len + 1);
		if (msg_content->sip_content_start == NULL) {
			sip_free_msg((sip_msg_t)new_msg);
			(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
			return (NULL);
		}
		(void) strncpy(msg_content->sip_content_start,
		    sip_content->sip_content_start, len);
		msg_content->sip_content_start[len] = '\0';
		msg_content->sip_content_current =
		    msg_content->sip_content_start;
		msg_content->sip_content_end =  msg_content->sip_content_start +
		    len;
		msg_content->sip_content_allocated = B_TRUE;
		new_msg->sip_msg_content_len += len;
		new_msg->sip_msg_len += len;
		if (new_msg->sip_msg_content == NULL)
			new_msg->sip_msg_content = msg_content;
		else
			new_content->sip_content_next = msg_content;
		new_content = msg_content;
		sip_content = sip_content->sip_content_next;
	}
	(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
	/*
	 * Since this is a new message, no threads should be referring
	 * to this, so it is not necessary to take the lock, however,
	 * since sip_msg_to_msgbuf() expects the lock to be held, we'll
	 * take it here.
	 */
	(void) pthread_mutex_lock(&new_msg->sip_msg_mutex);
	new_msg->sip_msg_buf = sip_msg_to_msgbuf((sip_msg_t)new_msg, NULL);
	if (new_msg->sip_msg_buf == NULL) {
		(void) pthread_mutex_unlock(&new_msg->sip_msg_mutex);
		sip_free_msg((sip_msg_t)new_msg);
		return (NULL);
	}
	new_msg->sip_msg_cannot_be_modified = B_TRUE;
	(void) pthread_mutex_unlock(&new_msg->sip_msg_mutex);

	return ((sip_msg_t)new_msg);
}

/*
 * Return the SIP message as a string. Caller frees the string
 */
char *
sip_msg_to_str(sip_msg_t sip_msg, int *error)
{
	_sip_msg_t	*msg;
	char		*msgstr;

	if (sip_msg == NULL) {
		if (error != NULL)
			*error = EINVAL;
		return (NULL);
	}
	msg = (_sip_msg_t *)sip_msg;
	(void) pthread_mutex_lock(&msg->sip_msg_mutex);
	msgstr = sip_msg_to_msgbuf(msg, error);
	(void) pthread_mutex_unlock(&msg->sip_msg_mutex);
	return (msgstr);
}

/*
 * Given a message generate a string that includes all the headers and the
 * content.
 */
char *
sip_msg_to_msgbuf(_sip_msg_t *msg, int *error)
{
	_sip_header_t	*header;
	int		len = 0;
	char		*p;
	char		*e;
	sip_content_t	*sip_content;
#ifdef	_DEBUG
	int		tlen = 0;
	int		clen = 0;
#endif

	if (error != NULL)
		*error = 0;

	if (msg == NULL) {
		if (error != NULL)
			*error = EINVAL;
		return (NULL);
	}
#ifdef	__solaris__
	assert(mutex_held(&msg->sip_msg_mutex));
#endif

	p = (char *)malloc(msg->sip_msg_len + 1);
	if (p == NULL) {
		if (error != 0)
			*error = ENOMEM;
		return (NULL);
	}
	e = p;

	/*
	 * Get the start line
	 */
	if (msg->sip_msg_start_line != NULL) {
		len = msg->sip_msg_start_line->sip_hdr_end -
		    msg->sip_msg_start_line->sip_hdr_start;
		(void) strncpy(e, msg->sip_msg_start_line->sip_hdr_start, len);
		e += len;
#ifdef	_DEBUG
		tlen += len;
#endif
	}
	header = sip_search_for_header(msg, NULL, NULL);
	while (header != NULL) {
		if (header->sip_header_state != SIP_HEADER_DELETED) {
			if (header->sip_header_state ==
			    SIP_HEADER_DELETED_VAL) {
				len = sip_copy_values(e, header);
			} else {
				len = header->sip_hdr_end -
				    header->sip_hdr_start;
				(void) strncpy(e, header->sip_hdr_start, len);
			}
#ifdef	_DEBUG
			tlen += len;
			assert(tlen <= msg->sip_msg_len);
#endif
		}
		header = sip_search_for_header(msg, NULL, header);
		e += len;
	}
	sip_content = msg->sip_msg_content;
	while (sip_content != NULL) {
		len = sip_content->sip_content_end -
		    sip_content->sip_content_start;
#ifdef	_DEBUG
		clen += len;
		assert(clen <= msg->sip_msg_content_len);
		tlen += len;
		assert(tlen <= msg->sip_msg_len);
#endif
		(void) strncpy(e, sip_content->sip_content_start, len);
		e += len;
		sip_content = sip_content->sip_content_next;
	}
	p[msg->sip_msg_len] = '\0';
	return (p);
}

/*
 * This is called just before sending the message to the transport. It
 * creates the sip_msg_buf from the SIP headers.
 */
int
sip_adjust_msgbuf(_sip_msg_t *msg)
{
	_sip_header_t	*header;
	int		ret;
#ifdef	_DEBUG
	int		tlen = 0;
	int		clen = 0;
#endif

	if (msg == NULL)
		return (EINVAL);

	(void) pthread_mutex_lock(&msg->sip_msg_mutex);
	if ((msg->sip_msg_buf != NULL) && (!msg->sip_msg_modified)) {
		/*
		 * We could just be forwarding the message we
		 * received.
		 */
		(void) pthread_mutex_unlock(&msg->sip_msg_mutex);
		return (0);
	}

	/*
	 * We are sending a new message or a message that we received
	 * but have modified it. We keep the old
	 * msgbuf till the message is freed as some
	 * headers still point to it.
	 */

	assert(msg->sip_msg_old_buf == NULL);
	msg->sip_msg_old_buf = msg->sip_msg_buf;
	/*
	 * We add the content-length header here, if it has not
	 * already been added.
	 */
	header = sip_search_for_header(msg, SIP_CONTENT_LENGTH, NULL);
	if (header != NULL) {
		/*
		 * Mark the previous header as deleted.
		 */
		header->sip_header_state = SIP_HEADER_DELETED;
		header->sip_hdr_sipmsg->sip_msg_len -= header->sip_hdr_end -
		    header->sip_hdr_start;
	}
	(void) pthread_mutex_unlock(&msg->sip_msg_mutex);
	ret = sip_add_content_length(msg, msg->sip_msg_content_len);
	if (ret != 0) {
		(void) pthread_mutex_unlock(&msg->sip_msg_mutex);
		return (ret);
	}
	(void) pthread_mutex_lock(&msg->sip_msg_mutex);
	msg->sip_msg_modified = B_FALSE;

	msg->sip_msg_buf = sip_msg_to_msgbuf((sip_msg_t)msg, &ret);
	if (msg->sip_msg_buf == NULL) {
		(void) pthread_mutex_unlock(&msg->sip_msg_mutex);
		return (ret);
	}
	/*
	 * Once the message has been sent it can not be modified
	 * any furthur as we keep a pointer to it for retransmission
	 */
	msg->sip_msg_cannot_be_modified = B_TRUE;

	(void) pthread_mutex_unlock(&msg->sip_msg_mutex);
	return (0);
}

/*
 * Copy header values into ptr
 */
int
sip_copy_values(char *ptr, _sip_header_t *header)
{
	sip_header_value_t	value;
	int			tlen = 0;
	int			len = 0;
	boolean_t		first = B_TRUE;
	char			*p = ptr;
	char			*s;
	boolean_t		crlf_present = B_FALSE;

	if (sip_parse_goto_values(header) != 0)
		return (0);

	len = header->sip_hdr_current - header->sip_hdr_start;
	(void) strncpy(p, header->sip_hdr_start, len);
	tlen += len;
	p += len;
	value = header->sip_hdr_parsed->value;
	while (value != NULL) {
		if (value->value_state != SIP_VALUE_DELETED) {
			crlf_present = B_FALSE;
			len = value->value_end - value->value_start;
			if (first) {
				(void) strncpy(p, value->value_start, len);
				first = B_FALSE;
			} else {
				s = value->value_start;
				while (*s != SIP_COMMA)
					s--;
				len += value->value_start - s;
				(void) strncpy(p, s, len);
			}
			tlen += len;
			p += len;
			s = value->value_end;
			while (s != value->value_start) {
				if (*s == '\r' && strncmp(s, SIP_CRLF,
				    strlen(SIP_CRLF)) == 0) {
					crlf_present = B_TRUE;
					break;
				}
				s--;
			}
		} else {
			if (value->next == NULL && !first && !crlf_present) {
				s = value->value_end;
				while (*s != '\r')
					s--;
				len = value->value_end - s;
				(void) strncpy(p, s, len);
				tlen += len;
				p += len;
			}
		}
		value = value->next;
	}
	return (tlen);
}


/*
 * Add content (message body) to sip_msg
 */
int
sip_add_content(sip_msg_t sip_msg, char *content)
{
	size_t		len;
	sip_content_t	**loc;
	sip_content_t	*msg_content;
	_sip_msg_t	*_sip_msg;

	if (sip_msg == NULL || content == NULL || strlen(content) == 0)
		return (EINVAL);
	len = strlen(content);
	_sip_msg = (_sip_msg_t *)sip_msg;
	(void) pthread_mutex_lock(&_sip_msg->sip_msg_mutex);

	if (_sip_msg->sip_msg_cannot_be_modified) {
		(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
		return (ENOTSUP);
	}

	msg_content = calloc(1, sizeof (sip_content_t));
	if (msg_content == NULL) {
		(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
		return (ENOMEM);
	}
	msg_content->sip_content_start = malloc(strlen(content) + 1);
	if (msg_content->sip_content_start == NULL) {
		(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
		free(msg_content);
		return (ENOMEM);
	}
	(void) strncpy(msg_content->sip_content_start, content,
	    strlen(content));
	msg_content->sip_content_start[strlen(content)] = '\0';
	msg_content->sip_content_current = msg_content->sip_content_start;
	msg_content->sip_content_end = msg_content->sip_content_start +
	    strlen(msg_content->sip_content_start);
	msg_content->sip_content_allocated = B_TRUE;

	loc = &_sip_msg->sip_msg_content;
	while (*loc != NULL)
		loc = &((*loc)->sip_content_next);
	*loc = msg_content;

	_sip_msg->sip_msg_content_len += len;
	_sip_msg->sip_msg_len += len;
	if (_sip_msg->sip_msg_buf != NULL)
		_sip_msg->sip_msg_modified = B_TRUE;
	(void) pthread_mutex_unlock(&_sip_msg->sip_msg_mutex);
	return (0);
}

/*
 * Free the message content
 */
void
sip_free_content(_sip_msg_t *sip_msg)
{
	sip_content_t *content;

	if (sip_msg == NULL)
		return;
	content = sip_msg->sip_msg_content;
	while (content != NULL) {
		sip_content_t *content_tmp;

		content_tmp = content;
		content = content->sip_content_next;
		if (content_tmp->sip_content_allocated)
			free(content_tmp->sip_content_start);
		free(content_tmp);
	}
	sip_msg->sip_msg_content = NULL;
}


/*
 * Add a response line to sip_response
 */
int
sip_add_response_line(sip_msg_t sip_response, int response, char *response_code)
{
	_sip_header_t	*new_header;
	int		header_size;
	_sip_msg_t	*_sip_response;
	int		ret;

	if (sip_response == NULL || response < 0 || response_code == NULL)
		return (EINVAL);
	_sip_response = (_sip_msg_t *)sip_response;
	(void) pthread_mutex_lock(&_sip_response->sip_msg_mutex);
	if (_sip_response->sip_msg_cannot_be_modified) {
		(void) pthread_mutex_unlock(&_sip_response->sip_msg_mutex);
		return (ENOTSUP);
	}
	header_size = strlen(SIP_VERSION) + SIP_SPACE_LEN +
	    SIP_SIZE_OF_STATUS_CODE + SIP_SPACE_LEN + strlen(response_code) +
	    strlen(SIP_CRLF);

	new_header = sip_new_header(header_size);
	if (new_header == NULL) {
		(void) pthread_mutex_unlock(&_sip_response->sip_msg_mutex);
		return (ENOMEM);
	}
	new_header->sip_hdr_sipmsg = _sip_response;

	(void) snprintf(new_header->sip_hdr_start, header_size + 1,
	    SIP_RESPONSE, SIP_VERSION, response, response_code, SIP_CRLF);

	new_header->sip_hdr_next = _sip_response->sip_msg_start_line;
	_sip_response->sip_msg_start_line = new_header;
	_sip_response->sip_msg_len += header_size;
	ret = sip_parse_first_line(_sip_response->sip_msg_start_line,
	    &_sip_response->sip_msg_req_res);
	if (_sip_response->sip_msg_buf != NULL)
		_sip_response->sip_msg_modified = B_TRUE;
	(void) pthread_mutex_unlock(&_sip_response->sip_msg_mutex);
	return (ret);
}

/*
 * create a response based on the sip_request.
 * Copies Call-ID, CSeq, From, To and Via headers from the request.
 */
sip_msg_t
sip_create_response(sip_msg_t sip_request, int response, char *response_code,
    char *totag, char *mycontact)
{
	_sip_msg_t	*new_msg;
	_sip_msg_t	*_sip_request;
	boolean_t	ttag_present;

	if (sip_request == NULL || response_code == NULL)
		return (NULL);

	ttag_present =  sip_get_to_tag(sip_request, NULL) != NULL;

	new_msg = (_sip_msg_t *)sip_new_msg();
	if (new_msg == NULL)
		return (NULL);
	_sip_request = (_sip_msg_t *)sip_request;

	(void) pthread_mutex_lock(&_sip_request->sip_msg_mutex);

	/*
	 * Add response line.
	 */
	if (sip_add_response_line(new_msg, response, response_code) != 0)
		goto error;

	/*
	 * Copy Via headers
	 */
	if (_sip_find_and_copy_all_header(_sip_request, new_msg, SIP_VIA) != 0)
		goto error;

	/*
	 * Copy From header.
	 */
	if (_sip_find_and_copy_header(_sip_request, new_msg, SIP_FROM,
	    NULL, B_FALSE)) {
		goto error;
	}
	/*
	 * Copy To header. If To tag is present, copy it, if not then
	 * add one if the repsonse is not provisional.
	 */
	if (ttag_present || (totag == NULL && response == SIP_TRYING)) {
		if (_sip_find_and_copy_header(_sip_request, new_msg, SIP_TO,
		    NULL, B_FALSE)) {
			goto error;
		}
	} else {
		char		*xtra_param;
		boolean_t	tag_alloc = B_FALSE;
		int		taglen;

		if (totag == NULL) {
			totag = sip_guid();
			if (totag == NULL)
				goto error;
			tag_alloc = B_TRUE;
		}
		taglen = strlen(SIP_TAG) + strlen(totag) + 1;
		xtra_param = (char *)malloc(taglen);
		if (xtra_param == NULL) {
			if (tag_alloc)
				free(totag);
			goto error;
		}
		(void) snprintf(xtra_param, taglen, "%s%s", SIP_TAG, totag);
		if (tag_alloc)
			free(totag);
		if (_sip_find_and_copy_header(_sip_request, new_msg,
		    SIP_TO, xtra_param, B_FALSE)) {
			free(xtra_param);
			goto error;
		}
		free(xtra_param);
	}

	/*
	 * Copy Call-ID header.
	 */
	if (_sip_find_and_copy_header(_sip_request, new_msg, SIP_CALL_ID, NULL,
	    B_FALSE)) {
		goto error;
	}
	/*
	 * Copy CSEQ header
	 */
	if (_sip_find_and_copy_header(_sip_request, new_msg, SIP_CSEQ, NULL,
	    B_FALSE)) {
		goto error;
	}
	/*
	 * Copy RECORD-ROUTE header, if present.
	 */
	if (sip_search_for_header(_sip_request, SIP_RECORD_ROUTE, NULL) !=
	    NULL) {
		if (_sip_find_and_copy_all_header(_sip_request, new_msg,
		    SIP_RECORD_ROUTE) != 0) {
			goto error;
		}
	}
	if (mycontact != NULL) {
		if (sip_add_contact(new_msg, NULL, mycontact, B_FALSE,
		    NULL) != 0) {
			goto error;
		}
	}
	(void) pthread_mutex_unlock(&_sip_request->sip_msg_mutex);
	return ((sip_msg_t)new_msg);
error:
	sip_free_msg((sip_msg_t)new_msg);
	(void) pthread_mutex_unlock(&_sip_request->sip_msg_mutex);
	return (NULL);
}

/*
 * NON OK ACK : MUST contain values for the Call-ID, From, and Request-URI
 * that are equal to the values of those header fields in the orig request
 * passed to the transport. The To header field in the ACK MUST equal the To
 * header field in the response being acknowledged. The ACK MUST contain the
 * top Via header field of the original request.  The CSeq header field in
 * the ACK MUST contain the same value for the sequence number as was
 * present in the original request, but the method parameter MUST be equal
 * to "ACK".
 */
int
sip_create_nonOKack(sip_msg_t request, sip_msg_t response, sip_msg_t ack_msg)
{
	int		seqno;
	char		*uri;
	_sip_msg_t	*_request;
	_sip_msg_t	*_response;
	_sip_msg_t	*_ack_msg;
	int		ret;

	if (request == NULL || response == NULL || ack_msg == NULL ||
	    request == ack_msg) {
		return (EINVAL);
	}
	_request = (_sip_msg_t *)request;
	_response = (_sip_msg_t *)response;
	_ack_msg = (_sip_msg_t *)ack_msg;

	(void) pthread_mutex_lock(&_request->sip_msg_mutex);
	if (_request->sip_msg_req_res == NULL) {
		if ((ret = sip_parse_first_line(_request->sip_msg_start_line,
		    &_request->sip_msg_req_res)) != 0) {
			(void) pthread_mutex_unlock(&_request->sip_msg_mutex);
			return (ret);
		}
	}
	if (_request->sip_msg_req_res->U.sip_request.sip_request_uri.
	    sip_str_ptr == NULL) {
		(void) pthread_mutex_unlock(&_request->sip_msg_mutex);
		return (EINVAL);
	}
	uri = (char *)malloc(_request->sip_msg_req_res->U.sip_request.
	    sip_request_uri.sip_str_len + 1);
	if (uri == NULL) {
		(void) pthread_mutex_unlock(&_request->sip_msg_mutex);
		return (EINVAL);
	}
	(void) strncpy(uri,
	    _request->sip_msg_req_res->U.sip_request.sip_request_uri.
	    sip_str_ptr, _request->sip_msg_req_res->U.sip_request.
	    sip_request_uri.sip_str_len);
	uri[_request->sip_msg_req_res->U.sip_request.
	    sip_request_uri.sip_str_len] = '\0';
	if ((ret = sip_add_request_line(_ack_msg, ACK, uri)) != 0) {
		(void) pthread_mutex_unlock(&_request->sip_msg_mutex);
		return (ret);
	}
	free(uri);
	if ((ret = _sip_find_and_copy_header(_request, _ack_msg, SIP_VIA,
	    NULL, B_TRUE)) != 0) {
		(void) pthread_mutex_unlock(&_request->sip_msg_mutex);
		return (ret);
	}
	(void) _sip_find_and_copy_header(_request, _ack_msg,
	    SIP_MAX_FORWARDS, NULL, B_TRUE);

	(void) pthread_mutex_lock(&_response->sip_msg_mutex);
	if ((ret = _sip_find_and_copy_header(_response, _ack_msg, SIP_TO,
	    NULL, B_TRUE)) != 0) {
		(void) pthread_mutex_unlock(&_response->sip_msg_mutex);
		return (ret);
	}
	(void) pthread_mutex_unlock(&_response->sip_msg_mutex);
	if ((ret = _sip_find_and_copy_header(_request, _ack_msg, SIP_FROM,
	    NULL, B_TRUE)) != 0) {
		(void) pthread_mutex_unlock(&_request->sip_msg_mutex);
		return (ret);
	}
	if ((ret = _sip_find_and_copy_header(_request, _ack_msg, SIP_CALL_ID,
	    NULL, B_TRUE)) != 0) {
		(void) pthread_mutex_unlock(&_request->sip_msg_mutex);
		return (ret);
	}
	(void) pthread_mutex_unlock(&_request->sip_msg_mutex);
	seqno = sip_get_callseq_num(_request, &ret);
	if (ret != 0)
		return (ret);
	if ((ret = sip_add_cseq(_ack_msg, ACK, seqno)) != 0)
		return (ret);
	if ((ret = sip_adjust_msgbuf(_ack_msg)) != 0)
		return (ret);
	return (0);
}

/*
 * This is a 2XX ACK, for others ACK is constructed differently,
 * esp. the branch id is retained.
 */
int
sip_create_OKack(sip_msg_t response, sip_msg_t ack_msg, char *transport,
    char *sent_by, int sent_by_port, char *via_params)
{
	int			seqno;
	char			*uri;
	sip_parsed_header_t	*parsed_header;
	sip_hdr_value_t		*contact_value;
	_sip_header_t		*header;
	_sip_msg_t		*_response;
	_sip_msg_t		*_ack_msg;
	int			ret;

	if (response == NULL || response == NULL || transport == NULL)
		return (EINVAL);
	_response = (_sip_msg_t *)response;
	_ack_msg = (_sip_msg_t *)ack_msg;

	/*
	 * Get URI from the response, Contact field
	 */
	(void) pthread_mutex_lock(&_response->sip_msg_mutex);
	if ((header = sip_search_for_header(_response, SIP_CONTACT,
	    NULL)) == NULL) {
		(void) pthread_mutex_unlock(&_response->sip_msg_mutex);
		return (EINVAL);
	}
	if ((ret = sip_parse_cftr_header(header, (void *)&parsed_header)) !=
	    0) {
		(void) pthread_mutex_unlock(&_response->sip_msg_mutex);
		return (ret);
	}
	contact_value = (sip_hdr_value_t *)parsed_header->value;
	if (contact_value->cftr_uri.sip_str_ptr == NULL) {
		(void) pthread_mutex_unlock(&_response->sip_msg_mutex);
		return (EINVAL);
	}
	uri = (char *)malloc(contact_value->cftr_uri.sip_str_len + 1);
	if (uri == NULL) {
		(void) pthread_mutex_unlock(&_response->sip_msg_mutex);
		return (ENOMEM);
	}
	(void) strncpy(uri, contact_value->cftr_uri.sip_str_ptr,
	    contact_value->cftr_uri.sip_str_len);
	uri[contact_value->cftr_uri.sip_str_len] = '\0';
	if ((ret = sip_add_request_line(_ack_msg, ACK, uri)) != 0) {
		(void) pthread_mutex_unlock(&_response->sip_msg_mutex);
		return (ret);
	}
	free(uri);
	if ((ret = sip_add_via(_ack_msg, transport, sent_by, sent_by_port,
	    via_params)) != 0) {
		(void) pthread_mutex_unlock(&_response->sip_msg_mutex);
		return (ret);
	}

	if ((ret = _sip_find_and_copy_header(_response, _ack_msg, SIP_TO,
	    NULL, B_TRUE)) != 0) {
		(void) pthread_mutex_unlock(&_response->sip_msg_mutex);
		return (ret);
	}
	if ((ret = _sip_find_and_copy_header(_response, _ack_msg, SIP_FROM,
	    NULL, B_TRUE)) != 0) {
		(void) pthread_mutex_unlock(&_response->sip_msg_mutex);
		return (ret);
	}
	if ((ret = _sip_find_and_copy_header(_response, _ack_msg, SIP_CALL_ID,
	    NULL, B_TRUE)) != 0) {
		(void) pthread_mutex_unlock(&_response->sip_msg_mutex);
		return (ret);
	}
	/*
	 * Copy Max-Forward if present
	 */
	if (sip_search_for_header(_response, SIP_MAX_FORWARDS, NULL) != NULL) {
		if ((ret = _sip_find_and_copy_header(_response, _ack_msg,
		    SIP_MAX_FORWARDS, NULL, B_TRUE)) != 0) {
			(void) pthread_mutex_unlock(&_response->sip_msg_mutex);
			return (ret);
		}
	}
	(void) pthread_mutex_unlock(&_response->sip_msg_mutex);
	seqno = sip_get_callseq_num(_response, &ret);
	if (ret != 0)
		return (ret);
	if ((ret = sip_add_cseq(_ack_msg, ACK, seqno)) != 0)
		return (ret);

	return (0);
}

/*
 * Request-Line   =  Method SP Request-URI SP SIP-Version CRLF
 */
int
sip_add_request_line(sip_msg_t sip_request, sip_method_t method,
    char *request_uri)
{
	_sip_header_t	*new_header;
	int		 header_size;
	_sip_msg_t	*_sip_request;

	if (method < INVITE || method >= MAX_SIP_METHODS ||
	    request_uri == NULL || sip_request == NULL) {
		return (EINVAL);
	}

	_sip_request = (_sip_msg_t *)sip_request;
	(void) pthread_mutex_lock(&_sip_request->sip_msg_mutex);
	if (_sip_request->sip_msg_cannot_be_modified) {
		(void) pthread_mutex_unlock(&_sip_request->sip_msg_mutex);
		return (ENOTSUP);
	}

	header_size = strlen(sip_methods[method].name) + SIP_SPACE_LEN +
	    strlen(request_uri) + SIP_SPACE_LEN + strlen(SIP_VERSION) +
	    strlen(SIP_CRLF);

	new_header = sip_new_header(header_size);
	if (new_header == NULL) {
		(void) pthread_mutex_unlock(&_sip_request->sip_msg_mutex);
		return (ENOMEM);
	}
	new_header->sip_hdr_sipmsg = _sip_request;

	(void) snprintf(new_header->sip_hdr_start, header_size + 1,
	    "%s %s %s%s", sip_methods[method].name, request_uri,
	    SIP_VERSION, SIP_CRLF);

	new_header->sip_hdr_next = _sip_request->sip_msg_start_line;
	_sip_request->sip_msg_start_line = new_header;
	_sip_request->sip_msg_len += header_size;
	(void) sip_parse_first_line(_sip_request->sip_msg_start_line,
	    &_sip_request->sip_msg_req_res);
	if (_sip_request->sip_msg_buf != NULL)
		_sip_request->sip_msg_modified = B_TRUE;
	(void) pthread_mutex_unlock(&_sip_request->sip_msg_mutex);
	return (0);
}