OpenSolaris_b135/lib/libsip/common/sip_xaction_state_mc.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 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);
}