usr/src/lib/libsip/common/sip_xaction.c

   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 #pragma ident   "%Z%%M% %I%     %E% SMI"
  28
  29 #include <stdlib.h>
  30 #include <assert.h>
  31 #include <errno.h>
  32 #include <pthread.h>
  33 #include <strings.h>
  34
  35 #include "sip_parse_uri.h"
  36 #include "sip_msg.h"
  37 #include "sip_miscdefs.h"
  38 #include "sip_xaction.h"
  39 #include "sip_hash.h"
  40
  41 #define RFC_3261_BRANCH "z9hG4bK"
  42
  43 /*
  44  * The transaction hash table
  45  */
  46 sip_hash_t      sip_xaction_hash[SIP_HASH_SZ];
  47
  48 int (*sip_xaction_ulp_trans_err)(sip_transaction_t, int, void *) = NULL;
  49 void (*sip_xaction_ulp_state_cb)(sip_transaction_t, sip_msg_t, int, int) = NULL;
  50
  51 int sip_xaction_add(sip_xaction_t *, char *, _sip_msg_t *, sip_method_t);
  52 static boolean_t sip_is_conn_obj_cache(sip_conn_object_t, void *);
  53
  54 /*
  55  * Get the md5 hash of the required fields
  56  */
  57 int
  58 sip_find_md5_digest(char *bid, _sip_msg_t *msg, uint16_t *hindex,
  59     sip_method_t method)
  60 {
  61         boolean_t       is_2543;
  62
  63         is_2543 = (bid == NULL ||
  64             strncmp(bid, RFC_3261_BRANCH, strlen(RFC_3261_BRANCH)) != 0);
  65
  66         if (is_2543 && msg == NULL)
  67                 return (EINVAL);
  68         if (is_2543) {
  69                 _sip_header_t   *from = NULL;
  70                 _sip_header_t   *cid = NULL;
  71                 _sip_header_t   *via = NULL;
  72                 const sip_str_t *to_uri = NULL;
  73                 int             cseq;
  74                 int             error = 0;
  75
  76                 /*
  77                  * Since the response might contain parameters not in the
  78                  * request, just use the to URI.
  79                  */
  80                 to_uri = sip_get_to_uri_str((sip_msg_t)msg, &error);
  81                 if (to_uri == NULL || error != 0)
  82                         return (EINVAL);
  83                 cseq = sip_get_callseq_num((sip_msg_t)msg, &error);
  84                 if (cseq < 0 || error != 0)
  85                         return (EINVAL);
  86                 (void) pthread_mutex_lock(&msg->sip_msg_mutex);
  87                 via = sip_search_for_header(msg, SIP_VIA, NULL);
  88                 from = sip_search_for_header(msg, SIP_FROM, NULL);
  89                 cid = sip_search_for_header(msg, SIP_CALL_ID, NULL);
  90                 (void) pthread_mutex_unlock(&msg->sip_msg_mutex);
  91                 if (via == NULL || from == NULL || cid == NULL)
  92                         return (EINVAL);
  93                 sip_md5_hash(via->sip_hdr_start,
  94                     via->sip_hdr_end - via->sip_hdr_start,
  95                     cid->sip_hdr_start,
  96                     cid->sip_hdr_end - cid->sip_hdr_start,
  97                     from->sip_hdr_start,
  98                     from->sip_hdr_end - from->sip_hdr_start,
  99                     (char *)&cseq, sizeof (int),
 100                     (char *)&method, sizeof (sip_method_t),
 101                     to_uri->sip_str_ptr, to_uri->sip_str_len,
 102                     (uchar_t *)hindex);
 103         } else {
 104                 sip_md5_hash(bid, strlen(bid), (char *)&method,
 105                     sizeof (sip_method_t), NULL, 0, NULL, 0, NULL, 0, NULL, 0,
 106                     (uchar_t *)hindex);
 107         }
 108         return (0);
 109 }
 110
 111 /*
 112  * Add object to the connection cache object. Not checking for duplicates!!
 113  */
 114 int
 115 sip_add_conn_obj_cache(sip_conn_object_t obj, void *cobj)
 116 {
 117         void                    **obj_val;
 118         sip_conn_obj_pvt_t      *pvt_data;
 119         sip_conn_cache_t        *xaction_list;
 120         sip_xaction_t           *sip_trans = (sip_xaction_t *)cobj;
 121
 122         /*
 123          * Is already cached
 124          */
 125         if (sip_trans->sip_xaction_conn_obj != NULL) {
 126                 if (sip_is_conn_obj_cache(sip_trans->sip_xaction_conn_obj,
 127                     (void *)sip_trans)) {
 128                         return (0);
 129                 }
 130                 /*
 131                  * Transaction has cached a different conn_obj, release it
 132                  */
 133                 sip_del_conn_obj_cache(sip_trans->sip_xaction_conn_obj,
 134                     (void *)sip_trans);
 135         }
 136
 137         xaction_list = malloc(sizeof (sip_conn_cache_t));
 138         if (xaction_list == NULL)
 139                 return (ENOMEM);
 140         xaction_list->obj = cobj;
 141         xaction_list->next = xaction_list->prev = NULL;
 142
 143         obj_val = (void *)obj;
 144         pvt_data = (sip_conn_obj_pvt_t *)*obj_val;
 145         if (pvt_data == NULL) {
 146                 free(xaction_list);
 147                 return (EINVAL);
 148         }
 149         (void) pthread_mutex_lock(&pvt_data->sip_conn_obj_cache_lock);
 150
 151         if (pvt_data->sip_conn_obj_cache == NULL) {
 152                 pvt_data->sip_conn_obj_cache = xaction_list;
 153         } else {
 154                 xaction_list->next =  pvt_data->sip_conn_obj_cache;
 155                 pvt_data->sip_conn_obj_cache->prev = xaction_list;
 156                 pvt_data->sip_conn_obj_cache = xaction_list;
 157         }
 158         sip_refhold_conn(obj);
 159         sip_trans->sip_xaction_conn_obj = obj;
 160         (void) pthread_mutex_unlock(&pvt_data->sip_conn_obj_cache_lock);
 161         return (0);
 162 }
 163
 164 /*
 165  * Walk thru the list of transactions that have cached this obj and
 166  * and return true if 'cobj' is one of them.
 167  */
 168 static boolean_t
 169 sip_is_conn_obj_cache(sip_conn_object_t obj, void *cobj)
 170 {
 171         void                    **obj_val;
 172         sip_conn_obj_pvt_t      *pvt_data;
 173         sip_conn_cache_t        *xaction_list;
 174         sip_xaction_t           *trans;
 175         sip_xaction_t           *ctrans = (sip_xaction_t *)cobj;
 176
 177         obj_val = (void *)obj;
 178         pvt_data = (sip_conn_obj_pvt_t *)*obj_val;
 179         if (pvt_data == NULL)
 180                 return (B_FALSE);
 181         (void) pthread_mutex_lock(&pvt_data->sip_conn_obj_cache_lock);
 182         xaction_list = pvt_data->sip_conn_obj_cache;
 183         while (xaction_list != NULL) {
 184                 trans = (sip_xaction_t *)xaction_list->obj;
 185                 if (ctrans != trans) {
 186                         xaction_list = xaction_list->next;
 187                         continue;
 188                 }
 189                 (void) pthread_mutex_unlock(&pvt_data->sip_conn_obj_cache_lock);
 190                 return (B_TRUE);
 191         }
 192         (void) pthread_mutex_unlock(&pvt_data->sip_conn_obj_cache_lock);
 193         return (B_FALSE);
 194 }
 195
 196
 197 /*
 198  * Walk thru the list of transactions that have cached this obj and
 199  * refrele the objs.
 200  */
 201 void
 202 sip_del_conn_obj_cache(sip_conn_object_t obj, void *cobj)
 203 {
 204         void                    **obj_val;
 205         sip_conn_obj_pvt_t      *pvt_data;
 206         sip_conn_cache_t        *xaction_list;
 207         sip_conn_cache_t        *tmp_list;
 208         sip_xaction_t           *trans;
 209         sip_xaction_t           *ctrans = NULL;
 210
 211         if (cobj != NULL)
 212                 ctrans = (sip_xaction_t *)cobj;
 213
 214         obj_val = (void *)obj;
 215         pvt_data = (sip_conn_obj_pvt_t *)*obj_val;
 216         if (pvt_data == NULL) { /* ASSERT FALSE if ctrans != NULL?? */
 217                 if (ctrans != NULL) {
 218                         sip_refrele_conn(obj);
 219                         ctrans->sip_xaction_conn_obj = NULL;
 220                 }
 221                 return;
 222         }
 223         (void) pthread_mutex_lock(&pvt_data->sip_conn_obj_cache_lock);
 224         xaction_list = pvt_data->sip_conn_obj_cache;
 225         while (xaction_list != NULL) {
 226                 tmp_list = xaction_list;
 227                 trans = (sip_xaction_t *)xaction_list->obj;
 228                 assert(trans != NULL);
 229                 if (ctrans != NULL && ctrans != trans) {
 230                         xaction_list = xaction_list->next;
 231                         continue;
 232                 }
 233                 if (ctrans == NULL)
 234                         (void) pthread_mutex_lock(&trans->sip_xaction_mutex);
 235                 assert(trans->sip_xaction_conn_obj == obj);
 236                 sip_refrele_conn(obj);
 237                 trans->sip_xaction_conn_obj = NULL;
 238                 if (ctrans == NULL)
 239                         (void) pthread_mutex_unlock(&trans->sip_xaction_mutex);
 240                 xaction_list = xaction_list->next;
 241
 242                 /*
 243                  * Take the obj out of the list
 244                  */
 245                 if (tmp_list == pvt_data->sip_conn_obj_cache) {
 246                         if (xaction_list == NULL) {
 247                                 pvt_data->sip_conn_obj_cache = NULL;
 248                         } else {
 249                                 xaction_list->prev = NULL;
 250                                 pvt_data->sip_conn_obj_cache = xaction_list;
 251                         }
 252                 } else if (xaction_list == NULL) {
 253                         assert(tmp_list->prev != NULL);
 254                         tmp_list->prev->next = NULL;
 255                 } else {
 256                         assert(tmp_list->prev != NULL);
 257                         tmp_list->prev->next = xaction_list;
 258                         xaction_list->prev = tmp_list->prev;
 259                 }
 260                 tmp_list->prev = NULL;
 261                 tmp_list->next = NULL;
 262                 tmp_list->obj = NULL;
 263
 264                 free(tmp_list);
 265         }
 266         (void) pthread_mutex_unlock(&pvt_data->sip_conn_obj_cache_lock);
 267 }
 268
 269 /*
 270  * Check for a transaction match. Passed to sip_hash_find().
 271  */
 272 boolean_t
 273 sip_xaction_match(void *obj, void *hindex)
 274 {
 275         sip_xaction_t   *tmp = (sip_xaction_t *)obj;
 276
 277         tmp = (sip_xaction_t *)obj;
 278
 279         if (SIP_IS_XACTION_TERMINATED(tmp->sip_xaction_state))
 280                 return (B_FALSE);
 281         if (bcmp(tmp->sip_xaction_hash_digest, hindex,
 282             sizeof (tmp->sip_xaction_hash_digest)) == 0) {
 283                 SIP_XACTION_REFCNT_INCR(tmp);
 284                 return (B_TRUE);
 285         }
 286         return (B_FALSE);
 287 }
 288
 289
 290 /*
 291  * Find a transaction
 292  */
 293 static sip_xaction_t *
 294 sip_xaction_find(char *branchid, _sip_msg_t *msg, int which)
 295 {
 296         sip_xaction_t           *tmp;
 297         uint16_t                hash_index[8];
 298         int                     hindex;
 299         sip_method_t            method;
 300         int                     error;
 301         sip_message_type_t      *sip_msg_info;
 302
 303         sip_msg_info = msg->sip_msg_req_res;
 304         method = sip_get_callseq_method((sip_msg_t)msg, &error);
 305         if (error != 0)
 306                 return (NULL);
 307
 308         /*
 309          * If we are getting a ACK/CANCEL we need to match with the
 310          * corresponding INVITE, if any.
 311          */
 312         if (sip_msg_info->is_request && which == SIP_SERVER_TRANSACTION &&
 313             (method == ACK || method == CANCEL)) {
 314                 method = INVITE;
 315         }
 316         if (sip_find_md5_digest(branchid, msg, hash_index, method) != 0)
 317                 return (NULL);
 318         hindex = SIP_DIGEST_TO_HASH(hash_index);
 319         tmp = (sip_xaction_t *)sip_hash_find(sip_xaction_hash,
 320             (void *)hash_index, hindex, sip_xaction_match);
 321         return (tmp);
 322 }
 323
 324 /*
 325  * create a transaction.
 326  */
 327 static sip_xaction_t *
 328 sip_xaction_create(sip_conn_object_t obj, _sip_msg_t *msg, char *branchid,
 329     int *error)
 330 {
 331         sip_xaction_t           *trans;
 332         sip_message_type_t      *sip_msg_info;
 333         int                     state = 0;
 334         int                     prev_state = 0;
 335         sip_method_t            method;
 336         int                     ret;
 337         int                     timer1 = sip_timer_T1;
 338         int                     timer4 = sip_timer_T4;
 339         int                     timerd = sip_timer_TD;
 340
 341         if (error != NULL)
 342                 *error = 0;
 343         /*
 344          * Make sure we are not creating a transaction for
 345          * an ACK request.
 346          */
 347         trans = (sip_xaction_t *)malloc(sizeof (sip_xaction_t));
 348         if (trans == NULL) {
 349                 if (error != NULL)
 350                         *error = ENOMEM;
 351                 return (NULL);
 352         }
 353         bzero(trans, sizeof (sip_xaction_t));
 354         if (branchid == NULL) {
 355                 trans->sip_xaction_branch_id = (char *)sip_branchid(NULL);
 356                 if (trans->sip_xaction_branch_id == NULL) {
 357                         free(trans);
 358                         if (error != NULL)
 359                                 *error = ENOMEM;
 360                         return (NULL);
 361                 }
 362         } else {
 363                 trans->sip_xaction_branch_id = (char *)malloc(strlen(branchid)
 364                     + 1);
 365                 if (trans->sip_xaction_branch_id == NULL) {
 366                         free(trans);
 367                         if (error != NULL)
 368                                 *error = ENOMEM;
 369                         return (NULL);
 370                 }
 371                 (void) strncpy(trans->sip_xaction_branch_id, branchid,
 372                     strlen(branchid));
 373                 trans->sip_xaction_branch_id[strlen(branchid)] = '\0';
 374         }
 375         (void) pthread_mutex_init(&trans->sip_xaction_mutex, NULL);
 376         SIP_MSG_REFCNT_INCR(msg);
 377         trans->sip_xaction_orig_msg = msg;
 378         assert(msg->sip_msg_req_res != NULL);
 379         sip_msg_info = msg->sip_msg_req_res;
 380         if (sip_msg_info->is_request) {
 381                 method = sip_msg_info->sip_req_method;
 382         } else {
 383                 method = sip_get_callseq_method((sip_msg_t)msg, &ret);
 384                 if (ret != 0) {
 385                         free(trans->sip_xaction_branch_id);
 386                         free(trans);
 387                         if (error != NULL)
 388                                 *error = ret;
 389                         return (NULL);
 390                 }
 391                 if (method == INVITE)
 392                         state = SIP_SRV_INV_PROCEEDING;
 393                 else
 394                         state = SIP_SRV_TRYING;
 395         }
 396         trans->sip_xaction_method = method;
 397         trans->sip_xaction_state = state;
 398
 399         /*
 400          * Get connection object specific timeouts, if present
 401          */
 402         if (sip_conn_timer1 != NULL)
 403                 timer1 = sip_conn_timer1(obj);
 404         if (sip_conn_timer4 != NULL)
 405                 timer4 = sip_conn_timer4(obj);
 406         if (sip_conn_timerd != NULL)
 407                 timerd = sip_conn_timerd(obj);
 408
 409         SIP_INIT_TIMER(trans->sip_xaction_TA, 2 * timer1);
 410         SIP_INIT_TIMER(trans->sip_xaction_TB, 64 * timer1)
 411         SIP_INIT_TIMER(trans->sip_xaction_TD,  timerd);
 412         SIP_INIT_TIMER(trans->sip_xaction_TE, timer1);
 413         SIP_INIT_TIMER(trans->sip_xaction_TF, 64 * timer1);
 414         SIP_INIT_TIMER(trans->sip_xaction_TG, 2 * timer1);
 415         SIP_INIT_TIMER(trans->sip_xaction_TH, 64 * timer1);
 416         SIP_INIT_TIMER(trans->sip_xaction_TI, timer4);
 417         SIP_INIT_TIMER(trans->sip_xaction_TJ, 64 * timer1);
 418         SIP_INIT_TIMER(trans->sip_xaction_TK, timer4);
 419
 420         if ((ret = sip_xaction_add(trans, branchid, msg, method)) != 0) {
 421                 (void) pthread_mutex_destroy(&trans->sip_xaction_mutex);
 422                 free(trans->sip_xaction_branch_id);
 423                 free(trans);
 424                 if (error != NULL)
 425                         *error = ret;
 426                 return (NULL);
 427         }
 428         if (sip_xaction_ulp_state_cb != NULL &&
 429             prev_state != trans->sip_xaction_state) {
 430                 sip_xaction_ulp_state_cb((sip_transaction_t)trans,
 431                     (sip_msg_t)msg, prev_state, trans->sip_xaction_state);
 432         }
 433         return (trans);
 434 }
 435
 436 /*
 437  * Find a transaction, create if asked for
 438  */
 439 sip_xaction_t *
 440 sip_xaction_get(sip_conn_object_t obj, sip_msg_t msg, boolean_t create,
 441     int which, int *error)
 442 {
 443         char                    *branchid;
 444         sip_xaction_t           *sip_trans;
 445         _sip_msg_t              *_msg;
 446         sip_message_type_t      *sip_msg_info;
 447
 448         if (error != NULL)
 449                 *error = 0;
 450
 451         _msg = (_sip_msg_t *)msg;
 452         sip_msg_info = ((_sip_msg_t *)msg)->sip_msg_req_res;
 453
 454         branchid = sip_get_branchid(msg, NULL);
 455         sip_trans = sip_xaction_find(branchid, _msg, which);
 456         if (sip_trans == NULL && create) {
 457                 /*
 458                  * If we are sending a request, must be conformant to RFC 3261.
 459                  */
 460                 if (sip_msg_info->is_request &&
 461                     (branchid == NULL || strncmp(branchid,
 462                     RFC_3261_BRANCH, strlen(RFC_3261_BRANCH) != 0))) {
 463                         if (error != NULL)
 464                                 *error = EINVAL;
 465                         if (branchid != NULL)
 466                                 free(branchid);
 467                         return (NULL);
 468                 }
 469                 sip_trans = sip_xaction_create(obj, _msg, branchid, error);
 470                 if (sip_trans != NULL)
 471                         SIP_XACTION_REFCNT_INCR(sip_trans);
 472         }
 473         if (branchid != NULL)
 474                 free(branchid);
 475         return (sip_trans);
 476 }
 477
 478
 479 /*
 480  * Delete a transaction if the reference count is 0. Passed to
 481  * sip_hash_delete().
 482  */
 483 boolean_t
 484 sip_xaction_remove(void *obj, void *hindex, int *found)
 485 {
 486         sip_xaction_t   *tmp = (sip_xaction_t *)obj;
 487         int             count = 0;
 488         sip_msg_chain_t *msg_chain;
 489         sip_msg_chain_t *nmsg_chain;
 490
 491         *found = 0;
 492         tmp = (sip_xaction_t *)obj;
 493         (void) pthread_mutex_lock(&tmp->sip_xaction_mutex);
 494         if (bcmp(tmp->sip_xaction_hash_digest, hindex,
 495             sizeof (tmp->sip_xaction_hash_digest)) == 0) {
 496                 *found = 1;
 497                 if (tmp->sip_xaction_ref_cnt != 0) {
 498                         (void) pthread_mutex_unlock(&tmp->sip_xaction_mutex);
 499                         return (B_FALSE);
 500                 }
 501                 (void) pthread_mutex_destroy(&tmp->sip_xaction_mutex);
 502                 SIP_CANCEL_TIMER(tmp->sip_xaction_TA);
 503                 SIP_CANCEL_TIMER(tmp->sip_xaction_TB);
 504                 SIP_CANCEL_TIMER(tmp->sip_xaction_TD);
 505                 SIP_CANCEL_TIMER(tmp->sip_xaction_TE);
 506                 SIP_CANCEL_TIMER(tmp->sip_xaction_TF);
 507                 SIP_CANCEL_TIMER(tmp->sip_xaction_TG);
 508                 SIP_CANCEL_TIMER(tmp->sip_xaction_TH);
 509                 SIP_CANCEL_TIMER(tmp->sip_xaction_TI);
 510                 SIP_CANCEL_TIMER(tmp->sip_xaction_TJ);
 511                 SIP_CANCEL_TIMER(tmp->sip_xaction_TK);
 512                 sip_write_to_log((void *)tmp, SIP_TRANSACTION_LOG, NULL, 0);
 513                 free(tmp->sip_xaction_branch_id);
 514                 if (tmp->sip_xaction_last_msg != NULL) {
 515                         SIP_MSG_REFCNT_DECR(tmp->sip_xaction_last_msg);
 516                         tmp->sip_xaction_last_msg = NULL;
 517                 }
 518                 if (tmp->sip_xaction_orig_msg != NULL) {
 519                         SIP_MSG_REFCNT_DECR(tmp->sip_xaction_orig_msg);
 520                         tmp->sip_xaction_orig_msg = NULL;
 521                 }
 522                 if (tmp->sip_xaction_conn_obj != NULL) {
 523                         sip_del_conn_obj_cache(tmp->sip_xaction_conn_obj,
 524                             (void *)tmp);
 525                 }
 526                 /*
 527                  * If the transaction logging is disabled before we could
 528                  * write the captured messages into the transaction log, then
 529                  * we need to free those captured messsages
 530                  */
 531                 for (count = 0; count <= SIP_SRV_NONINV_TERMINATED; count++) {
 532                         msg_chain = tmp->sip_xaction_log[count].sip_msgs;
 533                         while (msg_chain != NULL) {
 534                                 nmsg_chain = msg_chain->next;
 535                                 if (msg_chain->sip_msg != NULL)
 536                                         free(msg_chain->sip_msg);
 537                                 free(msg_chain);
 538                                 msg_chain = nmsg_chain;
 539                         }
 540                 }
 541                 free(tmp);
 542                 return (B_TRUE);
 543         }
 544         (void) pthread_mutex_unlock(&tmp->sip_xaction_mutex);
 545         return (B_FALSE);
 546 }
 547
 548 /*
 549  * Delete a SIP transaction
 550  */
 551 void
 552 sip_xaction_delete(sip_xaction_t *trans)
 553 {
 554         int     hindex;
 555
 556         (void) pthread_mutex_lock(&trans->sip_xaction_mutex);
 557         hindex = SIP_DIGEST_TO_HASH(trans->sip_xaction_hash_digest);
 558         if (trans->sip_xaction_ref_cnt != 0) {
 559                 (void) pthread_mutex_unlock(&trans->sip_xaction_mutex);
 560                 return;
 561         }
 562         (void) pthread_mutex_unlock(&trans->sip_xaction_mutex);
 563         sip_hash_delete(sip_xaction_hash, trans->sip_xaction_hash_digest,
 564             hindex, sip_xaction_remove);
 565 }
 566
 567 /*
 568  * Add a SIP transaction into the hash list.
 569  */
 570 int
 571 sip_xaction_add(sip_xaction_t *trans, char *branchid, _sip_msg_t *msg,
 572     sip_method_t method)
 573 {
 574         uint16_t        hash_index[8];
 575
 576         if (sip_find_md5_digest(branchid, msg, hash_index, method) != 0)
 577                 return (EINVAL);
 578
 579         /*
 580          * trans is not in the list as yet, so no need to hold the lock
 581          */
 582         bcopy(hash_index, trans->sip_xaction_hash_digest, sizeof (hash_index));
 583
 584         if (sip_hash_add(sip_xaction_hash, (void *)trans,
 585             SIP_DIGEST_TO_HASH(hash_index)) != 0) {
 586                 return (ENOMEM);
 587         }
 588         return (0);
 589 }
 590
 591
 592 /*
 593  * Given a state, return the  string - This is mostly for debug purposes
 594  */
 595 char *
 596 sip_get_xaction_state(int state)
 597 {
 598         switch (state) {
 599                 case SIP_NEW_TRANSACTION:
 600                         return ("SIP_NEW_TRANSACTION");
 601                 case SIP_CLNT_CALLING:
 602                         return ("SIP_CLNT_CALLING");
 603                 case SIP_CLNT_INV_PROCEEDING:
 604                         return ("SIP_CLNT_INV_PROCEEDING");
 605                 case SIP_CLNT_INV_TERMINATED:
 606                         return ("SIP_CLNT_INV_TERMINATED");
 607                 case SIP_CLNT_INV_COMPLETED:
 608                         return ("SIP_CLNT_INV_COMPLETED");
 609                 case SIP_CLNT_TRYING:
 610                         return ("SIP_CLNT_TRYING");
 611                 case SIP_CLNT_NONINV_PROCEEDING:
 612                         return ("SIP_CLNT_NONINV_PROCEEDING");
 613                 case SIP_CLNT_NONINV_TERMINATED:
 614                         return ("SIP_CLNT_NONINV_TERMINATED");
 615                 case SIP_CLNT_NONINV_COMPLETED:
 616                         return ("SIP_CLNT_NONINV_COMPLETED");
 617                 case SIP_SRV_INV_PROCEEDING:
 618                         return ("SIP_SRV_INV_PROCEEDING");
 619                 case SIP_SRV_INV_COMPLETED:
 620                         return ("SIP_SRV_INV_COMPLETED");
 621                 case SIP_SRV_CONFIRMED:
 622                         return ("SIP_SRV_CONFIRMED");
 623                 case SIP_SRV_INV_TERMINATED:
 624                         return ("SIP_SRV_INV_TERMINATED");
 625                 case SIP_SRV_TRYING:
 626                         return ("SIP_SRV_TRYING");
 627                 case SIP_SRV_NONINV_PROCEEDING:
 628                         return ("SIP_SRV_NONINV_PROCEEDING");
 629                 case SIP_SRV_NONINV_COMPLETED:
 630                         return ("SIP_SRV_NONINV_COMPLETED");
 631                 case SIP_SRV_NONINV_TERMINATED:
 632                         return ("SIP_SRV_NONINV_TERMINATED");
 633                 default :
 634                         return ("UNKNOWN");
 635         }
 636 }
 637
 638 /*
 639  * Initialize the hash table etc.
 640  */
 641 void
 642 sip_xaction_init(int (*ulp_trans_err)(sip_transaction_t, int, void *),
 643     void (*ulp_state_cb)(sip_transaction_t, sip_msg_t, int, int))
 644 {
 645         int     cnt;
 646
 647         for (cnt = 0; cnt < SIP_HASH_SZ; cnt++) {
 648                 sip_xaction_hash[cnt].hash_count = 0;
 649                 sip_xaction_hash[cnt].hash_head = NULL;
 650                 sip_xaction_hash[cnt].hash_tail = NULL;
 651                 (void) pthread_mutex_init(
 652                     &sip_xaction_hash[cnt].sip_hash_mutex, NULL);
 653         }
 654         if (ulp_trans_err != NULL)
 655                 sip_xaction_ulp_trans_err = ulp_trans_err;
 656         if (ulp_state_cb != NULL)
 657                 sip_xaction_ulp_state_cb = ulp_state_cb;
 658 }