usr/src/lib/libsip/common/sip_dialog_ui.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 <sip.h>
  34
  35 #include "sip_msg.h"
  36 #include "sip_miscdefs.h"
  37 #include "sip_parse_uri.h"
  38 #include "sip_dialog.h"
  39
  40 /*
  41  * Create a request using the state maintained in the dialog.
  42  */
  43 sip_msg_t
  44 sip_create_dialog_req(sip_method_t method, sip_dialog_t dialog,
  45     char *transport, char *sent_by, int sent_by_port, char *via_param,
  46     uint32_t maxforward, int cseq)
  47 {
  48         _sip_dialog_t   *_dialog;
  49         sip_msg_t       sip_msg;
  50         char            *uri;
  51         int             oldseq = 0;
  52
  53         if (!sip_manage_dialog || dialog == NULL || transport == NULL ||
  54             sent_by == NULL) {
  55                 return (NULL);
  56         }
  57         if ((sip_msg = sip_new_msg()) == NULL)
  58                 return (NULL);
  59         _dialog = (_sip_dialog_t *)dialog;
  60         (void) pthread_mutex_lock(&_dialog->sip_dlg_mutex);
  61         /*
  62          * Depending on the route set, if any, the request URI could either
  63          * be the contact URI or the 1st URI from the route set.
  64          */
  65         uri = (char *)sip_dialog_req_uri(_dialog);
  66         if (uri == NULL)
  67                 goto err_ret;
  68         if (sip_add_request_line(sip_msg, method, uri) != 0) {
  69                 free(uri);
  70                 goto err_ret;
  71         }
  72         free(uri);
  73         if (sip_copy_header(sip_msg, _dialog->sip_dlg_local_uri_tag, NULL) != 0)
  74                 goto err_ret;
  75         if (sip_copy_header(sip_msg, _dialog->sip_dlg_remote_uri_tag, NULL) !=
  76             0) {
  77                 goto err_ret;
  78         }
  79         if (sip_copy_header(sip_msg, _dialog->sip_dlg_local_contact, NULL) != 0)
  80                 goto err_ret;
  81         if (sip_add_via(sip_msg, transport, sent_by, sent_by_port, via_param) !=
  82             0) {
  83                 goto err_ret;
  84         }
  85         if (sip_add_maxforward(sip_msg, maxforward) != 0)
  86                 goto err_ret;
  87         if (sip_copy_header(sip_msg, _dialog->sip_dlg_call_id, NULL) != 0)
  88                 goto err_ret;
  89         if (cseq < 0) {
  90                 if (_dialog->sip_dlg_local_cseq == 0)
  91                         _dialog->sip_dlg_local_cseq = 1;
  92                 oldseq = _dialog->sip_dlg_local_cseq;
  93                 cseq = ++_dialog->sip_dlg_local_cseq;
  94         }
  95         if (sip_add_cseq(sip_msg, method, cseq) != 0) {
  96                 _dialog->sip_dlg_local_cseq = oldseq;
  97                 goto err_ret;
  98         }
  99         /*
 100          * The route set, even if empty, overrides any pre-existing route set.
 101          * If the route set is empty, the UAC MUST NOT add a Route header
 102          * field to the request.
 103          */
 104         (void) sip_delete_header_by_name(sip_msg, SIP_ROUTE);
 105
 106         if (_dialog->sip_dlg_route_set != NULL) {
 107                 if (sip_copy_header(sip_msg, _dialog->sip_dlg_route_set,
 108                     NULL) != 0) {
 109                         _dialog->sip_dlg_local_cseq = oldseq;
 110                         goto err_ret;
 111                 }
 112         }
 113         (void) pthread_mutex_unlock(&_dialog->sip_dlg_mutex);
 114         return (sip_msg);
 115 err_ret:
 116         (void) pthread_mutex_unlock(&_dialog->sip_dlg_mutex);
 117         sip_free_msg(sip_msg);
 118         return (NULL);
 119 }
 120
 121 /*
 122  * Create a request using the state maintained in the dialog. The request will
 123  * not have Contact header.
 124  */
 125 sip_msg_t
 126 sip_create_dialog_req_nocontact(sip_method_t method, sip_dialog_t dialog,
 127     char *transport, char *sent_by, int sent_by_port, char *via_param,
 128     uint32_t maxforward, int cseq)
 129 {
 130         sip_msg_t       sip_msg;
 131
 132         sip_msg = sip_create_dialog_req(method, dialog, transport, sent_by,
 133             sent_by_port, via_param, maxforward, cseq);
 134         if (sip_msg != NULL) {
 135                 if (sip_delete_header_by_name(sip_msg, SIP_CONTACT) != 0) {
 136                         sip_free_msg(sip_msg);
 137                         return (NULL);
 138                 }
 139         }
 140
 141         return (sip_msg);
 142 }
 143
 144 /*
 145  * Get the Dialog method
 146  */
 147 int
 148 sip_get_dialog_method(sip_dialog_t dialog, int *error)
 149 {
 150         _sip_dialog_t   *_dialog;
 151
 152         if (error != NULL)
 153                 *error = 0;
 154         if (!sip_manage_dialog) {
 155                 if (error != NULL)
 156                         *error = EINVAL;
 157                 return (0);
 158         }
 159         if (dialog == NULL) {
 160                 if (error != NULL)
 161                         *error = EINVAL;
 162                 return (0);
 163         }
 164         _dialog = (_sip_dialog_t *)dialog;
 165         return (_dialog->sip_dlg_method);
 166 }
 167
 168 /*
 169  * Get the Dialog state
 170  */
 171 int
 172 sip_get_dialog_state(sip_dialog_t dialog, int *error)
 173 {
 174         _sip_dialog_t   *_dialog;
 175
 176         if (error != NULL)
 177                 *error = 0;
 178         if (!sip_manage_dialog) {
 179                 if (error != NULL)
 180                         *error = EINVAL;
 181                 return (0);
 182         }
 183         if (dialog == NULL) {
 184                 if (error != NULL)
 185                         *error = EINVAL;
 186                 return (0);
 187         }
 188         _dialog = (_sip_dialog_t *)dialog;
 189         return (_dialog->sip_dlg_state);
 190 }
 191
 192 /*
 193  * Return the dialog callid
 194  */
 195 const sip_str_t *
 196 sip_get_dialog_callid(sip_dialog_t dialog, int *error)
 197 {
 198         _sip_dialog_t           *_dialog;
 199         const struct sip_value  *val;
 200         const sip_str_t         *callid = NULL;
 201
 202         if (error != NULL)
 203                 *error = 0;
 204         if (!sip_manage_dialog || dialog == NULL) {
 205                 if (error != NULL)
 206                         *error = EINVAL;
 207                 return (NULL);
 208         }
 209         _dialog = (_sip_dialog_t *)dialog;
 210         (void) pthread_mutex_lock(&_dialog->sip_dlg_mutex);
 211         if (dialog->sip_dlg_call_id != NULL) {
 212                 val = sip_get_header_value(_dialog->sip_dlg_call_id, error);
 213                 if (val == NULL) {
 214                         (void) pthread_mutex_unlock(&_dialog->sip_dlg_mutex);
 215                         return (NULL);
 216                 }
 217                 callid = &((sip_hdr_value_t *)val)->str_val;
 218         }
 219         (void) pthread_mutex_unlock(&_dialog->sip_dlg_mutex);
 220         return (callid);
 221 }
 222
 223 /*
 224  * Return the dialog localtag.
 225  */
 226 const sip_str_t *
 227 sip_get_dialog_local_tag(sip_dialog_t dialog, int *error)
 228 {
 229         _sip_dialog_t           *_dialog;
 230         const sip_str_t         *ltag = NULL;
 231         const struct sip_value  *val;
 232
 233         if (error != NULL)
 234                 *error = 0;
 235         if (!sip_manage_dialog || dialog == NULL) {
 236                 if (error != NULL)
 237                         *error = EINVAL;
 238                 return (NULL);
 239         }
 240         _dialog = (_sip_dialog_t *)dialog;
 241         (void) pthread_mutex_lock(&_dialog->sip_dlg_mutex);
 242         if (dialog->sip_dlg_local_uri_tag != NULL) {
 243                 val = sip_get_header_value(_dialog->sip_dlg_local_uri_tag,
 244                     error);
 245                 if (val == NULL) {
 246                         (void) pthread_mutex_unlock(&_dialog->sip_dlg_mutex);
 247                         return (NULL);
 248                 }
 249                 ltag = sip_get_param_value((sip_header_value_t)val, "tag",
 250                     error);
 251         }
 252         (void) pthread_mutex_unlock(&_dialog->sip_dlg_mutex);
 253         return (ltag);
 254 }
 255
 256 /*
 257  * Return the dialog remotetag
 258  */
 259 const sip_str_t *
 260 sip_get_dialog_remote_tag(sip_dialog_t dialog, int *error)
 261 {
 262         _sip_dialog_t           *_dialog;
 263         const sip_str_t         *ttag = NULL;
 264         const struct sip_value  *val;
 265
 266         if (error != NULL)
 267                 *error = 0;
 268         if (!sip_manage_dialog || dialog == NULL) {
 269                 if (error != NULL)
 270                         *error = EINVAL;
 271                 return (NULL);
 272         }
 273         _dialog = (_sip_dialog_t *)dialog;
 274         (void) pthread_mutex_lock(&_dialog->sip_dlg_mutex);
 275         if (dialog->sip_dlg_remote_uri_tag != NULL) {
 276                 val = sip_get_header_value(_dialog->sip_dlg_remote_uri_tag,
 277                     error);
 278                 if (val == NULL) {
 279                         (void) pthread_mutex_unlock(&_dialog->sip_dlg_mutex);
 280                         return (NULL);
 281                 }
 282                 ttag = sip_get_param_value((sip_header_value_t)val, "tag",
 283                     error);
 284         }
 285         (void) pthread_mutex_unlock(&_dialog->sip_dlg_mutex);
 286
 287         return (ttag);
 288 }
 289
 290 /*
 291  * Return the dialog localuri.
 292  */
 293 const struct sip_uri *
 294 sip_get_dialog_local_uri(sip_dialog_t dialog, int *error)
 295 {
 296         _sip_dialog_t           *_dialog;
 297         const _sip_uri_t        *luri = NULL;
 298         const struct sip_value  *val;
 299
 300         if (error != NULL)
 301                 *error = 0;
 302         if (!sip_manage_dialog || dialog == NULL) {
 303                 if (error != NULL)
 304                         *error = EINVAL;
 305                 return (NULL);
 306         }
 307         _dialog = (_sip_dialog_t *)dialog;
 308         (void) pthread_mutex_lock(&_dialog->sip_dlg_mutex);
 309         if (dialog->sip_dlg_local_uri_tag != NULL) {
 310                 val = sip_get_header_value(_dialog->sip_dlg_local_uri_tag,
 311                     error);
 312                 if (val == NULL) {
 313                         (void) pthread_mutex_unlock(&_dialog->sip_dlg_mutex);
 314                         return (NULL);
 315                 }
 316                 luri = val->sip_value_parse_uri;
 317         }
 318         (void) pthread_mutex_unlock(&_dialog->sip_dlg_mutex);
 319
 320         return ((sip_uri_t)luri);
 321 }
 322
 323 /*
 324  * Return the dialog remoteuri.
 325  */
 326 const struct sip_uri *
 327 sip_get_dialog_remote_uri(sip_dialog_t dialog, int *error)
 328 {
 329         _sip_dialog_t           *_dialog;
 330         const _sip_uri_t        *ruri = NULL;
 331         const struct sip_value  *val;
 332
 333         if (error != NULL)
 334                 *error = 0;
 335         if (!sip_manage_dialog || dialog == NULL) {
 336                 if (error != NULL)
 337                         *error = EINVAL;
 338                 return (NULL);
 339         }
 340         _dialog = (_sip_dialog_t *)dialog;
 341         (void) pthread_mutex_lock(&_dialog->sip_dlg_mutex);
 342         if (dialog->sip_dlg_remote_uri_tag != NULL) {
 343                 val = sip_get_header_value(dialog->sip_dlg_remote_uri_tag,
 344                     error);
 345                 if (val == NULL) {
 346                         (void) pthread_mutex_unlock(&_dialog->sip_dlg_mutex);
 347                         return (NULL);
 348                 }
 349                 ruri = val->sip_value_parse_uri;
 350         }
 351         (void) pthread_mutex_unlock(&_dialog->sip_dlg_mutex);
 352         return ((sip_uri_t)ruri);
 353 }
 354
 355 /*
 356  * Return the dialog remotetarg.
 357  */
 358 const struct sip_uri *
 359 sip_get_dialog_remote_target_uri(sip_dialog_t dialog, int *error)
 360 {
 361         _sip_dialog_t           *_dialog;
 362         const struct sip_uri    *rtarg = NULL;
 363         const struct sip_value  *val;
 364
 365         if (error != NULL)
 366                 *error = 0;
 367         if (!sip_manage_dialog || dialog == NULL) {
 368                 if (error != NULL)
 369                         *error = EINVAL;
 370                 return (NULL);
 371         }
 372         _dialog = (_sip_dialog_t *)dialog;
 373         (void) pthread_mutex_lock(&_dialog->sip_dlg_mutex);
 374         if (dialog->sip_dlg_remote_target != NULL) {
 375                 val = sip_get_header_value(_dialog->sip_dlg_remote_target,
 376                     error);
 377                 if (val == NULL) {
 378                         (void) pthread_mutex_unlock(&_dialog->sip_dlg_mutex);
 379                         return (NULL);
 380                 }
 381                 rtarg = val->sip_value_parse_uri;
 382         }
 383         (void) pthread_mutex_unlock(&_dialog->sip_dlg_mutex);
 384
 385         return ((sip_uri_t)rtarg);
 386 }
 387
 388 /*
 389  * Return the dialog local contact uri.
 390  */
 391 const struct sip_uri *
 392 sip_get_dialog_local_contact_uri(sip_dialog_t dialog, int *error)
 393 {
 394         _sip_dialog_t           *_dialog;
 395         const struct sip_uri    *lcuri = NULL;
 396         const struct sip_value  *val;
 397
 398         if (error != NULL)
 399                 *error = 0;
 400         if (!sip_manage_dialog || dialog == NULL) {
 401                 if (error != NULL)
 402                         *error = EINVAL;
 403                 return (NULL);
 404         }
 405         _dialog = (_sip_dialog_t *)dialog;
 406         (void) pthread_mutex_lock(&_dialog->sip_dlg_mutex);
 407         if (dialog->sip_dlg_local_contact != NULL) {
 408                 val = sip_get_header_value(_dialog->sip_dlg_local_contact,
 409                     error);
 410                 if (val == NULL) {
 411                         (void) pthread_mutex_unlock(&_dialog->sip_dlg_mutex);
 412                         return (NULL);
 413                 }
 414                 lcuri = val->sip_value_parse_uri;
 415         }
 416         (void) pthread_mutex_unlock(&_dialog->sip_dlg_mutex);
 417
 418         return ((sip_uri_t)lcuri);
 419 }
 420
 421 /*
 422  * Return the dialog route set
 423  */
 424 const sip_str_t *
 425 sip_get_dialog_route_set(sip_dialog_t dialog, int *error)
 426 {
 427         _sip_dialog_t           *_dialog;
 428
 429         if (error != NULL)
 430                 *error = 0;
 431         if (!sip_manage_dialog || dialog == NULL) {
 432                 if (error != NULL)
 433                         *error = EINVAL;
 434                 return (NULL);
 435         }
 436         _dialog = (_sip_dialog_t *)dialog;
 437         if (_dialog->sip_dlg_rset.sip_str_len > 0)
 438                 return (&_dialog->sip_dlg_rset);
 439         return (NULL);
 440 }
 441
 442 /*
 443  * Return the dialog secure
 444  */
 445 boolean_t
 446 sip_is_dialog_secure(sip_dialog_t dialog, int *error)
 447 {
 448         _sip_dialog_t   *_dialog;
 449         boolean_t       issecure;
 450
 451         if (error != NULL)
 452                 *error = 0;
 453         if (!sip_manage_dialog || dialog == NULL) {
 454                 if (error != NULL)
 455                         *error = EINVAL;
 456                 return (B_FALSE);
 457         }
 458         _dialog = (_sip_dialog_t *)dialog;
 459         (void) pthread_mutex_lock(&_dialog->sip_dlg_mutex);
 460         issecure = _dialog->sip_dlg_secure;
 461         (void) pthread_mutex_unlock(&_dialog->sip_dlg_mutex);
 462         return (issecure);
 463 }
 464
 465 /*
 466  * Return the dialog local cseq
 467  */
 468 uint32_t
 469 sip_get_dialog_local_cseq(sip_dialog_t dialog, int *error)
 470 {
 471         _sip_dialog_t   *_dialog;
 472         uint32_t        cseq;
 473
 474         if (error != NULL)
 475                 *error = 0;
 476         if (!sip_manage_dialog || dialog == NULL) {
 477                 if (error != NULL)
 478                         *error = EINVAL;
 479                 return (0);
 480         }
 481         _dialog = (_sip_dialog_t *)dialog;
 482         (void) pthread_mutex_lock(&_dialog->sip_dlg_mutex);
 483         cseq = _dialog->sip_dlg_local_cseq;
 484         (void) pthread_mutex_unlock(&_dialog->sip_dlg_mutex);
 485         return (cseq);
 486 }
 487
 488 /*
 489  * Return the dialog remote cseq
 490  */
 491 uint32_t
 492 sip_get_dialog_remote_cseq(sip_dialog_t dialog, int *error)
 493 {
 494         _sip_dialog_t   *_dialog;
 495         uint32_t        cseq;
 496
 497         if (error != NULL)
 498                 *error = 0;
 499         if (!sip_manage_dialog || dialog == NULL) {
 500                 if (error != NULL)
 501                         *error = EINVAL;
 502                 return (0);
 503         }
 504         _dialog = (_sip_dialog_t *)dialog;
 505         (void) pthread_mutex_lock(&_dialog->sip_dlg_mutex);
 506         cseq = _dialog->sip_dlg_remote_cseq;
 507         (void) pthread_mutex_unlock(&_dialog->sip_dlg_mutex);
 508         return (cseq);
 509 }
 510
 511 /*
 512  * Return the dialog type
 513  */
 514 int
 515 sip_get_dialog_type(sip_dialog_t dialog, int *error)
 516 {
 517         _sip_dialog_t   *_dialog;
 518         int             type;
 519
 520         if (error != NULL)
 521                 *error = 0;
 522         if (!sip_manage_dialog || dialog == NULL) {
 523                 if (error != NULL)
 524                         *error = EINVAL;
 525                 return (-1);
 526         }
 527         _dialog = (_sip_dialog_t *)dialog;
 528         (void) pthread_mutex_lock(&_dialog->sip_dlg_mutex);
 529         type = _dialog->sip_dlg_type;
 530         (void) pthread_mutex_unlock(&_dialog->sip_dlg_mutex);
 531         return (type);
 532 }
 533
 534 /*
 535  * Return the number of messages exchanged within a dialog.
 536  */
 537 int
 538 sip_get_dialog_msgcnt(sip_dialog_t dialog, int *error)
 539 {
 540         _sip_dialog_t   *_dialog;
 541         int             nmsgs;
 542
 543         if (error != NULL)
 544                 *error = 0;
 545         if (!sip_manage_dialog || dialog == NULL) {
 546                 if (error != NULL)
 547                         *error = EINVAL;
 548                 return (-1);
 549         }
 550         _dialog = (_sip_dialog_t *)dialog;
 551         (void) pthread_mutex_lock(&_dialog->sip_dlg_mutex);
 552         nmsgs = _dialog->sip_dlg_msgcnt;
 553         (void) pthread_mutex_unlock(&_dialog->sip_dlg_mutex);
 554         return (nmsgs);
 555 }
 556
 557 /*
 558  * Partial dialog ?
 559  */
 560 boolean_t
 561 sip_incomplete_dialog(sip_dialog_t dialog)
 562 {
 563         _sip_dialog_t   *_dialog;
 564         boolean_t       isnew;
 565
 566         if (!sip_manage_dialog || dialog == NULL)
 567                 return (B_FALSE);
 568         _dialog = (_sip_dialog_t *)dialog;
 569         (void) pthread_mutex_lock(&_dialog->sip_dlg_mutex);
 570         isnew = _dialog->sip_dlg_state == SIP_DLG_NEW;
 571         (void) pthread_mutex_unlock(&_dialog->sip_dlg_mutex);
 572         return (isnew);
 573 }
 574
 575 /*
 576  * Hold dialog
 577  */
 578 void
 579 sip_hold_dialog(sip_dialog_t dialog)
 580 {
 581         _sip_dialog_t   *_dialog;
 582
 583         if (!sip_manage_dialog || dialog == NULL)
 584                 return;
 585         _dialog = (_sip_dialog_t *)dialog;
 586         (void) pthread_mutex_lock(&_dialog->sip_dlg_mutex);
 587         SIP_DLG_REFCNT_INCR(_dialog);
 588         (void) pthread_mutex_unlock(&_dialog->sip_dlg_mutex);
 589 }
 590
 591 /*
 592  * Release dialog
 593  */
 594 void
 595 sip_release_dialog(sip_dialog_t dialog)
 596 {
 597         _sip_dialog_t   *_dialog;
 598
 599         if (!sip_manage_dialog || dialog == NULL)
 600                 return;
 601         _dialog = (_sip_dialog_t *)dialog;
 602         SIP_DLG_REFCNT_DECR(_dialog);
 603 }
 604
 605 /*
 606  * Delete a dialog
 607  */
 608 void
 609 sip_delete_dialog(sip_dialog_t dialog)
 610 {
 611         if (!sip_manage_dialog || dialog == NULL)
 612                 return;
 613         sip_dialog_terminate(dialog, NULL);
 614 }