xref: /onnv-gate/usr/src/lib/libsip/common/sip_xaction_state_mc.c (revision 5842:e93f793783f6)

/*
 * 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

/*
 * SIP Client/Server Invite/Non-Invite Transaction State machine.
 */

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

#include "sip_miscdefs.h"
#include "sip_msg.h"
#include "sip_xaction.h"

/*
 * Some Timer related info from RFC 3261, page 265.
 *
 * ----------------------------------------------------------------------
 * Timer    Value            Section               Meaning
 * ----------------------------------------------------------------------
 * T1       500ms default    Section 17.1.1.1     RTT Estimate
 * T2       4s               Section 17.1.2.2     The maximum retransmit
 *                                                interval for non-INVITE
 *                                                requests and INVITE
 *                                                responses
 * T4       5s               Section 17.1.2.2     Maximum duration a
 *                                                message will
 *                                                remain in the network
 * ----------------------------------------------------------------------
 * Timer A  initially T1     Section 17.1.1.2     INVITE request retransmit
 *                                                interval, for UDP only
 * Timer B  64*T1            Section 17.1.1.2     INVITE transaction
 *                                                timeout timer
 * Timer C  > 3min           Section 16.6         proxy INVITE transaction
 *                            bullet 11            timeout
 * Timer D  > 32s for UDP    Section 17.1.1.2     Wait time for response
 *          0s for TCP/SCTP                       retransmits
 * Timer E  initially T1     Section 17.1.2.2     non-INVITE request
 *                                                retransmit interval,
 *                                                UDP only
 * Timer F  64*T1            Section 17.1.2.2     non-INVITE transaction
 *                                                timeout timer
 * Timer G  initially T1     Section 17.2.1       INVITE response
 *                                                retransmit interval
 * Timer H  64*T1            Section 17.2.1       Wait time for
 *                                                ACK receipt
 * Timer I  T4 for UDP       Section 17.2.1       Wait time for
 *          0s for TCP/SCTP                       ACK retransmits
 * Timer J  64*T1 for UDP    Section 17.2.2       Wait time for
 *          0s for TCP/SCTP                       non-INVITE request
 *                                                retransmits
 * Timer K  T4 for UDP       Section 17.1.2.2     Wait time for
 *          0s for TCP/SCTP                       response retransmits
 * ----------------------------------------------------------------------
 */

#ifndef MIN
#define	MIN(a, b)	(((a) < (b)) ? (a):(b))
#endif

/*
 * Arg to the timer fire routine
 */
typedef	struct sip_xaction_timer_obj_s {
	sip_xaction_timer_type_t	sip_xaction_timer_type;
	sip_xaction_t			*sip_trans;
	int				sip_xaction_timer_xport;
} sip_xaction_time_obj_t;

int		sip_xaction_output(sip_conn_object_t, sip_xaction_t *,
		    _sip_msg_t *);
int		sip_xaction_input(sip_conn_object_t, sip_xaction_t *,
		    _sip_msg_t **);
void		sip_xaction_terminate(sip_xaction_t *, _sip_msg_t *, int);

static int 	sip_clnt_xaction_output(sip_conn_object_t, sip_xaction_t *,
		    _sip_msg_t *);
static int	sip_clnt_xaction_input(sip_conn_object_t, sip_xaction_t *,
		    _sip_msg_t **);
static int	sip_clnt_xaction_inv_res(sip_conn_object_t, sip_xaction_t *,
		    _sip_msg_t **);
static int	sip_clnt_xaction_noninv_res(sip_conn_object_t, sip_xaction_t *,
		    _sip_msg_t **);
static int 	sip_srv_xaction_output(sip_conn_object_t, sip_xaction_t *,
		    _sip_msg_t *);
static int	sip_srv_xaction_input(sip_conn_object_t, sip_xaction_t *,
		    _sip_msg_t **);
static int	sip_srv_xaction_inv_res(sip_conn_object_t, sip_xaction_t *,
		    _sip_msg_t *);
static int	sip_srv_xaction_noninv_res(sip_conn_object_t, sip_xaction_t *,
		    _sip_msg_t *);
static int	sip_create_send_nonOKack(sip_conn_object_t, sip_xaction_t *,
		    _sip_msg_t *, boolean_t);
void		sip_xaction_state_timer_fire(void *);

static sip_xaction_time_obj_t	*sip_setup_timer(sip_conn_object_t,
				    sip_xaction_t *, _sip_msg_t *,
				    sip_timer_t, int);

/*
 * Return a timer object
 */
static sip_xaction_time_obj_t *
sip_setup_timer(sip_conn_object_t conn_obj, sip_xaction_t *sip_trans,
    _sip_msg_t *sip_msg, sip_timer_t timer, int type)
{
	sip_xaction_time_obj_t	*sip_timer_obj = NULL;

	sip_timer_obj = (sip_xaction_time_obj_t *)
	    malloc(sizeof (sip_xaction_time_obj_t));
	if (sip_timer_obj == NULL)
		return (NULL);
	if (SIP_IS_TIMER_RUNNING(timer))
		SIP_CANCEL_TIMER(timer);
	sip_timer_obj->sip_xaction_timer_type = type;
	sip_timer_obj->sip_xaction_timer_xport = sip_conn_transport(conn_obj);
	sip_timer_obj->sip_trans = sip_trans;
	/*
	 * Save the message
	 */
	if (sip_msg != NULL) {
		(void) sip_add_conn_obj_cache(conn_obj, (void *)sip_trans);
		if (sip_trans->sip_xaction_last_msg != NULL) {
			SIP_MSG_REFCNT_DECR(sip_trans->sip_xaction_last_msg);
			sip_trans->sip_xaction_last_msg = NULL;
		}
		SIP_MSG_REFCNT_INCR(sip_msg);
		sip_trans->sip_xaction_last_msg = sip_msg;
	}
	return (sip_timer_obj);
}

/*
 * --------------------------- Output Routines ---------------------------
 */

/*
 * Send a SIP message, request or response, out
 */
int
sip_xaction_output(sip_conn_object_t conn_obj, sip_xaction_t *sip_trans,
    _sip_msg_t *msg)
{
	sip_message_type_t	*sip_msg_info;
	int			ret;

	if (conn_obj == NULL) {
		(void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex);
		sip_write_to_log((void *)sip_trans, SIP_TRANSACTION_LOG |
		    SIP_ASSERT_ERROR, __FILE__, __LINE__);
		(void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex);
	}
	assert(conn_obj != NULL);
	sip_msg_info = msg->sip_msg_req_res;

	(void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex);
	sip_trans->sip_xaction_msgcnt++;
	sip_add_log(&sip_trans->sip_xaction_log[sip_trans->sip_xaction_state],
	    (sip_msg_t)msg, sip_trans->sip_xaction_msgcnt, SIP_TRANSACTION_LOG);
	(void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex);

	if (sip_msg_info->is_request)
		return (sip_clnt_xaction_output(conn_obj, sip_trans, msg));

	ret = sip_srv_xaction_output(conn_obj, sip_trans, msg);

	return (ret);
}

/*
 * Send a Request out
 */
static int
sip_clnt_xaction_output(sip_conn_object_t conn_obj, sip_xaction_t *sip_trans,
    _sip_msg_t *msg)
{
	sip_xaction_time_obj_t	*timer_obj_A = NULL;
	sip_xaction_time_obj_t	*timer_obj_B = NULL;
	sip_xaction_time_obj_t	*timer_obj_E = NULL;
	sip_xaction_time_obj_t	*timer_obj_F = NULL;
	sip_message_type_t	*sip_msg_info;
	int			prev_state;
	int			error = 0;
	boolean_t		isreliable;

	(void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex);
	prev_state = sip_trans->sip_xaction_state;
	if (msg->sip_msg_req_res == NULL) {
		sip_write_to_log((void *)sip_trans, SIP_TRANSACTION_LOG |
		    SIP_ASSERT_ERROR, __FILE__, __LINE__);
	}
	assert(msg->sip_msg_req_res != NULL);
	sip_msg_info = msg->sip_msg_req_res;
	isreliable = sip_is_conn_reliable(conn_obj);

	if (sip_msg_info->sip_req_method == INVITE) {
		/*
		 * if transport is not reliable, start TIMER A.
		 */
		if (!isreliable) {
			timer_obj_A = sip_setup_timer(conn_obj, sip_trans,
			    msg, sip_trans->sip_xaction_TA,
			    SIP_XACTION_TIMER_A);
			if (timer_obj_A == NULL) {
				error = ENOMEM;
				goto error_ret;
			}
		}

		timer_obj_B = sip_setup_timer(conn_obj, sip_trans, NULL,
		    sip_trans->sip_xaction_TB, SIP_XACTION_TIMER_B);
		if (timer_obj_B == NULL) {
			error = ENOMEM;
			goto error_ret;
		}
		if (timer_obj_A != NULL) {
			SIP_SCHED_TIMER(sip_trans->sip_xaction_TA, timer_obj_A,
			    sip_xaction_state_timer_fire);
			if (!SIP_IS_TIMER_RUNNING(sip_trans->sip_xaction_TA)) {
				error = ENOMEM;
				goto error_ret;
			}
		}
		SIP_SCHED_TIMER(sip_trans->sip_xaction_TB, timer_obj_B,
		    sip_xaction_state_timer_fire);
		if (!SIP_IS_TIMER_RUNNING(sip_trans->sip_xaction_TB)) {
			if (timer_obj_A != NULL)
				SIP_CANCEL_TIMER(sip_trans->sip_xaction_TA)
			error = ENOMEM;
			goto error_ret;
		}
		sip_trans->sip_xaction_state = SIP_CLNT_CALLING;
	} else {
		/*
		 * if transport is not reliable, start rexmit Timer E.
		 */
		if (!isreliable) {
			timer_obj_E = sip_setup_timer(conn_obj, sip_trans, msg,
			    sip_trans->sip_xaction_TE, SIP_XACTION_TIMER_E);
			if (timer_obj_E == NULL) {
				error = ENOMEM;
				goto error_ret;
			}
		}
		/*
		 * Start transaction Timer F
		 */
		timer_obj_F = sip_setup_timer(conn_obj, sip_trans, NULL,
		    sip_trans->sip_xaction_TF, SIP_XACTION_TIMER_F);
		if (timer_obj_F == NULL) {
			error = ENOMEM;
			goto error_ret;
		}
		if (timer_obj_E != NULL) {
			SIP_SCHED_TIMER(sip_trans->sip_xaction_TE, timer_obj_E,
			    sip_xaction_state_timer_fire);
			if (!SIP_IS_TIMER_RUNNING(sip_trans->sip_xaction_TE)) {
				error = ENOMEM;
				goto error_ret;
			}
		}
		SIP_SCHED_TIMER(sip_trans->sip_xaction_TF, timer_obj_F,
		    sip_xaction_state_timer_fire);
		if (!SIP_IS_TIMER_RUNNING(sip_trans->sip_xaction_TF)) {
			if (timer_obj_E != NULL)
				SIP_CANCEL_TIMER(sip_trans->sip_xaction_TE)
			error = ENOMEM;
			goto error_ret;
		}
		sip_trans->sip_xaction_state = SIP_CLNT_TRYING;
	}
	(void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex);
	if (sip_xaction_ulp_state_cb != NULL) {
		sip_xaction_ulp_state_cb((sip_transaction_t)sip_trans,
		    (sip_msg_t)msg, prev_state, sip_trans->sip_xaction_state);
	}
	return (0);

error_ret:
	(void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex);
	if (timer_obj_A != NULL)
		free(timer_obj_A);
	if (timer_obj_B != NULL)
		free(timer_obj_B);
	if (timer_obj_E != NULL)
		free(timer_obj_E);
	if (timer_obj_F != NULL)
		free(timer_obj_F);
	return (error);
}

/*
 * Send a response out
 */
static int
sip_srv_xaction_output(sip_conn_object_t conn_obj, sip_xaction_t *sip_trans,
    _sip_msg_t *msg)
{
	int		ret;

	if (sip_trans->sip_xaction_method == INVITE)
		ret = sip_srv_xaction_inv_res(conn_obj, sip_trans, msg);
	else
		ret = sip_srv_xaction_noninv_res(conn_obj, sip_trans, msg);
	return (ret);
}

/*
 * Send a INVITE response out
 */
static int
sip_srv_xaction_inv_res(sip_conn_object_t conn_obj, sip_xaction_t *sip_trans,
    _sip_msg_t *msg)
{
	int			resp_code;
	sip_xaction_time_obj_t	*timer_obj_G = NULL;
	sip_xaction_time_obj_t	*timer_obj_H = NULL;
	sip_message_type_t	*sip_msg_info = msg->sip_msg_req_res;
	int			prev_state;
	boolean_t		isreliable;

	isreliable = sip_is_conn_reliable(conn_obj);

	resp_code = sip_msg_info->sip_resp_code;
	(void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex);
	prev_state = sip_trans->sip_xaction_state;
	switch (sip_trans->sip_xaction_state) {
		case SIP_SRV_INV_PROCEEDING:
			if (SIP_PROVISIONAL_RESP(resp_code)) {
				if (sip_trans->sip_xaction_last_msg != NULL) {
					SIP_MSG_REFCNT_DECR(
					    sip_trans->sip_xaction_last_msg);
					sip_trans->sip_xaction_last_msg = NULL;
				}
				SIP_MSG_REFCNT_INCR(msg);
				sip_trans->sip_xaction_last_msg = msg;
				(void) sip_add_conn_obj_cache(conn_obj,
				    (void *)sip_trans);
			} else if (SIP_OK_RESP(resp_code)) {
				sip_trans->sip_xaction_state =
				    SIP_SRV_INV_TERMINATED;
			} else  if (SIP_NONOK_FINAL_RESP(resp_code)) {
				if (sip_trans->sip_xaction_last_msg != NULL) {
					SIP_MSG_REFCNT_DECR(
					    sip_trans->sip_xaction_last_msg);
					sip_trans->sip_xaction_last_msg = NULL;
				}
				SIP_MSG_REFCNT_INCR(msg);
				sip_trans->sip_xaction_last_msg = msg;
				(void) sip_add_conn_obj_cache(conn_obj,
				    (void *)sip_trans);
				/*
				 * For unreliable transport start timer G
				 */
				if (!isreliable) {
					timer_obj_G = sip_setup_timer(
					    conn_obj, sip_trans,
					    NULL, sip_trans->sip_xaction_TG,
					    SIP_XACTION_TIMER_G);
					if (timer_obj_G == NULL) {
						(void) pthread_mutex_unlock(
						    &sip_trans->
						    sip_xaction_mutex);
						return (ENOMEM);
					}
				}
				/*
				 * Start Timer H
				 */
				timer_obj_H = sip_setup_timer(
				    conn_obj, sip_trans,
				    NULL, sip_trans->sip_xaction_TH,
				    SIP_XACTION_TIMER_H);
				if (timer_obj_H == NULL) {
					if (timer_obj_G != NULL)
						free(timer_obj_G);
					(void) pthread_mutex_unlock(
					    &sip_trans->sip_xaction_mutex);
					return (ENOMEM);
				}
				if (timer_obj_G != NULL) {
					SIP_SCHED_TIMER(
					    sip_trans->sip_xaction_TG,
					    timer_obj_G,
					    sip_xaction_state_timer_fire);
					if (!SIP_IS_TIMER_RUNNING(
					    sip_trans->sip_xaction_TG)) {
						(void) pthread_mutex_unlock(
						    &sip_trans->
						    sip_xaction_mutex);
						free(timer_obj_G);
						return (ENOMEM);
					}
				}
				if (timer_obj_H != NULL) {
					SIP_SCHED_TIMER(
					    sip_trans->sip_xaction_TH,
					    timer_obj_H,
					    sip_xaction_state_timer_fire);
					if (!SIP_IS_TIMER_RUNNING(
					    sip_trans->sip_xaction_TH)) {
						if (timer_obj_G != NULL) {
							SIP_CANCEL_TIMER(
							    sip_trans->
							    sip_xaction_TG);
							free(timer_obj_G);
						}
						(void) pthread_mutex_unlock(
						    &sip_trans->
						    sip_xaction_mutex);
						free(timer_obj_H);
						return (ENOMEM);
					}
				}
				sip_trans->sip_xaction_state =
				    SIP_SRV_INV_COMPLETED;
			}
			break;
		default:
			(void) pthread_mutex_unlock(
			    &sip_trans->sip_xaction_mutex);
			return (EPROTO);
	}
	(void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex);
	if (prev_state != sip_trans->sip_xaction_state &&
	    sip_xaction_ulp_state_cb != NULL) {
		sip_xaction_ulp_state_cb((sip_transaction_t)sip_trans,
		    (sip_msg_t)msg, prev_state, sip_trans->sip_xaction_state);
	}
	return (0);
}

/*
 *  Send a NON-INVITE response out
 */
static int
sip_srv_xaction_noninv_res(sip_conn_object_t conn_obj,
    sip_xaction_t *sip_trans, _sip_msg_t *msg)
{
	int			resp_code;
	sip_xaction_time_obj_t	*timer_obj_J = NULL;
	sip_message_type_t	*sip_msg_info = msg->sip_msg_req_res;
	int			prev_state;
	boolean_t		isreliable;

	resp_code = sip_msg_info->sip_resp_code;
	isreliable = sip_is_conn_reliable(conn_obj);

	(void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex);
	prev_state = sip_trans->sip_xaction_state;
	switch (sip_trans->sip_xaction_state) {
		case SIP_SRV_TRYING:
			if (sip_trans->sip_xaction_last_msg != NULL) {
				SIP_MSG_REFCNT_DECR(
				    sip_trans->sip_xaction_last_msg);
				sip_trans->sip_xaction_last_msg = NULL;
			}
			SIP_MSG_REFCNT_INCR(msg);
			sip_trans->sip_xaction_last_msg = msg;
			(void) sip_add_conn_obj_cache(conn_obj,
			    (void *)sip_trans);
			if (SIP_PROVISIONAL_RESP(resp_code)) {
				sip_trans->sip_xaction_state =
				    SIP_SRV_NONINV_PROCEEDING;
			} else if (SIP_FINAL_RESP(resp_code)) {
				/*
				 * For unreliable transports, start Timer J
				 */
				if (!isreliable) {
					timer_obj_J = sip_setup_timer(
					    conn_obj, sip_trans,
					    NULL, sip_trans->sip_xaction_TJ,
					    SIP_XACTION_TIMER_J);
					if (timer_obj_J == NULL) {
						(void) pthread_mutex_unlock(&
						    sip_trans->
						    sip_xaction_mutex);
						return (ENOMEM);
					}
					SIP_SCHED_TIMER(
					    sip_trans->sip_xaction_TJ,
					    timer_obj_J,
					    sip_xaction_state_timer_fire);
					if (!SIP_IS_TIMER_RUNNING(
					    sip_trans->sip_xaction_TJ)) {
						(void) pthread_mutex_unlock(&
						    sip_trans->
						    sip_xaction_mutex);
						free(timer_obj_J);
						return (ENOMEM);
					}
					sip_trans->sip_xaction_state =
					    SIP_SRV_NONINV_COMPLETED;
				} else {
					sip_trans->sip_xaction_state =
					    SIP_SRV_NONINV_TERMINATED;
				}
			}
			break;
		case SIP_SRV_NONINV_PROCEEDING:
			if (sip_trans->sip_xaction_last_msg != NULL) {
				SIP_MSG_REFCNT_DECR(
				    sip_trans->sip_xaction_last_msg);
				sip_trans->sip_xaction_last_msg = NULL;
			}
			SIP_MSG_REFCNT_INCR(msg);
			sip_trans->sip_xaction_last_msg = msg;
			(void) sip_add_conn_obj_cache(conn_obj,
			    (void *)sip_trans);
			if (SIP_PROVISIONAL_RESP(resp_code)) {
				break;
			} else if (SIP_FINAL_RESP(resp_code)) {
				/*
				 * For unreliable transports, start Timer J
				 */
				if (!isreliable) {
					timer_obj_J = sip_setup_timer(
					    conn_obj, sip_trans,
					    NULL, sip_trans->sip_xaction_TJ,
					    SIP_XACTION_TIMER_J);
					if (timer_obj_J == NULL) {
						(void) pthread_mutex_unlock(&
						    sip_trans->
						    sip_xaction_mutex);
						return (ENOMEM);
					}
					SIP_SCHED_TIMER(
					    sip_trans->sip_xaction_TJ,
					    timer_obj_J,
					    sip_xaction_state_timer_fire);
					if (!SIP_IS_TIMER_RUNNING(
					    sip_trans->sip_xaction_TJ)) {
						(void) pthread_mutex_unlock(&
						    sip_trans->
						    sip_xaction_mutex);
						free(timer_obj_J);
						return (ENOMEM);
					}
					sip_trans->sip_xaction_state =
					    SIP_SRV_NONINV_COMPLETED;
				} else {
					sip_trans->sip_xaction_state =
					    SIP_SRV_NONINV_TERMINATED;
				}
			}
			break;
		default:
			(void) pthread_mutex_unlock(
			    &sip_trans->sip_xaction_mutex);
			return (EPROTO);
	}
	(void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex);
	if (prev_state != sip_trans->sip_xaction_state &&
	    sip_xaction_ulp_state_cb != NULL) {
		sip_xaction_ulp_state_cb((sip_transaction_t)sip_trans,
		    (sip_msg_t)msg, prev_state, sip_trans->sip_xaction_state);
	}
	return (0);
}


/*
 * -------------------------- Input Routines ---------------------------
 */

/*
 * Process an incoming SIP message Request or Response
 */
int
sip_xaction_input(sip_conn_object_t conn_obj, sip_xaction_t *sip_trans,
    _sip_msg_t **sip_msg)
{
	sip_message_type_t	*sip_msg_info;
	int			ret;

	sip_msg_info = (*sip_msg)->sip_msg_req_res;

	(void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex);
	sip_trans->sip_xaction_msgcnt++;
	sip_add_log(&sip_trans->sip_xaction_log[sip_trans->sip_xaction_state],
	    (sip_msg_t)*sip_msg, sip_trans->sip_xaction_msgcnt,
	    SIP_TRANSACTION_LOG);
	(void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex);

	if (sip_msg_info->is_request)
		ret = sip_srv_xaction_input(conn_obj, sip_trans, sip_msg);
	else
		ret = sip_clnt_xaction_input(conn_obj, sip_trans, sip_msg);
	return (ret);
}

/*
 * Process a Request from the transport
 */
static int
sip_srv_xaction_input(sip_conn_object_t conn_obj, sip_xaction_t *sip_trans,
    _sip_msg_t **sip_msg)
{
	sip_message_type_t	*sip_msg_info;
	_sip_msg_t		*msg = *sip_msg;
	int			prev_state;
	boolean_t		isreliable;

	sip_msg_info = msg->sip_msg_req_res;
	isreliable = sip_is_conn_reliable(conn_obj);

	/*
	 * Cancel if the original transaction has not yet got a final
	 * response and send a 487 response.
	 */
	if (sip_msg_info->sip_req_method == ACK) {
		_sip_msg_t		*sip_last_resp;
		const sip_str_t		*resp_to_tag;
		const sip_str_t		*req_to_tag;
		int			error;
		sip_message_type_t	*last_msg_info;

		(void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex);

		if (sip_trans->sip_xaction_last_msg != NULL)
			sip_last_resp = sip_trans->sip_xaction_last_msg;
		else
			sip_last_resp = sip_trans->sip_xaction_orig_msg;
		last_msg_info = sip_last_resp->sip_msg_req_res;
		if (last_msg_info->is_request) {
			(void) pthread_mutex_unlock(
			    &sip_trans->sip_xaction_mutex);
			return (0);
		}
		req_to_tag = sip_get_to_tag((sip_msg_t)msg, &error);
		if (req_to_tag == NULL || error != 0) {
			(void) pthread_mutex_unlock(
			    &sip_trans->sip_xaction_mutex);
			return (0);
		}
		resp_to_tag = sip_get_to_tag((sip_msg_t)sip_last_resp,
		    &error);
		if (req_to_tag == NULL || error != 0) {
			(void) pthread_mutex_unlock(
			    &sip_trans->sip_xaction_mutex);
			return (0);
		}
		if (resp_to_tag->sip_str_len != req_to_tag->sip_str_len ||
		    strncmp(resp_to_tag->sip_str_ptr, req_to_tag->sip_str_ptr,
		    req_to_tag->sip_str_len) != 0) {
			(void) pthread_mutex_unlock(
			    &sip_trans->sip_xaction_mutex);
			return (0);
		}
		prev_state = sip_trans->sip_xaction_state;
		if (sip_trans->sip_xaction_state == SIP_SRV_INV_COMPLETED) {
			sip_xaction_time_obj_t	*timer_obj_I = NULL;

			SIP_CANCEL_TIMER(sip_trans->sip_xaction_TG);
			/*
			 * Cancel Timer H and goto TERMINATED state for
			 * reliable transports.
			 */
			if (isreliable) {
				SIP_CANCEL_TIMER(
				    sip_trans->sip_xaction_TH);
				sip_trans->sip_xaction_state =
				    SIP_SRV_INV_TERMINATED;
				(void) pthread_mutex_unlock(
				    &sip_trans->sip_xaction_mutex);
				if (sip_xaction_ulp_state_cb != NULL) {
					sip_xaction_ulp_state_cb(
					    (sip_transaction_t)sip_trans,
					    (sip_msg_t)msg, prev_state,
					    sip_trans->sip_xaction_state);
				}
				return (0);
			}
			/*
			 * For unreliable transports, start TIMER I and
			 * transition to CONFIRMED state.
			 */
			timer_obj_I = sip_setup_timer(conn_obj, sip_trans,
			    NULL,
			    sip_trans->sip_xaction_TI, SIP_XACTION_TIMER_I);
			if (timer_obj_I == NULL) {
				(void) pthread_mutex_unlock(
				    &sip_trans->sip_xaction_mutex);
				return (ENOMEM);
			}
			SIP_SCHED_TIMER(sip_trans->sip_xaction_TI,
			    timer_obj_I, sip_xaction_state_timer_fire);
			if (!SIP_IS_TIMER_RUNNING(sip_trans->sip_xaction_TI)) {
				(void) pthread_mutex_unlock(
				    &sip_trans->sip_xaction_mutex);
				free(timer_obj_I);
				return (ENOMEM);
			}
			sip_trans->sip_xaction_state = SIP_SRV_CONFIRMED;
		}
		(void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex);
		if (prev_state != sip_trans->sip_xaction_state &&
		    sip_xaction_ulp_state_cb != NULL) {
			sip_xaction_ulp_state_cb((sip_transaction_t)sip_trans,
			    (sip_msg_t)msg, prev_state,
			    sip_trans->sip_xaction_state);
		}
		return (0);
	} else if (sip_msg_info->sip_req_method == CANCEL) {
		if (sip_trans->sip_xaction_method == INVITE) {
			(void) pthread_mutex_unlock(
			    &sip_trans->sip_xaction_mutex);
			return (0);
		}
	}
	if (sip_msg_info->sip_req_method == INVITE) {
		(void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex);
		if (sip_trans->sip_xaction_method != INVITE) {
			sip_write_to_log((void *)sip_trans,
			    SIP_TRANSACTION_LOG | SIP_ASSERT_ERROR, __FILE__,
			    __LINE__);
		}
		assert(sip_trans->sip_xaction_method == INVITE);
		/*
		 * Retransmitted invite
		 */
		switch (sip_trans->sip_xaction_state) {
			case SIP_SRV_INV_PROCEEDING:
			case SIP_SRV_INV_COMPLETED:
				if (sip_trans->sip_xaction_last_msg != NULL) {
					_sip_msg_t		*new_msg;
					sip_message_type_t	*msg_info;
					int			resp;

					new_msg =
					    sip_trans->sip_xaction_last_msg;
					msg_info = new_msg->sip_msg_req_res;
					if (msg_info == NULL || msg_info->
					    is_request) {
						sip_write_to_log((void *)
						    sip_trans,
						    SIP_TRANSACTION_LOG |
						    SIP_ASSERT_ERROR, __FILE__,
						    __LINE__);
					}
					assert(msg_info != NULL && !msg_info->
					    is_request);
					resp = msg_info->sip_resp_code;
					SIP_UPDATE_COUNTERS(B_FALSE, 0, resp,
					    B_TRUE, new_msg->sip_msg_len);
					++sip_trans->sip_xaction_msgcnt;
					sip_add_log(&sip_trans->sip_xaction_log[
					    sip_trans->sip_xaction_state],
					    new_msg, sip_trans->
					    sip_xaction_msgcnt,
					    SIP_TRANSACTION_LOG);
					(void) sip_stack_send(conn_obj,
					    new_msg->sip_msg_buf,
					    new_msg->sip_msg_len);
				}
				break;
			default:
				(void) pthread_mutex_unlock(
				    &sip_trans->sip_xaction_mutex);
				return (EPROTO);
		}
		(void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex);
		/*
		 * We need to account for this invite received by the stack
		 * before we free that message.
		 */
		SIP_UPDATE_COUNTERS(B_TRUE, INVITE, 0, B_FALSE,
		    msg->sip_msg_len);
		sip_free_msg((sip_msg_t)msg);
		*sip_msg = NULL;
		return (0);
	}
	/*
	 * Retransmitted request
	 */
	(void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex);
	if (sip_trans->sip_xaction_method == INVITE) {
		sip_write_to_log((void *)sip_trans, SIP_TRANSACTION_LOG |
		    SIP_ASSERT_ERROR, __FILE__, __LINE__);
	}
	assert(sip_trans->sip_xaction_method != INVITE);
	switch (sip_trans->sip_xaction_state) {
		case SIP_SRV_NONINV_PROCEEDING:
		case SIP_SRV_NONINV_COMPLETED:
			if (sip_trans->sip_xaction_last_msg != NULL) {
				_sip_msg_t		*new_msg;
				sip_message_type_t	*msg_info;
				int			resp;

				new_msg = sip_trans->sip_xaction_last_msg;
				msg_info = new_msg->sip_msg_req_res;
				if (msg_info == NULL || msg_info->is_request) {
					sip_write_to_log((void *)sip_trans,
					    SIP_TRANSACTION_LOG |
					    SIP_ASSERT_ERROR, __FILE__,
					    __LINE__);
					}
				assert(msg_info != NULL && !msg_info->
				    is_request);
				resp = msg_info->sip_resp_code;
				SIP_UPDATE_COUNTERS(B_FALSE, 0, resp, B_TRUE,
				    new_msg->sip_msg_len);
				++sip_trans->sip_xaction_msgcnt;
				sip_add_log(&sip_trans->sip_xaction_log[
				    sip_trans->sip_xaction_state], new_msg,
				    sip_trans->sip_xaction_msgcnt,
				    SIP_TRANSACTION_LOG);
				(void) sip_stack_send(conn_obj,
				    new_msg->sip_msg_buf, new_msg->sip_msg_len);
			}
			break;
		default:
			(void) pthread_mutex_unlock(
			    &sip_trans->sip_xaction_mutex);
			return (EPROTO);
	}
	(void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex);
	/*
	 * We need to account for the retransmitted non-INVITE request here.
	 * When we return from here the msg will be freed and we will not
	 * be able to capture the details at sip_process_new_packet()
	 */
	SIP_UPDATE_COUNTERS(B_TRUE, sip_msg_info->sip_req_method, 0, B_FALSE,
	    msg->sip_msg_len);
	sip_free_msg((sip_msg_t)msg);
	*sip_msg = NULL;
	return (0);
}

/*
 * Process a Response
 */
static int
sip_clnt_xaction_input(sip_conn_object_t conn_obj, sip_xaction_t *sip_trans,
    _sip_msg_t **msg)
{
	int		ret;

	if (sip_trans->sip_xaction_method == INVITE)
		ret = sip_clnt_xaction_inv_res(conn_obj, sip_trans, msg);
	else
		ret = sip_clnt_xaction_noninv_res(conn_obj, sip_trans, msg);

	return (ret);
}

static int
sip_create_send_nonOKack(sip_conn_object_t conn_obj, sip_xaction_t *sip_trans,
    _sip_msg_t *msg, boolean_t copy)
{
	_sip_msg_t	*ack_msg;
	int		ret = 0;

	ack_msg = (_sip_msg_t *)sip_new_msg();
	if (ack_msg == NULL)
		return (ENOMEM);
	if ((ret = sip_create_nonOKack(
	    (sip_msg_t)sip_trans->sip_xaction_orig_msg, (sip_msg_t)msg,
	    (sip_msg_t)ack_msg)) != 0) {
		sip_free_msg((sip_msg_t)ack_msg);
		return (ret);
	}
	SIP_UPDATE_COUNTERS(B_TRUE, ACK, 0, B_TRUE, ack_msg->sip_msg_len);
	++sip_trans->sip_xaction_msgcnt;
	sip_add_log(&sip_trans->sip_xaction_log[sip_trans->sip_xaction_state],
	    ack_msg, sip_trans->sip_xaction_msgcnt, SIP_TRANSACTION_LOG);
	if ((ret = sip_stack_send(conn_obj, ack_msg->sip_msg_buf,
	    ack_msg->sip_msg_len)) != 0) {
		sip_free_msg((sip_msg_t)ack_msg);
		return (ret);
	}
	if (copy) {
		SIP_MSG_REFCNT_INCR(ack_msg);
		if (sip_trans->sip_xaction_last_msg != NULL) {
			SIP_MSG_REFCNT_DECR(sip_trans->sip_xaction_last_msg);
			sip_trans->sip_xaction_last_msg = NULL;
		}
		sip_trans->sip_xaction_last_msg = ack_msg;
	}
	sip_free_msg((sip_msg_t)ack_msg);
	return (0);
}

/*
 * Process a INVITE Response
 */
static int
sip_clnt_xaction_inv_res(sip_conn_object_t conn_obj, sip_xaction_t *sip_trans,
    _sip_msg_t **sip_msg)
{
	int			resp_code;
	_sip_msg_t		*msg = *sip_msg;
	sip_xaction_time_obj_t	*timer_obj_D = NULL;
	sip_message_type_t	*sip_msg_info;
	int			prev_state;
	boolean_t		isreliable;

	(void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex);
	if (msg->sip_msg_req_res == NULL) {
		sip_write_to_log((void *)sip_trans, SIP_TRANSACTION_LOG |
		    SIP_ASSERT_ERROR, __FILE__, __LINE__);
	}
	assert(msg->sip_msg_req_res != NULL);

	sip_msg_info = msg->sip_msg_req_res;
	resp_code = sip_msg_info->sip_resp_code;
	isreliable = sip_is_conn_reliable(conn_obj);

	prev_state = sip_trans->sip_xaction_state;
	switch (sip_trans->sip_xaction_state) {
		case SIP_CLNT_CALLING:
			if (SIP_PROVISIONAL_RESP(resp_code)) {
				/*
				 * sip_trans->sip_xaction_last_msg ?
				 */
				SIP_CANCEL_TIMER(
				    sip_trans->sip_xaction_TA);
				sip_trans->sip_xaction_state =
				    SIP_CLNT_INV_PROCEEDING;
			} else if (SIP_OK_RESP(resp_code)) {
				/*
				 * sip_trans->sip_xaction_last_msg ?
				 */
				SIP_CANCEL_TIMER(
				    sip_trans->sip_xaction_TA);
				SIP_CANCEL_TIMER(
				    sip_trans->sip_xaction_TB);
				sip_trans->sip_xaction_state =
				    SIP_CLNT_INV_TERMINATED;
			} else if (SIP_NONOK_FINAL_RESP(resp_code)) {
				int	ret;

				/*
				 * sip_trans->sip_xaction_last_msg ?
				 */
				SIP_CANCEL_TIMER(
				    sip_trans->sip_xaction_TA);
				SIP_CANCEL_TIMER(
				    sip_trans->sip_xaction_TB);
				if ((ret = sip_create_send_nonOKack(conn_obj,
				    sip_trans, msg, B_FALSE)) != 0) {
					(void) pthread_mutex_unlock(
					    &sip_trans->sip_xaction_mutex);
					return (ret);
				}
				/*
				 * start timer D for unreliable transports
				 */
				if (!isreliable) {
					timer_obj_D = sip_setup_timer(
					    conn_obj, sip_trans,
					    NULL, sip_trans->sip_xaction_TD,
					    SIP_XACTION_TIMER_D);
					if (timer_obj_D == NULL) {
						(void) pthread_mutex_unlock(
						    &sip_trans->
						    sip_xaction_mutex);
						return (ENOMEM);
					}
					SIP_SCHED_TIMER(
					    sip_trans->sip_xaction_TD,
					    timer_obj_D,
					    sip_xaction_state_timer_fire);
					if (!SIP_IS_TIMER_RUNNING(
					    sip_trans->sip_xaction_TD)) {
						(void) pthread_mutex_unlock(
						    &sip_trans->
						    sip_xaction_mutex);
						free(timer_obj_D);
						return (ENOMEM);
					}
					sip_trans->sip_xaction_state =
					    SIP_CLNT_INV_COMPLETED;
				} else {
					sip_trans->sip_xaction_state =
					    SIP_CLNT_INV_TERMINATED;
				}
			} else {
				/*
				 * Invalid resp_code
				 */
				(void) pthread_mutex_unlock(
				    &sip_trans->sip_xaction_mutex);
				return (EPROTO);
			}
			break;
		case SIP_CLNT_INV_PROCEEDING:
			if (SIP_PROVISIONAL_RESP(resp_code)) {
				break;
			} else if (SIP_OK_RESP(resp_code)) {
				SIP_CANCEL_TIMER(
				    sip_trans->sip_xaction_TB);
				sip_trans->sip_xaction_state =
				    SIP_CLNT_INV_TERMINATED;
			} else if (SIP_NONOK_FINAL_RESP(resp_code)) {
				int	ret;

				SIP_CANCEL_TIMER(
				    sip_trans->sip_xaction_TB);
				if ((ret = sip_create_send_nonOKack(conn_obj,
				    sip_trans, msg, B_FALSE)) != 0) {
					(void) pthread_mutex_unlock(
					    &sip_trans->sip_xaction_mutex);
					return (ret);
				}
				/*
				 * start timer D for unreliable transports
				 */
				if (!isreliable) {
					timer_obj_D = sip_setup_timer(
					    conn_obj, sip_trans,
					    NULL, sip_trans->sip_xaction_TD,
					    SIP_XACTION_TIMER_D);
					if (timer_obj_D == NULL) {
						(void) pthread_mutex_unlock(
						    &sip_trans->
						    sip_xaction_mutex);
						return (ENOMEM);
					}
					SIP_SCHED_TIMER(
					    sip_trans->sip_xaction_TD,
					    timer_obj_D,
					    sip_xaction_state_timer_fire);
					if (!SIP_IS_TIMER_RUNNING(
					    sip_trans->sip_xaction_TD)) {
						(void) pthread_mutex_unlock(
						    &sip_trans->
						    sip_xaction_mutex);
						free(timer_obj_D);
						return (ENOMEM);
					}
					sip_trans->sip_xaction_state =
					    SIP_CLNT_INV_COMPLETED;
				} else {
					sip_trans->sip_xaction_state =
					    SIP_CLNT_INV_TERMINATED;
				}
			} else {
				(void) pthread_mutex_unlock(
				    &sip_trans->sip_xaction_mutex);
				return (EPROTO);
			}
			break;
		case SIP_CLNT_INV_COMPLETED:
			/*
			 * Transport error takes it to
			 * SIP_CLNT_INV_TERMINATED
			 */
			if (SIP_NONOK_FINAL_RESP(resp_code)) {
				int	ret;

				if ((ret = sip_create_send_nonOKack(conn_obj,
				    sip_trans, msg, B_FALSE)) != 0) {
					(void) pthread_mutex_unlock(
					    &sip_trans->sip_xaction_mutex);
					return (ret);
				}
			} else {
				/*
				 * Invalid resp_code
				 */
				(void) pthread_mutex_unlock(
				    &sip_trans->sip_xaction_mutex);
				return (EPROTO);
			}
			break;
		default:
			(void) pthread_mutex_unlock(
			    &sip_trans->sip_xaction_mutex);
			return (EPROTO);
	}
	(void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex);
	if (prev_state != sip_trans->sip_xaction_state &&
	    sip_xaction_ulp_state_cb != NULL) {
		sip_xaction_ulp_state_cb((sip_transaction_t)sip_trans,
		    (sip_msg_t)msg, prev_state, sip_trans->sip_xaction_state);
	}
	return (0);
}

/*
 * Process a NON-INVITE Response
 */
static int
sip_clnt_xaction_noninv_res(sip_conn_object_t conn_obj,
    sip_xaction_t *sip_trans, _sip_msg_t **sip_msg)
{
	int			resp_code;
	sip_xaction_time_obj_t	*timer_obj_K = NULL;
	sip_message_type_t	*sip_msg_info;
	int			prev_state;
	_sip_msg_t		*msg = *sip_msg;
	boolean_t		isreliable;

	if (msg->sip_msg_req_res == NULL || sip_trans == NULL) {
		sip_write_to_log((void *)sip_trans, SIP_TRANSACTION_LOG |
		    SIP_ASSERT_ERROR, __FILE__, __LINE__);
	}
	assert(msg->sip_msg_req_res != NULL);
	assert(sip_trans != NULL);

	sip_msg_info = msg->sip_msg_req_res;
	isreliable = sip_is_conn_reliable(conn_obj);
	resp_code = sip_msg_info->sip_resp_code;
	(void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex);
	prev_state = sip_trans->sip_xaction_state;
	switch (sip_trans->sip_xaction_state) {
		case SIP_CLNT_TRYING:
			if (SIP_PROVISIONAL_RESP(resp_code)) {
				sip_trans->sip_xaction_state =
				    SIP_CLNT_NONINV_PROCEEDING;
			} else if (SIP_FINAL_RESP(resp_code)) {
				SIP_CANCEL_TIMER(
				    sip_trans->sip_xaction_TE);
				SIP_CANCEL_TIMER(
				    sip_trans->sip_xaction_TF);
				/*
				 * Start timer K for unreliable transports
				 */
				if (!isreliable) {
					timer_obj_K = sip_setup_timer(
					    conn_obj, sip_trans,
					    NULL, sip_trans->sip_xaction_TK,
					    SIP_XACTION_TIMER_K);
					if (timer_obj_K == NULL) {
						(void) pthread_mutex_unlock(&
						    sip_trans->
						    sip_xaction_mutex);
						return (ENOMEM);
					}
					SIP_SCHED_TIMER(
					    sip_trans->sip_xaction_TK,
					    timer_obj_K,
					    sip_xaction_state_timer_fire);
					if (!SIP_IS_TIMER_RUNNING(
					    sip_trans->sip_xaction_TK)) {
						(void) pthread_mutex_unlock(
						    &sip_trans->
						    sip_xaction_mutex);
						free(timer_obj_K);
						return (ENOMEM);
					}
					sip_trans->sip_xaction_state =
					    SIP_CLNT_NONINV_COMPLETED;
				} else {
					sip_trans->sip_xaction_state =
					    SIP_CLNT_NONINV_TERMINATED;
				}
			}
			break;
		case SIP_CLNT_NONINV_PROCEEDING:
			if (SIP_PROVISIONAL_RESP(resp_code)) {
				break;
			} else if (SIP_FINAL_RESP(resp_code)) {
				SIP_CANCEL_TIMER(
				    sip_trans->sip_xaction_TE);
				SIP_CANCEL_TIMER(
				    sip_trans->sip_xaction_TF);
				/*
				 * Start timer K for unreliable transports
				 */
				if (!isreliable) {
					timer_obj_K = sip_setup_timer(
					    conn_obj, sip_trans,
					    NULL, sip_trans->sip_xaction_TK,
					    SIP_XACTION_TIMER_K);
					if (timer_obj_K == NULL) {
						(void) pthread_mutex_unlock(&
						    sip_trans->
						    sip_xaction_mutex);
						return (ENOMEM);
					}
					SIP_SCHED_TIMER(
					    sip_trans->sip_xaction_TK,
					    timer_obj_K,
					    sip_xaction_state_timer_fire);
					if (!SIP_IS_TIMER_RUNNING(
					    sip_trans->sip_xaction_TK)) {
						(void) pthread_mutex_unlock(
						    &sip_trans->
						    sip_xaction_mutex);
						free(timer_obj_K);
						return (ENOMEM);
					}
					sip_trans->sip_xaction_state =
					    SIP_CLNT_NONINV_COMPLETED;
				} else {
					sip_trans->sip_xaction_state =
					    SIP_CLNT_NONINV_TERMINATED;
				}
			}
			break;
		default:
			(void) pthread_mutex_unlock(
			    &sip_trans->sip_xaction_mutex);
			return (EPROTO);
	}
	(void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex);
	if (prev_state != sip_trans->sip_xaction_state &&
	    sip_xaction_ulp_state_cb != NULL) {
		sip_xaction_ulp_state_cb((sip_transaction_t)sip_trans,
		    (sip_msg_t)msg, prev_state, sip_trans->sip_xaction_state);
	}
	return (0);
}

/*
 * If there is a transport error, sending the message out, terminate the
 * transaction.
 */
/* ARGSUSED */
void
sip_xaction_terminate(sip_xaction_t *sip_trans, _sip_msg_t *msg, int transport)
{
	sip_message_type_t	*sip_msg_info;
	int			state;
	int			prev_state;

	sip_msg_info = msg->sip_msg_req_res;
	(void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex);
	if (sip_msg_info->is_request) {
		if (sip_trans->sip_xaction_method == INVITE)
			state = SIP_CLNT_INV_TERMINATED;
		else
			state = SIP_CLNT_NONINV_TERMINATED;
	} else {
		if (sip_trans->sip_xaction_method == INVITE)
			state = SIP_SRV_INV_TERMINATED;
		else
			state = SIP_SRV_NONINV_TERMINATED;
	}
	prev_state = sip_trans->sip_xaction_state;
	sip_trans->sip_xaction_state = state;
	(void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex);
	if (sip_xaction_ulp_state_cb != NULL) {
		sip_xaction_ulp_state_cb((sip_transaction_t)sip_trans,
		    (sip_msg_t)msg, prev_state, sip_trans->sip_xaction_state);
	}
	sip_xaction_delete(sip_trans);
}

/*
 * --------------------------- Timer Routine ---------------------------
 */

void
sip_xaction_state_timer_fire(void *args)
{
	sip_xaction_time_obj_t	*time_obj = (sip_xaction_time_obj_t *)args;
	sip_xaction_t		*sip_trans = time_obj->sip_trans;
	_sip_msg_t		*new_msg;
	boolean_t		destroy_trans = B_FALSE;
	sip_conn_object_t	conn_obj;
	int			prev_state;
	sip_message_type_t	*msg_info;
	int			resp;
	sip_method_t		method;

	assert(time_obj != NULL);

	(void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex);
	prev_state = sip_trans->sip_xaction_state;
	switch (time_obj->sip_xaction_timer_type) {
		case SIP_XACTION_TIMER_A:
			if (sip_trans->sip_xaction_state != SIP_CLNT_CALLING)
				break;
			/*
			 * Assert candidate
			 */
			if (sip_trans->sip_xaction_last_msg == NULL)
				break;
			if (sip_trans->sip_xaction_conn_obj == NULL)
				break;
			new_msg = sip_trans->sip_xaction_last_msg;
			conn_obj = sip_trans->sip_xaction_conn_obj;
			/* timer A is for INVITE-RETRANSMIT only */
			SIP_UPDATE_COUNTERS(B_TRUE, INVITE, 0, B_TRUE, new_msg->
			    sip_msg_len);
			++sip_trans->sip_xaction_msgcnt;
			sip_add_log(&sip_trans->sip_xaction_log[sip_trans->
			    sip_xaction_state], new_msg, sip_trans->
			    sip_xaction_msgcnt, SIP_TRANSACTION_LOG);
			if (sip_stack_send(conn_obj, new_msg->sip_msg_buf,
			    new_msg->sip_msg_len) != 0) {
				sip_del_conn_obj_cache(
				    sip_trans->sip_xaction_conn_obj,
				    (void *)sip_trans);
				sip_trans->sip_xaction_state =
				    SIP_CLNT_INV_TERMINATED;
				(void) pthread_mutex_unlock(
				    &sip_trans->sip_xaction_mutex);
				if (sip_xaction_ulp_state_cb != NULL) {
					sip_xaction_ulp_state_cb(
					    (sip_transaction_t)sip_trans, NULL,
					    prev_state, sip_trans->
					    sip_xaction_state);
				}
				if (sip_xaction_ulp_trans_err != NULL) {
					sip_xaction_ulp_trans_err(sip_trans, 0,
					    NULL);
				}
				sip_xaction_delete(sip_trans);
				free(time_obj);
				return;
			}
			SIP_SET_TIMEOUT(sip_trans->sip_xaction_TA,
			    2 * SIP_GET_TIMEOUT(sip_trans->sip_xaction_TA));
			/*
			 * Reschedule the timer
			 */
			SIP_SCHED_TIMER(sip_trans->sip_xaction_TA,
			    time_obj, sip_xaction_state_timer_fire);
			if (!SIP_IS_TIMER_RUNNING(sip_trans->sip_xaction_TA)) {
				sip_del_conn_obj_cache(
				    sip_trans->sip_xaction_conn_obj,
				    (void *)sip_trans);
				sip_trans->sip_xaction_state =
				    SIP_CLNT_INV_TERMINATED;
				(void) pthread_mutex_unlock(
				    &sip_trans->sip_xaction_mutex);
				if (sip_xaction_ulp_state_cb != NULL) {
					sip_xaction_ulp_state_cb(
					    (sip_transaction_t)sip_trans, NULL,
					    prev_state, sip_trans->
					    sip_xaction_state);
				}
				if (sip_xaction_ulp_trans_err != NULL) {
					sip_xaction_ulp_trans_err(sip_trans, 0,
					    NULL);
				}
				sip_xaction_delete(sip_trans);
				free(time_obj);
				return;
			}
			(void) pthread_mutex_unlock(
			    &sip_trans->sip_xaction_mutex);
			return;
		case SIP_XACTION_TIMER_B:
			SIP_CANCEL_TIMER(sip_trans->sip_xaction_TA);
			if (sip_trans->sip_xaction_state == SIP_CLNT_CALLING) {
				sip_trans->sip_xaction_state =
				    SIP_CLNT_INV_TERMINATED;
				(void) pthread_mutex_unlock(
				    &sip_trans->sip_xaction_mutex);
				if (sip_xaction_ulp_state_cb != NULL) {
					sip_xaction_ulp_state_cb(
					    (sip_transaction_t)sip_trans, NULL,
					    prev_state, sip_trans->
					    sip_xaction_state);
				}
				if (sip_xaction_ulp_trans_err != NULL) {
					sip_xaction_ulp_trans_err(sip_trans, 0,
					    NULL);
				}
				sip_xaction_delete(sip_trans);
				free(time_obj);
				return;
			}
			break;
		case SIP_XACTION_TIMER_D:
			if (sip_trans->sip_xaction_state ==
			    SIP_CLNT_INV_COMPLETED) {
				SIP_CANCEL_TIMER(
				    sip_trans->sip_xaction_TB);
				sip_trans->sip_xaction_state =
				    SIP_CLNT_INV_TERMINATED;
				destroy_trans = B_TRUE;
			}
			break;
		case SIP_XACTION_TIMER_E:
			/*
			 * Assert candidate
			 */
			if (sip_trans->sip_xaction_state != SIP_CLNT_TRYING &&
			    sip_trans->sip_xaction_state !=
			    SIP_CLNT_NONINV_PROCEEDING) {
				break;
			}
			/*
			 * Assert candidate
			 */
			if (sip_trans->sip_xaction_last_msg == NULL)
				break;
			if (sip_trans->sip_xaction_conn_obj == NULL)
				break;
			conn_obj = sip_trans->sip_xaction_conn_obj;
			new_msg = sip_trans->sip_xaction_last_msg;
			/* Timer E is for non-INVITE request */

			msg_info = new_msg->sip_msg_req_res;
			if (msg_info == NULL || !msg_info->is_request) {
				(void) sip_write_to_log((void *) sip_trans,
				    SIP_TRANSACTION_LOG | SIP_ASSERT_ERROR,
				    __FILE__, __LINE__);
			}
			assert(msg_info != NULL && msg_info->is_request);
			method = msg_info->sip_req_method;
			SIP_UPDATE_COUNTERS(B_TRUE, method, 0, B_TRUE, new_msg->
			    sip_msg_len);
			++sip_trans->sip_xaction_msgcnt;
			sip_add_log(&sip_trans->sip_xaction_log[sip_trans->
			    sip_xaction_state], new_msg, sip_trans->
			    sip_xaction_msgcnt, SIP_TRANSACTION_LOG);
			if (sip_stack_send(conn_obj, new_msg->sip_msg_buf,
			    new_msg->sip_msg_len) != 0) {
				sip_del_conn_obj_cache(
				    sip_trans->sip_xaction_conn_obj,
				    (void *)sip_trans);
				sip_trans->sip_xaction_state =
				    SIP_CLNT_NONINV_TERMINATED;
				(void) pthread_mutex_unlock(
				    &sip_trans->sip_xaction_mutex);
				if (sip_xaction_ulp_state_cb != NULL) {
					sip_xaction_ulp_state_cb(
					    (sip_transaction_t)sip_trans, NULL,
					    prev_state, sip_trans->
					    sip_xaction_state);
				}
				if (sip_xaction_ulp_trans_err != NULL) {
					sip_xaction_ulp_trans_err(sip_trans, 0,
					    NULL);
				}
				sip_xaction_delete(sip_trans);
				free(time_obj);
				return;
			}
			SIP_SET_TIMEOUT(sip_trans->sip_xaction_TE,
			    MIN(SIP_TIMER_T2,
			    2 * SIP_GET_TIMEOUT(sip_trans->sip_xaction_TE)));
			/*
			 * Reschedule the timer
			 */
			SIP_SCHED_TIMER(sip_trans->sip_xaction_TE,
			    time_obj, sip_xaction_state_timer_fire);
			if (!SIP_IS_TIMER_RUNNING(sip_trans->sip_xaction_TE)) {
				sip_del_conn_obj_cache(
				    sip_trans->sip_xaction_conn_obj,
				    (void *)sip_trans);
				sip_trans->sip_xaction_state =
				    SIP_CLNT_NONINV_TERMINATED;
				(void) pthread_mutex_unlock(
				    &sip_trans->sip_xaction_mutex);
				if (sip_xaction_ulp_state_cb != NULL) {
					sip_xaction_ulp_state_cb(
					    (sip_transaction_t)sip_trans, NULL,
					    prev_state, sip_trans->
					    sip_xaction_state);
				}
				if (sip_xaction_ulp_trans_err != NULL) {
					sip_xaction_ulp_trans_err(sip_trans, 0,
					    NULL);
				}
				sip_xaction_delete(sip_trans);
				free(time_obj);
				return;
			}
			(void) pthread_mutex_unlock(
			    &sip_trans->sip_xaction_mutex);
			return;
		case SIP_XACTION_TIMER_F:
			SIP_CANCEL_TIMER(sip_trans->sip_xaction_TE);
			if (sip_trans->sip_xaction_state == SIP_CLNT_TRYING ||
			    sip_trans->sip_xaction_state ==
			    SIP_CLNT_NONINV_PROCEEDING) {
				sip_trans->sip_xaction_state =
				    SIP_CLNT_NONINV_TERMINATED;
				(void) pthread_mutex_unlock(
				    &sip_trans->sip_xaction_mutex);
				if (sip_xaction_ulp_state_cb != NULL) {
					sip_xaction_ulp_state_cb(
					    (sip_transaction_t)sip_trans, NULL,
					    prev_state, sip_trans->
					    sip_xaction_state);
				}
				if (sip_xaction_ulp_trans_err != NULL) {
					sip_xaction_ulp_trans_err(sip_trans, 0,
					    NULL);
				}
				sip_xaction_delete(sip_trans);
				free(time_obj);
				return;
			}
			break;
		case SIP_XACTION_TIMER_G:
			/*
			 * Assert candidate
			 */
			if (sip_trans->sip_xaction_last_msg == NULL)
				break;
			if (sip_trans->sip_xaction_conn_obj == NULL)
				break;
			if (sip_trans->sip_xaction_state !=
			    SIP_SRV_INV_COMPLETED) {
				break;
			}
			new_msg = sip_trans->sip_xaction_last_msg;
			conn_obj = sip_trans->sip_xaction_conn_obj;
			msg_info = new_msg->sip_msg_req_res;
			if (msg_info == NULL || msg_info->is_request) {
				(void) sip_write_to_log((void *) sip_trans,
				    SIP_TRANSACTION_LOG | SIP_ASSERT_ERROR,
				    __FILE__, __LINE__);
			}
			assert(msg_info != NULL && !msg_info->is_request);
			resp = msg_info->sip_resp_code;
			SIP_UPDATE_COUNTERS(B_FALSE, 0, resp, B_TRUE, new_msg->
			    sip_msg_len);
			++sip_trans->sip_xaction_msgcnt;
			sip_add_log(&sip_trans->sip_xaction_log[sip_trans->
			    sip_xaction_state], new_msg, sip_trans->
			    sip_xaction_msgcnt, SIP_TRANSACTION_LOG);
			if (sip_stack_send(conn_obj, new_msg->sip_msg_buf,
			    new_msg->sip_msg_len) != 0) {
				sip_del_conn_obj_cache(
				    sip_trans->sip_xaction_conn_obj,
				    (void *)sip_trans);
				sip_trans->sip_xaction_state =
				    SIP_SRV_INV_TERMINATED;
				(void) pthread_mutex_unlock(
				    &sip_trans->sip_xaction_mutex);
				if (sip_xaction_ulp_state_cb != NULL) {
					sip_xaction_ulp_state_cb(
					    (sip_transaction_t)sip_trans, NULL,
					    prev_state, sip_trans->
					    sip_xaction_state);
				}
				if (sip_xaction_ulp_trans_err != NULL) {
					sip_xaction_ulp_trans_err(sip_trans, 0,
					    NULL);
				}
				sip_xaction_delete(sip_trans);
				free(time_obj);
				return;
			}
			SIP_SET_TIMEOUT(sip_trans->sip_xaction_TG,
			    MIN(SIP_TIMER_T2,
			    2 * SIP_GET_TIMEOUT(sip_trans->sip_xaction_TG)));
			SIP_SCHED_TIMER(sip_trans->sip_xaction_TG,
			    time_obj, sip_xaction_state_timer_fire);
			if (!SIP_IS_TIMER_RUNNING(sip_trans->sip_xaction_TG)) {
				sip_del_conn_obj_cache(
				    sip_trans->sip_xaction_conn_obj,
				    (void *)sip_trans);
				sip_trans->sip_xaction_state =
				    SIP_SRV_INV_TERMINATED;
				(void) pthread_mutex_unlock(
				    &sip_trans->sip_xaction_mutex);
				if (sip_xaction_ulp_state_cb != NULL) {
					sip_xaction_ulp_state_cb(
					    (sip_transaction_t)sip_trans, NULL,
					    prev_state, sip_trans->
					    sip_xaction_state);
				}
				if (sip_xaction_ulp_trans_err != NULL) {
					sip_xaction_ulp_trans_err(sip_trans, 0,
					    NULL);
				}
				sip_xaction_delete(sip_trans);
				free(time_obj);
				return;
			}
			(void) pthread_mutex_unlock(
			    &sip_trans->sip_xaction_mutex);
			return;
		case SIP_XACTION_TIMER_H:
			SIP_CANCEL_TIMER(sip_trans->sip_xaction_TG);
			if (sip_trans->sip_xaction_state ==
			    SIP_SRV_INV_COMPLETED) {
				sip_trans->sip_xaction_state =
				    SIP_SRV_INV_TERMINATED;
				(void) pthread_mutex_unlock(
				    &sip_trans->sip_xaction_mutex);
				if (sip_xaction_ulp_state_cb != NULL) {
					sip_xaction_ulp_state_cb(
					    (sip_transaction_t)sip_trans, NULL,
					    prev_state, sip_trans->
					    sip_xaction_state);
				}
				if (sip_xaction_ulp_trans_err != NULL) {
					sip_xaction_ulp_trans_err(sip_trans, 0,
					    NULL);
				}
				sip_xaction_delete(sip_trans);
				free(time_obj);
				return;
			}
			break;
		case SIP_XACTION_TIMER_I:
			if (sip_trans->sip_xaction_state ==
			    SIP_SRV_CONFIRMED) {
				SIP_CANCEL_TIMER(
				    sip_trans->sip_xaction_TH);
				sip_trans->sip_xaction_state =
				    SIP_SRV_INV_TERMINATED;
				destroy_trans = B_TRUE;
			}
			break;
		case SIP_XACTION_TIMER_J:
			if (sip_trans->sip_xaction_state ==
			    SIP_SRV_NONINV_COMPLETED) {
				sip_trans->sip_xaction_state =
				    SIP_SRV_NONINV_TERMINATED;
				destroy_trans = B_TRUE;

			}
			break;
		case SIP_XACTION_TIMER_K:
			if (sip_trans->sip_xaction_state ==
			    SIP_CLNT_NONINV_COMPLETED) {
				SIP_CANCEL_TIMER(
				    sip_trans->sip_xaction_TF);
				sip_trans->sip_xaction_state =
				    SIP_CLNT_NONINV_TERMINATED;
				destroy_trans = B_TRUE;
			}
			break;
		default:
			break;
	}
	if (destroy_trans) {
		(void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex);
		if (sip_xaction_ulp_state_cb != NULL &&
		    prev_state != sip_trans->sip_xaction_state) {
			sip_xaction_ulp_state_cb((sip_transaction_t)sip_trans,
			    NULL, prev_state, sip_trans->sip_xaction_state);
		}
		sip_xaction_delete(sip_trans);
		free(time_obj);
		return;
	}
	(void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex);
	if (sip_xaction_ulp_state_cb != NULL &&
	    prev_state != sip_trans->sip_xaction_state) {
		sip_xaction_ulp_state_cb((sip_transaction_t)sip_trans, NULL,
		    prev_state, sip_trans->sip_xaction_state);
	}
	free(time_obj);
}