1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* 28 * SIP Client/Server Invite/Non-Invite Transaction State machine. 29 */ 30 31 #include <stdlib.h> 32 #include <string.h> 33 #include <assert.h> 34 #include <errno.h> 35 #include <pthread.h> 36 #include <sip.h> 37 38 #include "sip_miscdefs.h" 39 #include "sip_msg.h" 40 #include "sip_xaction.h" 41 42 /* 43 * Some Timer related info from RFC 3261, page 265. 44 * 45 * ---------------------------------------------------------------------- 46 * Timer Value Section Meaning 47 * ---------------------------------------------------------------------- 48 * T1 500ms default Section 17.1.1.1 RTT Estimate 49 * T2 4s Section 17.1.2.2 The maximum retransmit 50 * interval for non-INVITE 51 * requests and INVITE 52 * responses 53 * T4 5s Section 17.1.2.2 Maximum duration a 54 * message will 55 * remain in the network 56 * ---------------------------------------------------------------------- 57 * Timer A initially T1 Section 17.1.1.2 INVITE request retransmit 58 * interval, for UDP only 59 * Timer B 64*T1 Section 17.1.1.2 INVITE transaction 60 * timeout timer 61 * Timer C > 3min Section 16.6 proxy INVITE transaction 62 * bullet 11 timeout 63 * Timer D > 32s for UDP Section 17.1.1.2 Wait time for response 64 * 0s for TCP/SCTP retransmits 65 * Timer E initially T1 Section 17.1.2.2 non-INVITE request 66 * retransmit interval, 67 * UDP only 68 * Timer F 64*T1 Section 17.1.2.2 non-INVITE transaction 69 * timeout timer 70 * Timer G initially T1 Section 17.2.1 INVITE response 71 * retransmit interval 72 * Timer H 64*T1 Section 17.2.1 Wait time for 73 * ACK receipt 74 * Timer I T4 for UDP Section 17.2.1 Wait time for 75 * 0s for TCP/SCTP ACK retransmits 76 * Timer J 64*T1 for UDP Section 17.2.2 Wait time for 77 * 0s for TCP/SCTP non-INVITE request 78 * retransmits 79 * Timer K T4 for UDP Section 17.1.2.2 Wait time for 80 * 0s for TCP/SCTP response retransmits 81 * ---------------------------------------------------------------------- 82 */ 83 84 #ifndef MIN 85 #define MIN(a, b) (((a) < (b)) ? (a):(b)) 86 #endif 87 88 /* 89 * Arg to the timer fire routine 90 */ 91 typedef struct sip_xaction_timer_obj_s { 92 sip_xaction_timer_type_t sip_xaction_timer_type; 93 sip_xaction_t *sip_trans; 94 int sip_xaction_timer_xport; 95 } sip_xaction_time_obj_t; 96 97 int sip_xaction_output(sip_conn_object_t, sip_xaction_t *, 98 _sip_msg_t *); 99 int sip_xaction_input(sip_conn_object_t, sip_xaction_t *, 100 _sip_msg_t **); 101 void sip_xaction_terminate(sip_xaction_t *, _sip_msg_t *, int); 102 103 static int sip_clnt_xaction_output(sip_conn_object_t, sip_xaction_t *, 104 _sip_msg_t *); 105 static int sip_clnt_xaction_input(sip_conn_object_t, sip_xaction_t *, 106 _sip_msg_t **); 107 static int sip_clnt_xaction_inv_res(sip_conn_object_t, sip_xaction_t *, 108 _sip_msg_t **); 109 static int sip_clnt_xaction_noninv_res(sip_conn_object_t, sip_xaction_t *, 110 _sip_msg_t **); 111 static int sip_srv_xaction_output(sip_conn_object_t, sip_xaction_t *, 112 _sip_msg_t *); 113 static int sip_srv_xaction_input(sip_conn_object_t, sip_xaction_t *, 114 _sip_msg_t **); 115 static int sip_srv_xaction_inv_res(sip_conn_object_t, sip_xaction_t *, 116 _sip_msg_t *); 117 static int sip_srv_xaction_noninv_res(sip_conn_object_t, sip_xaction_t *, 118 _sip_msg_t *); 119 static int sip_create_send_nonOKack(sip_conn_object_t, sip_xaction_t *, 120 _sip_msg_t *, boolean_t); 121 void sip_xaction_state_timer_fire(void *); 122 123 static sip_xaction_time_obj_t *sip_setup_timer(sip_conn_object_t, 124 sip_xaction_t *, _sip_msg_t *, 125 sip_timer_t, int); 126 127 /* 128 * Return a timer object 129 */ 130 static sip_xaction_time_obj_t * 131 sip_setup_timer(sip_conn_object_t conn_obj, sip_xaction_t *sip_trans, 132 _sip_msg_t *sip_msg, sip_timer_t timer, int type) 133 { 134 sip_xaction_time_obj_t *sip_timer_obj = NULL; 135 136 sip_timer_obj = (sip_xaction_time_obj_t *) 137 malloc(sizeof (sip_xaction_time_obj_t)); 138 if (sip_timer_obj == NULL) 139 return (NULL); 140 if (SIP_IS_TIMER_RUNNING(timer)) 141 SIP_CANCEL_TIMER(timer); 142 sip_timer_obj->sip_xaction_timer_type = type; 143 sip_timer_obj->sip_xaction_timer_xport = sip_conn_transport(conn_obj); 144 sip_timer_obj->sip_trans = sip_trans; 145 /* 146 * Save the message 147 */ 148 if (sip_msg != NULL) { 149 (void) sip_add_conn_obj_cache(conn_obj, (void *)sip_trans); 150 if (sip_trans->sip_xaction_last_msg != NULL) { 151 SIP_MSG_REFCNT_DECR(sip_trans->sip_xaction_last_msg); 152 sip_trans->sip_xaction_last_msg = NULL; 153 } 154 SIP_MSG_REFCNT_INCR(sip_msg); 155 sip_trans->sip_xaction_last_msg = sip_msg; 156 } 157 return (sip_timer_obj); 158 } 159 160 /* 161 * --------------------------- Output Routines --------------------------- 162 */ 163 164 /* 165 * Send a SIP message, request or response, out 166 */ 167 int 168 sip_xaction_output(sip_conn_object_t conn_obj, sip_xaction_t *sip_trans, 169 _sip_msg_t *msg) 170 { 171 sip_message_type_t *sip_msg_info; 172 int ret; 173 174 if (conn_obj == NULL) { 175 (void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex); 176 sip_write_to_log((void *)sip_trans, SIP_TRANSACTION_LOG | 177 SIP_ASSERT_ERROR, __FILE__, __LINE__); 178 (void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex); 179 } 180 assert(conn_obj != NULL); 181 sip_msg_info = msg->sip_msg_req_res; 182 183 (void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex); 184 sip_trans->sip_xaction_msgcnt++; 185 sip_add_log(&sip_trans->sip_xaction_log[sip_trans->sip_xaction_state], 186 (sip_msg_t)msg, sip_trans->sip_xaction_msgcnt, SIP_TRANSACTION_LOG); 187 (void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex); 188 189 if (sip_msg_info->is_request) 190 return (sip_clnt_xaction_output(conn_obj, sip_trans, msg)); 191 192 ret = sip_srv_xaction_output(conn_obj, sip_trans, msg); 193 194 return (ret); 195 } 196 197 /* 198 * Send a Request out 199 */ 200 static int 201 sip_clnt_xaction_output(sip_conn_object_t conn_obj, sip_xaction_t *sip_trans, 202 _sip_msg_t *msg) 203 { 204 sip_xaction_time_obj_t *timer_obj_A = NULL; 205 sip_xaction_time_obj_t *timer_obj_B = NULL; 206 sip_xaction_time_obj_t *timer_obj_E = NULL; 207 sip_xaction_time_obj_t *timer_obj_F = NULL; 208 sip_message_type_t *sip_msg_info; 209 int prev_state; 210 int error = 0; 211 boolean_t isreliable; 212 213 (void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex); 214 prev_state = sip_trans->sip_xaction_state; 215 if (msg->sip_msg_req_res == NULL) { 216 sip_write_to_log((void *)sip_trans, SIP_TRANSACTION_LOG | 217 SIP_ASSERT_ERROR, __FILE__, __LINE__); 218 } 219 assert(msg->sip_msg_req_res != NULL); 220 sip_msg_info = msg->sip_msg_req_res; 221 isreliable = sip_is_conn_reliable(conn_obj); 222 223 if (sip_msg_info->sip_req_method == INVITE) { 224 /* 225 * if transport is not reliable, start TIMER A. 226 */ 227 if (!isreliable) { 228 timer_obj_A = sip_setup_timer(conn_obj, sip_trans, 229 msg, sip_trans->sip_xaction_TA, 230 SIP_XACTION_TIMER_A); 231 if (timer_obj_A == NULL) { 232 error = ENOMEM; 233 goto error_ret; 234 } 235 } 236 237 timer_obj_B = sip_setup_timer(conn_obj, sip_trans, NULL, 238 sip_trans->sip_xaction_TB, SIP_XACTION_TIMER_B); 239 if (timer_obj_B == NULL) { 240 error = ENOMEM; 241 goto error_ret; 242 } 243 if (timer_obj_A != NULL) { 244 SIP_SCHED_TIMER(sip_trans->sip_xaction_TA, timer_obj_A, 245 sip_xaction_state_timer_fire); 246 if (!SIP_IS_TIMER_RUNNING(sip_trans->sip_xaction_TA)) { 247 error = ENOMEM; 248 goto error_ret; 249 } 250 } 251 SIP_SCHED_TIMER(sip_trans->sip_xaction_TB, timer_obj_B, 252 sip_xaction_state_timer_fire); 253 if (!SIP_IS_TIMER_RUNNING(sip_trans->sip_xaction_TB)) { 254 if (timer_obj_A != NULL) 255 SIP_CANCEL_TIMER(sip_trans->sip_xaction_TA) 256 error = ENOMEM; 257 goto error_ret; 258 } 259 sip_trans->sip_xaction_state = SIP_CLNT_CALLING; 260 } else { 261 /* 262 * if transport is not reliable, start rexmit Timer E. 263 */ 264 if (!isreliable) { 265 timer_obj_E = sip_setup_timer(conn_obj, sip_trans, msg, 266 sip_trans->sip_xaction_TE, SIP_XACTION_TIMER_E); 267 if (timer_obj_E == NULL) { 268 error = ENOMEM; 269 goto error_ret; 270 } 271 } 272 /* 273 * Start transaction Timer F 274 */ 275 timer_obj_F = sip_setup_timer(conn_obj, sip_trans, NULL, 276 sip_trans->sip_xaction_TF, SIP_XACTION_TIMER_F); 277 if (timer_obj_F == NULL) { 278 error = ENOMEM; 279 goto error_ret; 280 } 281 if (timer_obj_E != NULL) { 282 SIP_SCHED_TIMER(sip_trans->sip_xaction_TE, timer_obj_E, 283 sip_xaction_state_timer_fire); 284 if (!SIP_IS_TIMER_RUNNING(sip_trans->sip_xaction_TE)) { 285 error = ENOMEM; 286 goto error_ret; 287 } 288 } 289 SIP_SCHED_TIMER(sip_trans->sip_xaction_TF, timer_obj_F, 290 sip_xaction_state_timer_fire); 291 if (!SIP_IS_TIMER_RUNNING(sip_trans->sip_xaction_TF)) { 292 if (timer_obj_E != NULL) 293 SIP_CANCEL_TIMER(sip_trans->sip_xaction_TE) 294 error = ENOMEM; 295 goto error_ret; 296 } 297 sip_trans->sip_xaction_state = SIP_CLNT_TRYING; 298 } 299 (void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex); 300 if (sip_xaction_ulp_state_cb != NULL) { 301 sip_xaction_ulp_state_cb((sip_transaction_t)sip_trans, 302 (sip_msg_t)msg, prev_state, sip_trans->sip_xaction_state); 303 } 304 return (0); 305 306 error_ret: 307 (void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex); 308 if (timer_obj_A != NULL) 309 free(timer_obj_A); 310 if (timer_obj_B != NULL) 311 free(timer_obj_B); 312 if (timer_obj_E != NULL) 313 free(timer_obj_E); 314 if (timer_obj_F != NULL) 315 free(timer_obj_F); 316 return (error); 317 } 318 319 /* 320 * Send a response out 321 */ 322 static int 323 sip_srv_xaction_output(sip_conn_object_t conn_obj, sip_xaction_t *sip_trans, 324 _sip_msg_t *msg) 325 { 326 int ret; 327 328 if (sip_trans->sip_xaction_method == INVITE) 329 ret = sip_srv_xaction_inv_res(conn_obj, sip_trans, msg); 330 else 331 ret = sip_srv_xaction_noninv_res(conn_obj, sip_trans, msg); 332 return (ret); 333 } 334 335 /* 336 * Send a INVITE response out 337 */ 338 static int 339 sip_srv_xaction_inv_res(sip_conn_object_t conn_obj, sip_xaction_t *sip_trans, 340 _sip_msg_t *msg) 341 { 342 int resp_code; 343 sip_xaction_time_obj_t *timer_obj_G = NULL; 344 sip_xaction_time_obj_t *timer_obj_H = NULL; 345 sip_message_type_t *sip_msg_info = msg->sip_msg_req_res; 346 int prev_state; 347 boolean_t isreliable; 348 349 isreliable = sip_is_conn_reliable(conn_obj); 350 351 resp_code = sip_msg_info->sip_resp_code; 352 (void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex); 353 prev_state = sip_trans->sip_xaction_state; 354 switch (sip_trans->sip_xaction_state) { 355 case SIP_SRV_INV_PROCEEDING: 356 if (SIP_PROVISIONAL_RESP(resp_code)) { 357 if (sip_trans->sip_xaction_last_msg != NULL) { 358 SIP_MSG_REFCNT_DECR( 359 sip_trans->sip_xaction_last_msg); 360 sip_trans->sip_xaction_last_msg = NULL; 361 } 362 SIP_MSG_REFCNT_INCR(msg); 363 sip_trans->sip_xaction_last_msg = msg; 364 (void) sip_add_conn_obj_cache(conn_obj, 365 (void *)sip_trans); 366 } else if (SIP_OK_RESP(resp_code)) { 367 sip_trans->sip_xaction_state = 368 SIP_SRV_INV_TERMINATED; 369 } else if (SIP_NONOK_FINAL_RESP(resp_code)) { 370 if (sip_trans->sip_xaction_last_msg != NULL) { 371 SIP_MSG_REFCNT_DECR( 372 sip_trans->sip_xaction_last_msg); 373 sip_trans->sip_xaction_last_msg = NULL; 374 } 375 SIP_MSG_REFCNT_INCR(msg); 376 sip_trans->sip_xaction_last_msg = msg; 377 (void) sip_add_conn_obj_cache(conn_obj, 378 (void *)sip_trans); 379 /* 380 * For unreliable transport start timer G 381 */ 382 if (!isreliable) { 383 timer_obj_G = sip_setup_timer( 384 conn_obj, sip_trans, 385 NULL, sip_trans->sip_xaction_TG, 386 SIP_XACTION_TIMER_G); 387 if (timer_obj_G == NULL) { 388 (void) pthread_mutex_unlock( 389 &sip_trans-> 390 sip_xaction_mutex); 391 return (ENOMEM); 392 } 393 } 394 /* 395 * Start Timer H 396 */ 397 timer_obj_H = sip_setup_timer( 398 conn_obj, sip_trans, 399 NULL, sip_trans->sip_xaction_TH, 400 SIP_XACTION_TIMER_H); 401 if (timer_obj_H == NULL) { 402 if (timer_obj_G != NULL) 403 free(timer_obj_G); 404 (void) pthread_mutex_unlock( 405 &sip_trans->sip_xaction_mutex); 406 return (ENOMEM); 407 } 408 if (timer_obj_G != NULL) { 409 SIP_SCHED_TIMER( 410 sip_trans->sip_xaction_TG, 411 timer_obj_G, 412 sip_xaction_state_timer_fire); 413 if (!SIP_IS_TIMER_RUNNING( 414 sip_trans->sip_xaction_TG)) { 415 (void) pthread_mutex_unlock( 416 &sip_trans-> 417 sip_xaction_mutex); 418 free(timer_obj_G); 419 return (ENOMEM); 420 } 421 } 422 if (timer_obj_H != NULL) { 423 SIP_SCHED_TIMER( 424 sip_trans->sip_xaction_TH, 425 timer_obj_H, 426 sip_xaction_state_timer_fire); 427 if (!SIP_IS_TIMER_RUNNING( 428 sip_trans->sip_xaction_TH)) { 429 if (timer_obj_G != NULL) { 430 SIP_CANCEL_TIMER( 431 sip_trans-> 432 sip_xaction_TG); 433 free(timer_obj_G); 434 } 435 (void) pthread_mutex_unlock( 436 &sip_trans-> 437 sip_xaction_mutex); 438 free(timer_obj_H); 439 return (ENOMEM); 440 } 441 } 442 sip_trans->sip_xaction_state = 443 SIP_SRV_INV_COMPLETED; 444 } 445 break; 446 default: 447 (void) pthread_mutex_unlock( 448 &sip_trans->sip_xaction_mutex); 449 return (EPROTO); 450 } 451 (void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex); 452 if (prev_state != sip_trans->sip_xaction_state && 453 sip_xaction_ulp_state_cb != NULL) { 454 sip_xaction_ulp_state_cb((sip_transaction_t)sip_trans, 455 (sip_msg_t)msg, prev_state, sip_trans->sip_xaction_state); 456 } 457 return (0); 458 } 459 460 /* 461 * Send a NON-INVITE response out 462 */ 463 static int 464 sip_srv_xaction_noninv_res(sip_conn_object_t conn_obj, 465 sip_xaction_t *sip_trans, _sip_msg_t *msg) 466 { 467 int resp_code; 468 sip_xaction_time_obj_t *timer_obj_J = NULL; 469 sip_message_type_t *sip_msg_info = msg->sip_msg_req_res; 470 int prev_state; 471 boolean_t isreliable; 472 473 resp_code = sip_msg_info->sip_resp_code; 474 isreliable = sip_is_conn_reliable(conn_obj); 475 476 (void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex); 477 prev_state = sip_trans->sip_xaction_state; 478 switch (sip_trans->sip_xaction_state) { 479 case SIP_SRV_TRYING: 480 if (sip_trans->sip_xaction_last_msg != NULL) { 481 SIP_MSG_REFCNT_DECR( 482 sip_trans->sip_xaction_last_msg); 483 sip_trans->sip_xaction_last_msg = NULL; 484 } 485 SIP_MSG_REFCNT_INCR(msg); 486 sip_trans->sip_xaction_last_msg = msg; 487 (void) sip_add_conn_obj_cache(conn_obj, 488 (void *)sip_trans); 489 if (SIP_PROVISIONAL_RESP(resp_code)) { 490 sip_trans->sip_xaction_state = 491 SIP_SRV_NONINV_PROCEEDING; 492 } else if (SIP_FINAL_RESP(resp_code)) { 493 /* 494 * For unreliable transports, start Timer J 495 */ 496 if (!isreliable) { 497 timer_obj_J = sip_setup_timer( 498 conn_obj, sip_trans, 499 NULL, sip_trans->sip_xaction_TJ, 500 SIP_XACTION_TIMER_J); 501 if (timer_obj_J == NULL) { 502 (void) pthread_mutex_unlock(& 503 sip_trans-> 504 sip_xaction_mutex); 505 return (ENOMEM); 506 } 507 SIP_SCHED_TIMER( 508 sip_trans->sip_xaction_TJ, 509 timer_obj_J, 510 sip_xaction_state_timer_fire); 511 if (!SIP_IS_TIMER_RUNNING( 512 sip_trans->sip_xaction_TJ)) { 513 (void) pthread_mutex_unlock(& 514 sip_trans-> 515 sip_xaction_mutex); 516 free(timer_obj_J); 517 return (ENOMEM); 518 } 519 sip_trans->sip_xaction_state = 520 SIP_SRV_NONINV_COMPLETED; 521 } else { 522 sip_trans->sip_xaction_state = 523 SIP_SRV_NONINV_TERMINATED; 524 } 525 } 526 break; 527 case SIP_SRV_NONINV_PROCEEDING: 528 if (sip_trans->sip_xaction_last_msg != NULL) { 529 SIP_MSG_REFCNT_DECR( 530 sip_trans->sip_xaction_last_msg); 531 sip_trans->sip_xaction_last_msg = NULL; 532 } 533 SIP_MSG_REFCNT_INCR(msg); 534 sip_trans->sip_xaction_last_msg = msg; 535 (void) sip_add_conn_obj_cache(conn_obj, 536 (void *)sip_trans); 537 if (SIP_PROVISIONAL_RESP(resp_code)) { 538 break; 539 } else if (SIP_FINAL_RESP(resp_code)) { 540 /* 541 * For unreliable transports, start Timer J 542 */ 543 if (!isreliable) { 544 timer_obj_J = sip_setup_timer( 545 conn_obj, sip_trans, 546 NULL, sip_trans->sip_xaction_TJ, 547 SIP_XACTION_TIMER_J); 548 if (timer_obj_J == NULL) { 549 (void) pthread_mutex_unlock(& 550 sip_trans-> 551 sip_xaction_mutex); 552 return (ENOMEM); 553 } 554 SIP_SCHED_TIMER( 555 sip_trans->sip_xaction_TJ, 556 timer_obj_J, 557 sip_xaction_state_timer_fire); 558 if (!SIP_IS_TIMER_RUNNING( 559 sip_trans->sip_xaction_TJ)) { 560 (void) pthread_mutex_unlock(& 561 sip_trans-> 562 sip_xaction_mutex); 563 free(timer_obj_J); 564 return (ENOMEM); 565 } 566 sip_trans->sip_xaction_state = 567 SIP_SRV_NONINV_COMPLETED; 568 } else { 569 sip_trans->sip_xaction_state = 570 SIP_SRV_NONINV_TERMINATED; 571 } 572 } 573 break; 574 default: 575 (void) pthread_mutex_unlock( 576 &sip_trans->sip_xaction_mutex); 577 return (EPROTO); 578 } 579 (void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex); 580 if (prev_state != sip_trans->sip_xaction_state && 581 sip_xaction_ulp_state_cb != NULL) { 582 sip_xaction_ulp_state_cb((sip_transaction_t)sip_trans, 583 (sip_msg_t)msg, prev_state, sip_trans->sip_xaction_state); 584 } 585 return (0); 586 } 587 588 589 /* 590 * -------------------------- Input Routines --------------------------- 591 */ 592 593 /* 594 * Process an incoming SIP message Request or Response 595 */ 596 int 597 sip_xaction_input(sip_conn_object_t conn_obj, sip_xaction_t *sip_trans, 598 _sip_msg_t **sip_msg) 599 { 600 sip_message_type_t *sip_msg_info; 601 int ret; 602 603 sip_msg_info = (*sip_msg)->sip_msg_req_res; 604 605 (void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex); 606 sip_trans->sip_xaction_msgcnt++; 607 sip_add_log(&sip_trans->sip_xaction_log[sip_trans->sip_xaction_state], 608 (sip_msg_t)*sip_msg, sip_trans->sip_xaction_msgcnt, 609 SIP_TRANSACTION_LOG); 610 (void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex); 611 612 if (sip_msg_info->is_request) 613 ret = sip_srv_xaction_input(conn_obj, sip_trans, sip_msg); 614 else 615 ret = sip_clnt_xaction_input(conn_obj, sip_trans, sip_msg); 616 return (ret); 617 } 618 619 /* 620 * Process a Request from the transport 621 */ 622 static int 623 sip_srv_xaction_input(sip_conn_object_t conn_obj, sip_xaction_t *sip_trans, 624 _sip_msg_t **sip_msg) 625 { 626 sip_message_type_t *sip_msg_info; 627 _sip_msg_t *msg = *sip_msg; 628 int prev_state; 629 boolean_t isreliable; 630 631 sip_msg_info = msg->sip_msg_req_res; 632 isreliable = sip_is_conn_reliable(conn_obj); 633 634 /* 635 * Cancel if the original transaction has not yet got a final 636 * response and send a 487 response. 637 */ 638 if (sip_msg_info->sip_req_method == ACK) { 639 _sip_msg_t *sip_last_resp; 640 const sip_str_t *resp_to_tag; 641 const sip_str_t *req_to_tag; 642 int error; 643 sip_message_type_t *last_msg_info; 644 645 (void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex); 646 647 if (sip_trans->sip_xaction_last_msg != NULL) 648 sip_last_resp = sip_trans->sip_xaction_last_msg; 649 else 650 sip_last_resp = sip_trans->sip_xaction_orig_msg; 651 last_msg_info = sip_last_resp->sip_msg_req_res; 652 if (last_msg_info->is_request) { 653 (void) pthread_mutex_unlock( 654 &sip_trans->sip_xaction_mutex); 655 return (0); 656 } 657 req_to_tag = sip_get_to_tag((sip_msg_t)msg, &error); 658 if (req_to_tag == NULL || error != 0) { 659 (void) pthread_mutex_unlock( 660 &sip_trans->sip_xaction_mutex); 661 return (0); 662 } 663 resp_to_tag = sip_get_to_tag((sip_msg_t)sip_last_resp, 664 &error); 665 if (req_to_tag == NULL || error != 0) { 666 (void) pthread_mutex_unlock( 667 &sip_trans->sip_xaction_mutex); 668 return (0); 669 } 670 if (resp_to_tag->sip_str_len != req_to_tag->sip_str_len || 671 strncmp(resp_to_tag->sip_str_ptr, req_to_tag->sip_str_ptr, 672 req_to_tag->sip_str_len) != 0) { 673 (void) pthread_mutex_unlock( 674 &sip_trans->sip_xaction_mutex); 675 return (0); 676 } 677 prev_state = sip_trans->sip_xaction_state; 678 if (sip_trans->sip_xaction_state == SIP_SRV_INV_COMPLETED) { 679 sip_xaction_time_obj_t *timer_obj_I = NULL; 680 681 SIP_CANCEL_TIMER(sip_trans->sip_xaction_TG); 682 /* 683 * Cancel Timer H and goto TERMINATED state for 684 * reliable transports. 685 */ 686 if (isreliable) { 687 SIP_CANCEL_TIMER( 688 sip_trans->sip_xaction_TH); 689 sip_trans->sip_xaction_state = 690 SIP_SRV_INV_TERMINATED; 691 (void) pthread_mutex_unlock( 692 &sip_trans->sip_xaction_mutex); 693 if (sip_xaction_ulp_state_cb != NULL) { 694 sip_xaction_ulp_state_cb( 695 (sip_transaction_t)sip_trans, 696 (sip_msg_t)msg, prev_state, 697 sip_trans->sip_xaction_state); 698 } 699 return (0); 700 } 701 /* 702 * For unreliable transports, start TIMER I and 703 * transition to CONFIRMED state. 704 */ 705 timer_obj_I = sip_setup_timer(conn_obj, sip_trans, 706 NULL, 707 sip_trans->sip_xaction_TI, SIP_XACTION_TIMER_I); 708 if (timer_obj_I == NULL) { 709 (void) pthread_mutex_unlock( 710 &sip_trans->sip_xaction_mutex); 711 return (ENOMEM); 712 } 713 SIP_SCHED_TIMER(sip_trans->sip_xaction_TI, 714 timer_obj_I, sip_xaction_state_timer_fire); 715 if (!SIP_IS_TIMER_RUNNING(sip_trans->sip_xaction_TI)) { 716 (void) pthread_mutex_unlock( 717 &sip_trans->sip_xaction_mutex); 718 free(timer_obj_I); 719 return (ENOMEM); 720 } 721 sip_trans->sip_xaction_state = SIP_SRV_CONFIRMED; 722 } 723 (void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex); 724 if (prev_state != sip_trans->sip_xaction_state && 725 sip_xaction_ulp_state_cb != NULL) { 726 sip_xaction_ulp_state_cb((sip_transaction_t)sip_trans, 727 (sip_msg_t)msg, prev_state, 728 sip_trans->sip_xaction_state); 729 } 730 return (0); 731 } else if (sip_msg_info->sip_req_method == CANCEL) { 732 if (sip_trans->sip_xaction_method == INVITE) { 733 (void) pthread_mutex_unlock( 734 &sip_trans->sip_xaction_mutex); 735 return (0); 736 } 737 } 738 if (sip_msg_info->sip_req_method == INVITE) { 739 (void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex); 740 if (sip_trans->sip_xaction_method != INVITE) { 741 sip_write_to_log((void *)sip_trans, 742 SIP_TRANSACTION_LOG | SIP_ASSERT_ERROR, __FILE__, 743 __LINE__); 744 } 745 assert(sip_trans->sip_xaction_method == INVITE); 746 /* 747 * Retransmitted invite 748 */ 749 switch (sip_trans->sip_xaction_state) { 750 case SIP_SRV_INV_PROCEEDING: 751 case SIP_SRV_INV_COMPLETED: 752 if (sip_trans->sip_xaction_last_msg != NULL) { 753 _sip_msg_t *new_msg; 754 sip_message_type_t *msg_info; 755 int resp; 756 757 new_msg = 758 sip_trans->sip_xaction_last_msg; 759 msg_info = new_msg->sip_msg_req_res; 760 if (msg_info == NULL || msg_info-> 761 is_request) { 762 sip_write_to_log((void *) 763 sip_trans, 764 SIP_TRANSACTION_LOG | 765 SIP_ASSERT_ERROR, __FILE__, 766 __LINE__); 767 } 768 assert(msg_info != NULL && !msg_info-> 769 is_request); 770 resp = msg_info->sip_resp_code; 771 SIP_UPDATE_COUNTERS(B_FALSE, 0, resp, 772 B_TRUE, new_msg->sip_msg_len); 773 ++sip_trans->sip_xaction_msgcnt; 774 sip_add_log(&sip_trans->sip_xaction_log[ 775 sip_trans->sip_xaction_state], 776 new_msg, sip_trans-> 777 sip_xaction_msgcnt, 778 SIP_TRANSACTION_LOG); 779 (void) sip_stack_send(conn_obj, 780 new_msg->sip_msg_buf, 781 new_msg->sip_msg_len); 782 } 783 break; 784 default: 785 (void) pthread_mutex_unlock( 786 &sip_trans->sip_xaction_mutex); 787 return (EPROTO); 788 } 789 (void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex); 790 /* 791 * We need to account for this invite received by the stack 792 * before we free that message. 793 */ 794 SIP_UPDATE_COUNTERS(B_TRUE, INVITE, 0, B_FALSE, 795 msg->sip_msg_len); 796 sip_free_msg((sip_msg_t)msg); 797 *sip_msg = NULL; 798 return (0); 799 } 800 /* 801 * Retransmitted request 802 */ 803 (void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex); 804 if (sip_trans->sip_xaction_method == INVITE) { 805 sip_write_to_log((void *)sip_trans, SIP_TRANSACTION_LOG | 806 SIP_ASSERT_ERROR, __FILE__, __LINE__); 807 } 808 assert(sip_trans->sip_xaction_method != INVITE); 809 switch (sip_trans->sip_xaction_state) { 810 case SIP_SRV_NONINV_PROCEEDING: 811 case SIP_SRV_NONINV_COMPLETED: 812 if (sip_trans->sip_xaction_last_msg != NULL) { 813 _sip_msg_t *new_msg; 814 sip_message_type_t *msg_info; 815 int resp; 816 817 new_msg = sip_trans->sip_xaction_last_msg; 818 msg_info = new_msg->sip_msg_req_res; 819 if (msg_info == NULL || msg_info->is_request) { 820 sip_write_to_log((void *)sip_trans, 821 SIP_TRANSACTION_LOG | 822 SIP_ASSERT_ERROR, __FILE__, 823 __LINE__); 824 } 825 assert(msg_info != NULL && !msg_info-> 826 is_request); 827 resp = msg_info->sip_resp_code; 828 SIP_UPDATE_COUNTERS(B_FALSE, 0, resp, B_TRUE, 829 new_msg->sip_msg_len); 830 ++sip_trans->sip_xaction_msgcnt; 831 sip_add_log(&sip_trans->sip_xaction_log[ 832 sip_trans->sip_xaction_state], new_msg, 833 sip_trans->sip_xaction_msgcnt, 834 SIP_TRANSACTION_LOG); 835 (void) sip_stack_send(conn_obj, 836 new_msg->sip_msg_buf, new_msg->sip_msg_len); 837 } 838 break; 839 default: 840 (void) pthread_mutex_unlock( 841 &sip_trans->sip_xaction_mutex); 842 return (EPROTO); 843 } 844 (void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex); 845 /* 846 * We need to account for the retransmitted non-INVITE request here. 847 * When we return from here the msg will be freed and we will not 848 * be able to capture the details at sip_process_new_packet() 849 */ 850 SIP_UPDATE_COUNTERS(B_TRUE, sip_msg_info->sip_req_method, 0, B_FALSE, 851 msg->sip_msg_len); 852 sip_free_msg((sip_msg_t)msg); 853 *sip_msg = NULL; 854 return (0); 855 } 856 857 /* 858 * Process a Response 859 */ 860 static int 861 sip_clnt_xaction_input(sip_conn_object_t conn_obj, sip_xaction_t *sip_trans, 862 _sip_msg_t **msg) 863 { 864 int ret; 865 866 if (sip_trans->sip_xaction_method == INVITE) 867 ret = sip_clnt_xaction_inv_res(conn_obj, sip_trans, msg); 868 else 869 ret = sip_clnt_xaction_noninv_res(conn_obj, sip_trans, msg); 870 871 return (ret); 872 } 873 874 static int 875 sip_create_send_nonOKack(sip_conn_object_t conn_obj, sip_xaction_t *sip_trans, 876 _sip_msg_t *msg, boolean_t copy) 877 { 878 _sip_msg_t *ack_msg; 879 int ret = 0; 880 881 ack_msg = (_sip_msg_t *)sip_new_msg(); 882 if (ack_msg == NULL) 883 return (ENOMEM); 884 if ((ret = sip_create_nonOKack( 885 (sip_msg_t)sip_trans->sip_xaction_orig_msg, (sip_msg_t)msg, 886 (sip_msg_t)ack_msg)) != 0) { 887 sip_free_msg((sip_msg_t)ack_msg); 888 return (ret); 889 } 890 SIP_UPDATE_COUNTERS(B_TRUE, ACK, 0, B_TRUE, ack_msg->sip_msg_len); 891 ++sip_trans->sip_xaction_msgcnt; 892 sip_add_log(&sip_trans->sip_xaction_log[sip_trans->sip_xaction_state], 893 ack_msg, sip_trans->sip_xaction_msgcnt, SIP_TRANSACTION_LOG); 894 if ((ret = sip_stack_send(conn_obj, ack_msg->sip_msg_buf, 895 ack_msg->sip_msg_len)) != 0) { 896 sip_free_msg((sip_msg_t)ack_msg); 897 return (ret); 898 } 899 if (copy) { 900 SIP_MSG_REFCNT_INCR(ack_msg); 901 if (sip_trans->sip_xaction_last_msg != NULL) { 902 SIP_MSG_REFCNT_DECR(sip_trans->sip_xaction_last_msg); 903 sip_trans->sip_xaction_last_msg = NULL; 904 } 905 sip_trans->sip_xaction_last_msg = ack_msg; 906 } 907 sip_free_msg((sip_msg_t)ack_msg); 908 return (0); 909 } 910 911 /* 912 * Process a INVITE Response 913 */ 914 static int 915 sip_clnt_xaction_inv_res(sip_conn_object_t conn_obj, sip_xaction_t *sip_trans, 916 _sip_msg_t **sip_msg) 917 { 918 int resp_code; 919 _sip_msg_t *msg = *sip_msg; 920 sip_xaction_time_obj_t *timer_obj_D = NULL; 921 sip_message_type_t *sip_msg_info; 922 int prev_state; 923 boolean_t isreliable; 924 925 (void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex); 926 if (msg->sip_msg_req_res == NULL) { 927 sip_write_to_log((void *)sip_trans, SIP_TRANSACTION_LOG | 928 SIP_ASSERT_ERROR, __FILE__, __LINE__); 929 } 930 assert(msg->sip_msg_req_res != NULL); 931 932 sip_msg_info = msg->sip_msg_req_res; 933 resp_code = sip_msg_info->sip_resp_code; 934 isreliable = sip_is_conn_reliable(conn_obj); 935 936 prev_state = sip_trans->sip_xaction_state; 937 switch (sip_trans->sip_xaction_state) { 938 case SIP_CLNT_CALLING: 939 if (SIP_PROVISIONAL_RESP(resp_code)) { 940 /* 941 * sip_trans->sip_xaction_last_msg ? 942 */ 943 SIP_CANCEL_TIMER( 944 sip_trans->sip_xaction_TA); 945 sip_trans->sip_xaction_state = 946 SIP_CLNT_INV_PROCEEDING; 947 } else if (SIP_OK_RESP(resp_code)) { 948 /* 949 * sip_trans->sip_xaction_last_msg ? 950 */ 951 SIP_CANCEL_TIMER( 952 sip_trans->sip_xaction_TA); 953 SIP_CANCEL_TIMER( 954 sip_trans->sip_xaction_TB); 955 sip_trans->sip_xaction_state = 956 SIP_CLNT_INV_TERMINATED; 957 } else if (SIP_NONOK_FINAL_RESP(resp_code)) { 958 int ret; 959 960 /* 961 * sip_trans->sip_xaction_last_msg ? 962 */ 963 SIP_CANCEL_TIMER( 964 sip_trans->sip_xaction_TA); 965 SIP_CANCEL_TIMER( 966 sip_trans->sip_xaction_TB); 967 if ((ret = sip_create_send_nonOKack(conn_obj, 968 sip_trans, msg, B_FALSE)) != 0) { 969 (void) pthread_mutex_unlock( 970 &sip_trans->sip_xaction_mutex); 971 return (ret); 972 } 973 /* 974 * start timer D for unreliable transports 975 */ 976 if (!isreliable) { 977 timer_obj_D = sip_setup_timer( 978 conn_obj, sip_trans, 979 NULL, sip_trans->sip_xaction_TD, 980 SIP_XACTION_TIMER_D); 981 if (timer_obj_D == NULL) { 982 (void) pthread_mutex_unlock( 983 &sip_trans-> 984 sip_xaction_mutex); 985 return (ENOMEM); 986 } 987 SIP_SCHED_TIMER( 988 sip_trans->sip_xaction_TD, 989 timer_obj_D, 990 sip_xaction_state_timer_fire); 991 if (!SIP_IS_TIMER_RUNNING( 992 sip_trans->sip_xaction_TD)) { 993 (void) pthread_mutex_unlock( 994 &sip_trans-> 995 sip_xaction_mutex); 996 free(timer_obj_D); 997 return (ENOMEM); 998 } 999 sip_trans->sip_xaction_state = 1000 SIP_CLNT_INV_COMPLETED; 1001 } else { 1002 sip_trans->sip_xaction_state = 1003 SIP_CLNT_INV_TERMINATED; 1004 } 1005 } else { 1006 /* 1007 * Invalid resp_code 1008 */ 1009 (void) pthread_mutex_unlock( 1010 &sip_trans->sip_xaction_mutex); 1011 return (EPROTO); 1012 } 1013 break; 1014 case SIP_CLNT_INV_PROCEEDING: 1015 if (SIP_PROVISIONAL_RESP(resp_code)) { 1016 break; 1017 } else if (SIP_OK_RESP(resp_code)) { 1018 SIP_CANCEL_TIMER( 1019 sip_trans->sip_xaction_TB); 1020 sip_trans->sip_xaction_state = 1021 SIP_CLNT_INV_TERMINATED; 1022 } else if (SIP_NONOK_FINAL_RESP(resp_code)) { 1023 int ret; 1024 1025 SIP_CANCEL_TIMER( 1026 sip_trans->sip_xaction_TB); 1027 if ((ret = sip_create_send_nonOKack(conn_obj, 1028 sip_trans, msg, B_FALSE)) != 0) { 1029 (void) pthread_mutex_unlock( 1030 &sip_trans->sip_xaction_mutex); 1031 return (ret); 1032 } 1033 /* 1034 * start timer D for unreliable transports 1035 */ 1036 if (!isreliable) { 1037 timer_obj_D = sip_setup_timer( 1038 conn_obj, sip_trans, 1039 NULL, sip_trans->sip_xaction_TD, 1040 SIP_XACTION_TIMER_D); 1041 if (timer_obj_D == NULL) { 1042 (void) pthread_mutex_unlock( 1043 &sip_trans-> 1044 sip_xaction_mutex); 1045 return (ENOMEM); 1046 } 1047 SIP_SCHED_TIMER( 1048 sip_trans->sip_xaction_TD, 1049 timer_obj_D, 1050 sip_xaction_state_timer_fire); 1051 if (!SIP_IS_TIMER_RUNNING( 1052 sip_trans->sip_xaction_TD)) { 1053 (void) pthread_mutex_unlock( 1054 &sip_trans-> 1055 sip_xaction_mutex); 1056 free(timer_obj_D); 1057 return (ENOMEM); 1058 } 1059 sip_trans->sip_xaction_state = 1060 SIP_CLNT_INV_COMPLETED; 1061 } else { 1062 sip_trans->sip_xaction_state = 1063 SIP_CLNT_INV_TERMINATED; 1064 } 1065 } else { 1066 (void) pthread_mutex_unlock( 1067 &sip_trans->sip_xaction_mutex); 1068 return (EPROTO); 1069 } 1070 break; 1071 case SIP_CLNT_INV_COMPLETED: 1072 /* 1073 * Transport error takes it to 1074 * SIP_CLNT_INV_TERMINATED 1075 */ 1076 if (SIP_NONOK_FINAL_RESP(resp_code)) { 1077 int ret; 1078 1079 if ((ret = sip_create_send_nonOKack(conn_obj, 1080 sip_trans, msg, B_FALSE)) != 0) { 1081 (void) pthread_mutex_unlock( 1082 &sip_trans->sip_xaction_mutex); 1083 return (ret); 1084 } 1085 } else { 1086 /* 1087 * Invalid resp_code 1088 */ 1089 (void) pthread_mutex_unlock( 1090 &sip_trans->sip_xaction_mutex); 1091 return (EPROTO); 1092 } 1093 break; 1094 default: 1095 (void) pthread_mutex_unlock( 1096 &sip_trans->sip_xaction_mutex); 1097 return (EPROTO); 1098 } 1099 (void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex); 1100 if (prev_state != sip_trans->sip_xaction_state && 1101 sip_xaction_ulp_state_cb != NULL) { 1102 sip_xaction_ulp_state_cb((sip_transaction_t)sip_trans, 1103 (sip_msg_t)msg, prev_state, sip_trans->sip_xaction_state); 1104 } 1105 return (0); 1106 } 1107 1108 /* 1109 * Process a NON-INVITE Response 1110 */ 1111 static int 1112 sip_clnt_xaction_noninv_res(sip_conn_object_t conn_obj, 1113 sip_xaction_t *sip_trans, _sip_msg_t **sip_msg) 1114 { 1115 int resp_code; 1116 sip_xaction_time_obj_t *timer_obj_K = NULL; 1117 sip_message_type_t *sip_msg_info; 1118 int prev_state; 1119 _sip_msg_t *msg = *sip_msg; 1120 boolean_t isreliable; 1121 1122 if (msg->sip_msg_req_res == NULL || sip_trans == NULL) { 1123 sip_write_to_log((void *)sip_trans, SIP_TRANSACTION_LOG | 1124 SIP_ASSERT_ERROR, __FILE__, __LINE__); 1125 } 1126 assert(msg->sip_msg_req_res != NULL); 1127 assert(sip_trans != NULL); 1128 1129 sip_msg_info = msg->sip_msg_req_res; 1130 isreliable = sip_is_conn_reliable(conn_obj); 1131 resp_code = sip_msg_info->sip_resp_code; 1132 (void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex); 1133 prev_state = sip_trans->sip_xaction_state; 1134 switch (sip_trans->sip_xaction_state) { 1135 case SIP_CLNT_TRYING: 1136 if (SIP_PROVISIONAL_RESP(resp_code)) { 1137 sip_trans->sip_xaction_state = 1138 SIP_CLNT_NONINV_PROCEEDING; 1139 } else if (SIP_FINAL_RESP(resp_code)) { 1140 SIP_CANCEL_TIMER( 1141 sip_trans->sip_xaction_TE); 1142 SIP_CANCEL_TIMER( 1143 sip_trans->sip_xaction_TF); 1144 /* 1145 * Start timer K for unreliable transports 1146 */ 1147 if (!isreliable) { 1148 timer_obj_K = sip_setup_timer( 1149 conn_obj, sip_trans, 1150 NULL, sip_trans->sip_xaction_TK, 1151 SIP_XACTION_TIMER_K); 1152 if (timer_obj_K == NULL) { 1153 (void) pthread_mutex_unlock(& 1154 sip_trans-> 1155 sip_xaction_mutex); 1156 return (ENOMEM); 1157 } 1158 SIP_SCHED_TIMER( 1159 sip_trans->sip_xaction_TK, 1160 timer_obj_K, 1161 sip_xaction_state_timer_fire); 1162 if (!SIP_IS_TIMER_RUNNING( 1163 sip_trans->sip_xaction_TK)) { 1164 (void) pthread_mutex_unlock( 1165 &sip_trans-> 1166 sip_xaction_mutex); 1167 free(timer_obj_K); 1168 return (ENOMEM); 1169 } 1170 sip_trans->sip_xaction_state = 1171 SIP_CLNT_NONINV_COMPLETED; 1172 } else { 1173 sip_trans->sip_xaction_state = 1174 SIP_CLNT_NONINV_TERMINATED; 1175 } 1176 } 1177 break; 1178 case SIP_CLNT_NONINV_PROCEEDING: 1179 if (SIP_PROVISIONAL_RESP(resp_code)) { 1180 break; 1181 } else if (SIP_FINAL_RESP(resp_code)) { 1182 SIP_CANCEL_TIMER( 1183 sip_trans->sip_xaction_TE); 1184 SIP_CANCEL_TIMER( 1185 sip_trans->sip_xaction_TF); 1186 /* 1187 * Start timer K for unreliable transports 1188 */ 1189 if (!isreliable) { 1190 timer_obj_K = sip_setup_timer( 1191 conn_obj, sip_trans, 1192 NULL, sip_trans->sip_xaction_TK, 1193 SIP_XACTION_TIMER_K); 1194 if (timer_obj_K == NULL) { 1195 (void) pthread_mutex_unlock(& 1196 sip_trans-> 1197 sip_xaction_mutex); 1198 return (ENOMEM); 1199 } 1200 SIP_SCHED_TIMER( 1201 sip_trans->sip_xaction_TK, 1202 timer_obj_K, 1203 sip_xaction_state_timer_fire); 1204 if (!SIP_IS_TIMER_RUNNING( 1205 sip_trans->sip_xaction_TK)) { 1206 (void) pthread_mutex_unlock( 1207 &sip_trans-> 1208 sip_xaction_mutex); 1209 free(timer_obj_K); 1210 return (ENOMEM); 1211 } 1212 sip_trans->sip_xaction_state = 1213 SIP_CLNT_NONINV_COMPLETED; 1214 } else { 1215 sip_trans->sip_xaction_state = 1216 SIP_CLNT_NONINV_TERMINATED; 1217 } 1218 } 1219 break; 1220 default: 1221 (void) pthread_mutex_unlock( 1222 &sip_trans->sip_xaction_mutex); 1223 return (EPROTO); 1224 } 1225 (void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex); 1226 if (prev_state != sip_trans->sip_xaction_state && 1227 sip_xaction_ulp_state_cb != NULL) { 1228 sip_xaction_ulp_state_cb((sip_transaction_t)sip_trans, 1229 (sip_msg_t)msg, prev_state, sip_trans->sip_xaction_state); 1230 } 1231 return (0); 1232 } 1233 1234 /* 1235 * If there is a transport error, sending the message out, terminate the 1236 * transaction. 1237 */ 1238 /* ARGSUSED */ 1239 void 1240 sip_xaction_terminate(sip_xaction_t *sip_trans, _sip_msg_t *msg, int transport) 1241 { 1242 sip_message_type_t *sip_msg_info; 1243 int state; 1244 int prev_state; 1245 1246 sip_msg_info = msg->sip_msg_req_res; 1247 (void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex); 1248 if (sip_msg_info->is_request) { 1249 if (sip_trans->sip_xaction_method == INVITE) 1250 state = SIP_CLNT_INV_TERMINATED; 1251 else 1252 state = SIP_CLNT_NONINV_TERMINATED; 1253 } else { 1254 if (sip_trans->sip_xaction_method == INVITE) 1255 state = SIP_SRV_INV_TERMINATED; 1256 else 1257 state = SIP_SRV_NONINV_TERMINATED; 1258 } 1259 prev_state = sip_trans->sip_xaction_state; 1260 sip_trans->sip_xaction_state = state; 1261 (void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex); 1262 if (sip_xaction_ulp_state_cb != NULL) { 1263 sip_xaction_ulp_state_cb((sip_transaction_t)sip_trans, 1264 (sip_msg_t)msg, prev_state, sip_trans->sip_xaction_state); 1265 } 1266 sip_xaction_delete(sip_trans); 1267 } 1268 1269 /* 1270 * --------------------------- Timer Routine --------------------------- 1271 */ 1272 1273 void 1274 sip_xaction_state_timer_fire(void *args) 1275 { 1276 sip_xaction_time_obj_t *time_obj = (sip_xaction_time_obj_t *)args; 1277 sip_xaction_t *sip_trans = time_obj->sip_trans; 1278 _sip_msg_t *new_msg; 1279 boolean_t destroy_trans = B_FALSE; 1280 sip_conn_object_t conn_obj; 1281 int prev_state; 1282 sip_message_type_t *msg_info; 1283 int resp; 1284 sip_method_t method; 1285 1286 assert(time_obj != NULL); 1287 1288 (void) pthread_mutex_lock(&sip_trans->sip_xaction_mutex); 1289 prev_state = sip_trans->sip_xaction_state; 1290 switch (time_obj->sip_xaction_timer_type) { 1291 case SIP_XACTION_TIMER_A: 1292 if (sip_trans->sip_xaction_state != SIP_CLNT_CALLING) 1293 break; 1294 /* 1295 * Assert candidate 1296 */ 1297 if (sip_trans->sip_xaction_last_msg == NULL) 1298 break; 1299 if (sip_trans->sip_xaction_conn_obj == NULL) 1300 break; 1301 new_msg = sip_trans->sip_xaction_last_msg; 1302 conn_obj = sip_trans->sip_xaction_conn_obj; 1303 /* timer A is for INVITE-RETRANSMIT only */ 1304 SIP_UPDATE_COUNTERS(B_TRUE, INVITE, 0, B_TRUE, new_msg-> 1305 sip_msg_len); 1306 ++sip_trans->sip_xaction_msgcnt; 1307 sip_add_log(&sip_trans->sip_xaction_log[sip_trans-> 1308 sip_xaction_state], new_msg, sip_trans-> 1309 sip_xaction_msgcnt, SIP_TRANSACTION_LOG); 1310 if (sip_stack_send(conn_obj, new_msg->sip_msg_buf, 1311 new_msg->sip_msg_len) != 0) { 1312 sip_del_conn_obj_cache( 1313 sip_trans->sip_xaction_conn_obj, 1314 (void *)sip_trans); 1315 sip_trans->sip_xaction_state = 1316 SIP_CLNT_INV_TERMINATED; 1317 (void) pthread_mutex_unlock( 1318 &sip_trans->sip_xaction_mutex); 1319 if (sip_xaction_ulp_state_cb != NULL) { 1320 sip_xaction_ulp_state_cb( 1321 (sip_transaction_t)sip_trans, NULL, 1322 prev_state, sip_trans-> 1323 sip_xaction_state); 1324 } 1325 if (sip_xaction_ulp_trans_err != NULL) { 1326 sip_xaction_ulp_trans_err(sip_trans, 0, 1327 NULL); 1328 } 1329 sip_xaction_delete(sip_trans); 1330 free(time_obj); 1331 return; 1332 } 1333 SIP_SET_TIMEOUT(sip_trans->sip_xaction_TA, 1334 2 * SIP_GET_TIMEOUT(sip_trans->sip_xaction_TA)); 1335 /* 1336 * Reschedule the timer 1337 */ 1338 SIP_SCHED_TIMER(sip_trans->sip_xaction_TA, 1339 time_obj, sip_xaction_state_timer_fire); 1340 if (!SIP_IS_TIMER_RUNNING(sip_trans->sip_xaction_TA)) { 1341 sip_del_conn_obj_cache( 1342 sip_trans->sip_xaction_conn_obj, 1343 (void *)sip_trans); 1344 sip_trans->sip_xaction_state = 1345 SIP_CLNT_INV_TERMINATED; 1346 (void) pthread_mutex_unlock( 1347 &sip_trans->sip_xaction_mutex); 1348 if (sip_xaction_ulp_state_cb != NULL) { 1349 sip_xaction_ulp_state_cb( 1350 (sip_transaction_t)sip_trans, NULL, 1351 prev_state, sip_trans-> 1352 sip_xaction_state); 1353 } 1354 if (sip_xaction_ulp_trans_err != NULL) { 1355 sip_xaction_ulp_trans_err(sip_trans, 0, 1356 NULL); 1357 } 1358 sip_xaction_delete(sip_trans); 1359 free(time_obj); 1360 return; 1361 } 1362 (void) pthread_mutex_unlock( 1363 &sip_trans->sip_xaction_mutex); 1364 return; 1365 case SIP_XACTION_TIMER_B: 1366 SIP_CANCEL_TIMER(sip_trans->sip_xaction_TA); 1367 if (sip_trans->sip_xaction_state == SIP_CLNT_CALLING) { 1368 sip_trans->sip_xaction_state = 1369 SIP_CLNT_INV_TERMINATED; 1370 (void) pthread_mutex_unlock( 1371 &sip_trans->sip_xaction_mutex); 1372 if (sip_xaction_ulp_state_cb != NULL) { 1373 sip_xaction_ulp_state_cb( 1374 (sip_transaction_t)sip_trans, NULL, 1375 prev_state, sip_trans-> 1376 sip_xaction_state); 1377 } 1378 if (sip_xaction_ulp_trans_err != NULL) { 1379 sip_xaction_ulp_trans_err(sip_trans, 0, 1380 NULL); 1381 } 1382 sip_xaction_delete(sip_trans); 1383 free(time_obj); 1384 return; 1385 } 1386 break; 1387 case SIP_XACTION_TIMER_D: 1388 if (sip_trans->sip_xaction_state == 1389 SIP_CLNT_INV_COMPLETED) { 1390 SIP_CANCEL_TIMER( 1391 sip_trans->sip_xaction_TB); 1392 sip_trans->sip_xaction_state = 1393 SIP_CLNT_INV_TERMINATED; 1394 destroy_trans = B_TRUE; 1395 } 1396 break; 1397 case SIP_XACTION_TIMER_E: 1398 /* 1399 * Assert candidate 1400 */ 1401 if (sip_trans->sip_xaction_state != SIP_CLNT_TRYING && 1402 sip_trans->sip_xaction_state != 1403 SIP_CLNT_NONINV_PROCEEDING) { 1404 break; 1405 } 1406 /* 1407 * Assert candidate 1408 */ 1409 if (sip_trans->sip_xaction_last_msg == NULL) 1410 break; 1411 if (sip_trans->sip_xaction_conn_obj == NULL) 1412 break; 1413 conn_obj = sip_trans->sip_xaction_conn_obj; 1414 new_msg = sip_trans->sip_xaction_last_msg; 1415 /* Timer E is for non-INVITE request */ 1416 1417 msg_info = new_msg->sip_msg_req_res; 1418 if (msg_info == NULL || !msg_info->is_request) { 1419 (void) sip_write_to_log((void *) sip_trans, 1420 SIP_TRANSACTION_LOG | SIP_ASSERT_ERROR, 1421 __FILE__, __LINE__); 1422 } 1423 assert(msg_info != NULL && msg_info->is_request); 1424 method = msg_info->sip_req_method; 1425 SIP_UPDATE_COUNTERS(B_TRUE, method, 0, B_TRUE, new_msg-> 1426 sip_msg_len); 1427 ++sip_trans->sip_xaction_msgcnt; 1428 sip_add_log(&sip_trans->sip_xaction_log[sip_trans-> 1429 sip_xaction_state], new_msg, sip_trans-> 1430 sip_xaction_msgcnt, SIP_TRANSACTION_LOG); 1431 if (sip_stack_send(conn_obj, new_msg->sip_msg_buf, 1432 new_msg->sip_msg_len) != 0) { 1433 sip_del_conn_obj_cache( 1434 sip_trans->sip_xaction_conn_obj, 1435 (void *)sip_trans); 1436 sip_trans->sip_xaction_state = 1437 SIP_CLNT_NONINV_TERMINATED; 1438 (void) pthread_mutex_unlock( 1439 &sip_trans->sip_xaction_mutex); 1440 if (sip_xaction_ulp_state_cb != NULL) { 1441 sip_xaction_ulp_state_cb( 1442 (sip_transaction_t)sip_trans, NULL, 1443 prev_state, sip_trans-> 1444 sip_xaction_state); 1445 } 1446 if (sip_xaction_ulp_trans_err != NULL) { 1447 sip_xaction_ulp_trans_err(sip_trans, 0, 1448 NULL); 1449 } 1450 sip_xaction_delete(sip_trans); 1451 free(time_obj); 1452 return; 1453 } 1454 SIP_SET_TIMEOUT(sip_trans->sip_xaction_TE, 1455 MIN(SIP_TIMER_T2, 1456 2 * SIP_GET_TIMEOUT(sip_trans->sip_xaction_TE))); 1457 /* 1458 * Reschedule the timer 1459 */ 1460 SIP_SCHED_TIMER(sip_trans->sip_xaction_TE, 1461 time_obj, sip_xaction_state_timer_fire); 1462 if (!SIP_IS_TIMER_RUNNING(sip_trans->sip_xaction_TE)) { 1463 sip_del_conn_obj_cache( 1464 sip_trans->sip_xaction_conn_obj, 1465 (void *)sip_trans); 1466 sip_trans->sip_xaction_state = 1467 SIP_CLNT_NONINV_TERMINATED; 1468 (void) pthread_mutex_unlock( 1469 &sip_trans->sip_xaction_mutex); 1470 if (sip_xaction_ulp_state_cb != NULL) { 1471 sip_xaction_ulp_state_cb( 1472 (sip_transaction_t)sip_trans, NULL, 1473 prev_state, sip_trans-> 1474 sip_xaction_state); 1475 } 1476 if (sip_xaction_ulp_trans_err != NULL) { 1477 sip_xaction_ulp_trans_err(sip_trans, 0, 1478 NULL); 1479 } 1480 sip_xaction_delete(sip_trans); 1481 free(time_obj); 1482 return; 1483 } 1484 (void) pthread_mutex_unlock( 1485 &sip_trans->sip_xaction_mutex); 1486 return; 1487 case SIP_XACTION_TIMER_F: 1488 SIP_CANCEL_TIMER(sip_trans->sip_xaction_TE); 1489 if (sip_trans->sip_xaction_state == SIP_CLNT_TRYING || 1490 sip_trans->sip_xaction_state == 1491 SIP_CLNT_NONINV_PROCEEDING) { 1492 sip_trans->sip_xaction_state = 1493 SIP_CLNT_NONINV_TERMINATED; 1494 (void) pthread_mutex_unlock( 1495 &sip_trans->sip_xaction_mutex); 1496 if (sip_xaction_ulp_state_cb != NULL) { 1497 sip_xaction_ulp_state_cb( 1498 (sip_transaction_t)sip_trans, NULL, 1499 prev_state, sip_trans-> 1500 sip_xaction_state); 1501 } 1502 if (sip_xaction_ulp_trans_err != NULL) { 1503 sip_xaction_ulp_trans_err(sip_trans, 0, 1504 NULL); 1505 } 1506 sip_xaction_delete(sip_trans); 1507 free(time_obj); 1508 return; 1509 } 1510 break; 1511 case SIP_XACTION_TIMER_G: 1512 /* 1513 * Assert candidate 1514 */ 1515 if (sip_trans->sip_xaction_last_msg == NULL) 1516 break; 1517 if (sip_trans->sip_xaction_conn_obj == NULL) 1518 break; 1519 if (sip_trans->sip_xaction_state != 1520 SIP_SRV_INV_COMPLETED) { 1521 break; 1522 } 1523 new_msg = sip_trans->sip_xaction_last_msg; 1524 conn_obj = sip_trans->sip_xaction_conn_obj; 1525 msg_info = new_msg->sip_msg_req_res; 1526 if (msg_info == NULL || msg_info->is_request) { 1527 (void) sip_write_to_log((void *) sip_trans, 1528 SIP_TRANSACTION_LOG | SIP_ASSERT_ERROR, 1529 __FILE__, __LINE__); 1530 } 1531 assert(msg_info != NULL && !msg_info->is_request); 1532 resp = msg_info->sip_resp_code; 1533 SIP_UPDATE_COUNTERS(B_FALSE, 0, resp, B_TRUE, new_msg-> 1534 sip_msg_len); 1535 ++sip_trans->sip_xaction_msgcnt; 1536 sip_add_log(&sip_trans->sip_xaction_log[sip_trans-> 1537 sip_xaction_state], new_msg, sip_trans-> 1538 sip_xaction_msgcnt, SIP_TRANSACTION_LOG); 1539 if (sip_stack_send(conn_obj, new_msg->sip_msg_buf, 1540 new_msg->sip_msg_len) != 0) { 1541 sip_del_conn_obj_cache( 1542 sip_trans->sip_xaction_conn_obj, 1543 (void *)sip_trans); 1544 sip_trans->sip_xaction_state = 1545 SIP_SRV_INV_TERMINATED; 1546 (void) pthread_mutex_unlock( 1547 &sip_trans->sip_xaction_mutex); 1548 if (sip_xaction_ulp_state_cb != NULL) { 1549 sip_xaction_ulp_state_cb( 1550 (sip_transaction_t)sip_trans, NULL, 1551 prev_state, sip_trans-> 1552 sip_xaction_state); 1553 } 1554 if (sip_xaction_ulp_trans_err != NULL) { 1555 sip_xaction_ulp_trans_err(sip_trans, 0, 1556 NULL); 1557 } 1558 sip_xaction_delete(sip_trans); 1559 free(time_obj); 1560 return; 1561 } 1562 SIP_SET_TIMEOUT(sip_trans->sip_xaction_TG, 1563 MIN(SIP_TIMER_T2, 1564 2 * SIP_GET_TIMEOUT(sip_trans->sip_xaction_TG))); 1565 SIP_SCHED_TIMER(sip_trans->sip_xaction_TG, 1566 time_obj, sip_xaction_state_timer_fire); 1567 if (!SIP_IS_TIMER_RUNNING(sip_trans->sip_xaction_TG)) { 1568 sip_del_conn_obj_cache( 1569 sip_trans->sip_xaction_conn_obj, 1570 (void *)sip_trans); 1571 sip_trans->sip_xaction_state = 1572 SIP_SRV_INV_TERMINATED; 1573 (void) pthread_mutex_unlock( 1574 &sip_trans->sip_xaction_mutex); 1575 if (sip_xaction_ulp_state_cb != NULL) { 1576 sip_xaction_ulp_state_cb( 1577 (sip_transaction_t)sip_trans, NULL, 1578 prev_state, sip_trans-> 1579 sip_xaction_state); 1580 } 1581 if (sip_xaction_ulp_trans_err != NULL) { 1582 sip_xaction_ulp_trans_err(sip_trans, 0, 1583 NULL); 1584 } 1585 sip_xaction_delete(sip_trans); 1586 free(time_obj); 1587 return; 1588 } 1589 (void) pthread_mutex_unlock( 1590 &sip_trans->sip_xaction_mutex); 1591 return; 1592 case SIP_XACTION_TIMER_H: 1593 SIP_CANCEL_TIMER(sip_trans->sip_xaction_TG); 1594 if (sip_trans->sip_xaction_state == 1595 SIP_SRV_INV_COMPLETED) { 1596 sip_trans->sip_xaction_state = 1597 SIP_SRV_INV_TERMINATED; 1598 (void) pthread_mutex_unlock( 1599 &sip_trans->sip_xaction_mutex); 1600 if (sip_xaction_ulp_state_cb != NULL) { 1601 sip_xaction_ulp_state_cb( 1602 (sip_transaction_t)sip_trans, NULL, 1603 prev_state, sip_trans-> 1604 sip_xaction_state); 1605 } 1606 if (sip_xaction_ulp_trans_err != NULL) { 1607 sip_xaction_ulp_trans_err(sip_trans, 0, 1608 NULL); 1609 } 1610 sip_xaction_delete(sip_trans); 1611 free(time_obj); 1612 return; 1613 } 1614 break; 1615 case SIP_XACTION_TIMER_I: 1616 if (sip_trans->sip_xaction_state == 1617 SIP_SRV_CONFIRMED) { 1618 SIP_CANCEL_TIMER( 1619 sip_trans->sip_xaction_TH); 1620 sip_trans->sip_xaction_state = 1621 SIP_SRV_INV_TERMINATED; 1622 destroy_trans = B_TRUE; 1623 } 1624 break; 1625 case SIP_XACTION_TIMER_J: 1626 if (sip_trans->sip_xaction_state == 1627 SIP_SRV_NONINV_COMPLETED) { 1628 sip_trans->sip_xaction_state = 1629 SIP_SRV_NONINV_TERMINATED; 1630 destroy_trans = B_TRUE; 1631 1632 } 1633 break; 1634 case SIP_XACTION_TIMER_K: 1635 if (sip_trans->sip_xaction_state == 1636 SIP_CLNT_NONINV_COMPLETED) { 1637 SIP_CANCEL_TIMER( 1638 sip_trans->sip_xaction_TF); 1639 sip_trans->sip_xaction_state = 1640 SIP_CLNT_NONINV_TERMINATED; 1641 destroy_trans = B_TRUE; 1642 } 1643 break; 1644 default: 1645 break; 1646 } 1647 if (destroy_trans) { 1648 (void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex); 1649 if (sip_xaction_ulp_state_cb != NULL && 1650 prev_state != sip_trans->sip_xaction_state) { 1651 sip_xaction_ulp_state_cb((sip_transaction_t)sip_trans, 1652 NULL, prev_state, sip_trans->sip_xaction_state); 1653 } 1654 sip_xaction_delete(sip_trans); 1655 free(time_obj); 1656 return; 1657 } 1658 (void) pthread_mutex_unlock(&sip_trans->sip_xaction_mutex); 1659 if (sip_xaction_ulp_state_cb != NULL && 1660 prev_state != sip_trans->sip_xaction_state) { 1661 sip_xaction_ulp_state_cb((sip_transaction_t)sip_trans, NULL, 1662 prev_state, sip_trans->sip_xaction_state); 1663 } 1664 free(time_obj); 1665 } 1666