res/pjproject/pjsip/src/pjsip-ua/sip_100rel.c

   1 /* $Id$ */
   2 /*
   3  * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
   4  * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20 #include <pjsip-ua/sip_100rel.h>
  21 #include <pjsip/sip_endpoint.h>
  22 #include <pjsip/sip_event.h>
  23 #include <pjsip/sip_module.h>
  24 #include <pjsip/sip_transaction.h>
  25 #include <pj/assert.h>
  26 #include <pj/ctype.h>
  27 #include <pj/log.h>
  28 #include <pj/os.h>
  29 #include <pj/pool.h>
  30 #include <pj/rand.h>
  31 #include <pj/string.h>
  32
  33 #define THIS_FILE       "sip_100rel.c"
  34
  35 /* PRACK method */
  36 PJ_DEF_DATA(const pjsip_method) pjsip_prack_method =
  37 {
  38     PJSIP_OTHER_METHOD,
  39     { "PRACK", 5 }
  40 };
  41
  42 typedef struct dlg_data dlg_data;
  43
  44 /*
  45  * Static prototypes.
  46  */
  47 static pj_status_t mod_100rel_load(pjsip_endpoint *endpt);
  48
  49 static void on_retransmit(pj_timer_heap_t *timer_heap,
  50                           struct pj_timer_entry *entry);
  51
  52
  53 const pj_str_t tag_100rel = { "100rel", 6 };
  54 const pj_str_t RSEQ = { "RSeq", 4 };
  55 const pj_str_t RACK = { "RAck", 4 };
  56
  57
  58 /* 100rel module */
  59 static struct mod_100rel
  60 {
  61     pjsip_module         mod;
  62     pjsip_endpoint      *endpt;
  63 } mod_100rel =
  64 {
  65     {
  66         NULL, NULL,                         /* prev, next.              */
  67         { "mod-100rel", 10 },               /* Name.                    */
  68         -1,                                 /* Id                       */
  69         PJSIP_MOD_PRIORITY_DIALOG_USAGE,    /* Priority                 */
  70         &mod_100rel_load,                   /* load()                   */
  71         NULL,                               /* start()                  */
  72         NULL,                               /* stop()                   */
  73         NULL,                               /* unload()                 */
  74         NULL,                               /* on_rx_request()          */
  75         NULL,                               /* on_rx_response()         */
  76         NULL,                               /* on_tx_request.           */
  77         NULL,                               /* on_tx_response()         */
  78         NULL,                               /* on_tsx_state()           */
  79     }
  80
  81 };
  82
  83 /* List of pending transmission (may include the final response as well) */
  84 typedef struct tx_data_list_t
  85 {
  86         PJ_DECL_LIST_MEMBER(struct tx_data_list_t);
  87         pj_uint32_t      rseq;
  88         pjsip_tx_data   *tdata;
  89 } tx_data_list_t;
  90
  91
  92 /* Below, UAS and UAC roles are of the INVITE transaction */
  93
  94 /* UAS state. */
  95 typedef struct uas_state_t
  96 {
  97         pj_int32_t       cseq;
  98         pj_uint32_t      rseq;  /* Initialized to -1 */
  99         tx_data_list_t   tx_data_list;
 100         unsigned         retransmit_count;
 101         pj_timer_entry   retransmit_timer;
 102 } uas_state_t;
 103
 104
 105 /* UAC state */
 106 typedef struct uac_state_t
 107 {
 108     pj_str_t            tag;    /* To tag               */
 109     pj_int32_t          cseq;
 110     pj_uint32_t         rseq;   /* Initialized to -1    */
 111     struct uac_state_t *next;   /* next call leg        */
 112 } uac_state_t;
 113
 114
 115 /* State attached to each dialog. */
 116 struct dlg_data
 117 {
 118         pjsip_inv_session       *inv;
 119         uas_state_t             *uas_state;
 120         uac_state_t             *uac_state_list;
 121 };
 122
 123
 124 /*****************************************************************************
 125  **
 126  ** Module
 127  **
 128  *****************************************************************************
 129  */
 130 static pj_status_t mod_100rel_load(pjsip_endpoint *endpt)
 131 {
 132     mod_100rel.endpt = endpt;
 133     pjsip_endpt_add_capability(endpt, &mod_100rel.mod,
 134                                PJSIP_H_ALLOW, NULL,
 135                                1, &pjsip_prack_method.name);
 136     pjsip_endpt_add_capability(endpt, &mod_100rel.mod,
 137                                PJSIP_H_SUPPORTED, NULL,
 138                                1, &tag_100rel);
 139
 140     return PJ_SUCCESS;
 141 }
 142
 143 static pjsip_require_hdr *find_req_hdr(pjsip_msg *msg)
 144 {
 145     pjsip_require_hdr *hreq;
 146
 147     hreq = (pjsip_require_hdr*)
 148             pjsip_msg_find_hdr(msg, PJSIP_H_REQUIRE, NULL);
 149
 150     while (hreq) {
 151         unsigned i;
 152         for (i=0; i<hreq->count; ++i) {
 153             if (!pj_stricmp(&hreq->values[i], &tag_100rel)) {
 154                 return hreq;
 155             }
 156         }
 157
 158         if ((void*)hreq->next == (void*)&msg->hdr)
 159             return NULL;
 160
 161         hreq = (pjsip_require_hdr*)
 162                 pjsip_msg_find_hdr(msg, PJSIP_H_REQUIRE, hreq->next);
 163
 164     }
 165
 166     return NULL;
 167 }
 168
 169
 170 /*
 171  * Get PRACK method constant.
 172  */
 173 PJ_DEF(const pjsip_method*) pjsip_get_prack_method(void)
 174 {
 175     return &pjsip_prack_method;
 176 }
 177
 178
 179 /*
 180  * init module
 181  */
 182 PJ_DEF(pj_status_t) pjsip_100rel_init_module(pjsip_endpoint *endpt)
 183 {
 184     if (mod_100rel.mod.id != -1)
 185         return PJ_SUCCESS;
 186
 187     return pjsip_endpt_register_module(endpt, &mod_100rel.mod);
 188 }
 189
 190
 191 /*
 192  * API: attach 100rel support in invite session. Called by
 193  *      sip_inv.c
 194  */
 195 PJ_DEF(pj_status_t) pjsip_100rel_attach(pjsip_inv_session *inv)
 196 {
 197     dlg_data *dd;
 198
 199     /* Check that 100rel module has been initialized */
 200     PJ_ASSERT_RETURN(mod_100rel.mod.id >= 0, PJ_EINVALIDOP);
 201
 202     /* Create and attach as dialog usage */
 203     dd = PJ_POOL_ZALLOC_T(inv->dlg->pool, dlg_data);
 204     dd->inv = inv;
 205     pjsip_dlg_add_usage(inv->dlg, &mod_100rel.mod, (void*)dd);
 206
 207     PJ_LOG(5,(dd->inv->dlg->obj_name, "100rel module attached"));
 208
 209     return PJ_SUCCESS;
 210 }
 211
 212
 213 /*
 214  * Check if incoming response has reliable provisional response feature.
 215  */
 216 PJ_DEF(pj_bool_t) pjsip_100rel_is_reliable(pjsip_rx_data *rdata)
 217 {
 218     pjsip_msg *msg = rdata->msg_info.msg;
 219
 220     PJ_ASSERT_RETURN(msg->type == PJSIP_RESPONSE_MSG, PJ_FALSE);
 221
 222     return msg->line.status.code > 100 && msg->line.status.code < 200 &&
 223            rdata->msg_info.require != NULL &&
 224            find_req_hdr(msg) != NULL;
 225 }
 226
 227
 228 /*
 229  * Create PRACK request for the incoming reliable provisional response.
 230  */
 231 PJ_DEF(pj_status_t) pjsip_100rel_create_prack( pjsip_inv_session *inv,
 232                                                pjsip_rx_data *rdata,
 233                                                pjsip_tx_data **p_tdata)
 234 {
 235     dlg_data *dd;
 236     uac_state_t *uac_state = NULL;
 237     const pj_str_t *to_tag = &rdata->msg_info.to->tag;
 238     pjsip_transaction *tsx;
 239     pjsip_msg *msg;
 240     pjsip_generic_string_hdr *rseq_hdr;
 241     pjsip_generic_string_hdr *rack_hdr;
 242     unsigned rseq;
 243     pj_str_t rack;
 244     char rack_buf[80];
 245     pjsip_tx_data *tdata;
 246     pj_status_t status;
 247
 248     *p_tdata = NULL;
 249
 250     dd = (dlg_data*) inv->dlg->mod_data[mod_100rel.mod.id];
 251     PJ_ASSERT_RETURN(dd != NULL, PJSIP_ENOTINITIALIZED);
 252
 253     tsx = pjsip_rdata_get_tsx(rdata);
 254     msg = rdata->msg_info.msg;
 255
 256     /* Check our assumptions */
 257     pj_assert( tsx->role == PJSIP_ROLE_UAC &&
 258                tsx->method.id == PJSIP_INVITE_METHOD &&
 259                msg->line.status.code > 100 &&
 260                msg->line.status.code < 200);
 261
 262
 263     /* Get the RSeq header */
 264     rseq_hdr = (pjsip_generic_string_hdr*)
 265                pjsip_msg_find_hdr_by_name(msg, &RSEQ, NULL);
 266     if (rseq_hdr == NULL) {
 267         PJ_LOG(4,(dd->inv->dlg->obj_name,
 268                  "Ignoring 100rel response with no RSeq header"));
 269         return PJSIP_EMISSINGHDR;
 270     }
 271     rseq = (pj_uint32_t) pj_strtoul(&rseq_hdr->hvalue);
 272
 273     /* Find UAC state for the specified call leg */
 274     uac_state = dd->uac_state_list;
 275     while (uac_state) {
 276         if (pj_strcmp(&uac_state->tag, to_tag)==0)
 277             break;
 278         uac_state = uac_state->next;
 279     }
 280
 281     /* Create new UAC state if we don't have one */
 282     if (uac_state == NULL) {
 283         uac_state = PJ_POOL_ZALLOC_T(dd->inv->dlg->pool, uac_state_t);
 284         uac_state->cseq = rdata->msg_info.cseq->cseq;
 285         uac_state->rseq = rseq - 1;
 286         pj_strdup(dd->inv->dlg->pool, &uac_state->tag, to_tag);
 287         uac_state->next = dd->uac_state_list;
 288         dd->uac_state_list = uac_state;
 289     }
 290
 291     /* If this is from new INVITE transaction, reset UAC state. */
 292     if (rdata->msg_info.cseq->cseq != uac_state->cseq) {
 293         uac_state->cseq = rdata->msg_info.cseq->cseq;
 294         uac_state->rseq = rseq - 1;
 295     }
 296
 297     /* Ignore provisional response retransmission */
 298     if (rseq <= uac_state->rseq) {
 299         /* This should have been handled before */
 300         return PJ_EIGNORED;
 301
 302     /* Ignore provisional response with out-of-order RSeq */
 303     } else if (rseq != uac_state->rseq + 1) {
 304         PJ_LOG(4,(dd->inv->dlg->obj_name,
 305                  "Ignoring 100rel response because RSeq jump "
 306                  "(expecting %u, got %u)",
 307                  uac_state->rseq+1, rseq));
 308         return PJ_EIGNORED;
 309     }
 310
 311     /* Update our RSeq */
 312     uac_state->rseq = rseq;
 313
 314     /* Create PRACK */
 315     status = pjsip_dlg_create_request(dd->inv->dlg, &pjsip_prack_method,
 316                                       -1, &tdata);
 317     if (status != PJ_SUCCESS)
 318         return status;
 319
 320     /* If this response is a forked response from a different call-leg,
 321      * update the req URI (https://trac.pjsip.org/repos/ticket/1364)
 322      */
 323     if (pj_strcmp(&uac_state->tag, &dd->inv->dlg->remote.info->tag)) {
 324         const pjsip_contact_hdr *mhdr;
 325
 326         mhdr = (const pjsip_contact_hdr*)
 327                pjsip_msg_find_hdr(rdata->msg_info.msg,
 328                                   PJSIP_H_CONTACT, NULL);
 329         if (!mhdr || !mhdr->uri) {
 330             PJ_LOG(4,(dd->inv->dlg->obj_name,
 331                      "Ignoring 100rel response with no or "
 332                      "invalid Contact header"));
 333             pjsip_tx_data_dec_ref(tdata);
 334             return PJ_EIGNORED;
 335         }
 336         tdata->msg->line.req.uri = (pjsip_uri*)
 337                                    pjsip_uri_clone(tdata->pool, mhdr->uri);
 338     }
 339
 340     /* Create RAck header */
 341     rack.ptr = rack_buf;
 342     rack.slen = pj_ansi_snprintf(rack.ptr, sizeof(rack_buf),
 343                                  "%u %u %.*s",
 344                                  rseq, rdata->msg_info.cseq->cseq,
 345                                  (int)tsx->method.name.slen,
 346                                  tsx->method.name.ptr);
 347     rack_hdr = pjsip_generic_string_hdr_create(tdata->pool, &RACK, &rack);
 348     pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*) rack_hdr);
 349
 350     /* Done */
 351     *p_tdata = tdata;
 352
 353     return PJ_SUCCESS;
 354 }
 355
 356
 357 /*
 358  * Send PRACK request.
 359  */
 360 PJ_DEF(pj_status_t) pjsip_100rel_send_prack( pjsip_inv_session *inv,
 361                                              pjsip_tx_data *tdata)
 362 {
 363     dlg_data *dd;
 364
 365     dd = (dlg_data*) inv->dlg->mod_data[mod_100rel.mod.id];
 366     PJ_ASSERT_ON_FAIL(dd != NULL,
 367     {pjsip_tx_data_dec_ref(tdata); return PJSIP_ENOTINITIALIZED; });
 368
 369     return pjsip_dlg_send_request(inv->dlg, tdata,
 370                                   mod_100rel.mod.id, (void*) dd);
 371
 372 }
 373
 374
 375 /*
 376  * Notify 100rel module that the invite session has been disconnected.
 377  */
 378 PJ_DEF(pj_status_t) pjsip_100rel_end_session(pjsip_inv_session *inv)
 379 {
 380     dlg_data *dd;
 381
 382     dd = (dlg_data*) inv->dlg->mod_data[mod_100rel.mod.id];
 383     if (!dd)
 384         return PJ_SUCCESS;
 385
 386     /* Make sure we don't have pending transmission */
 387     if (dd->uas_state) {
 388         pj_assert(!dd->uas_state->retransmit_timer.id);
 389         pj_assert(pj_list_empty(&dd->uas_state->tx_data_list));
 390     }
 391
 392     return PJ_SUCCESS;
 393 }
 394
 395
 396 static void parse_rack(const pj_str_t *rack,
 397                        pj_uint32_t *p_rseq, pj_int32_t *p_seq,
 398                        pj_str_t *p_method)
 399 {
 400     const char *p = rack->ptr, *end = p + rack->slen;
 401     pj_str_t token;
 402
 403     token.ptr = (char*)p;
 404     while (p < end && pj_isdigit(*p))
 405         ++p;
 406     token.slen = p - token.ptr;
 407     *p_rseq = pj_strtoul(&token);
 408
 409     ++p;
 410     token.ptr = (char*)p;
 411     while (p < end && pj_isdigit(*p))
 412         ++p;
 413     token.slen = p - token.ptr;
 414     *p_seq = pj_strtoul(&token);
 415
 416     ++p;
 417     if (p < end) {
 418         p_method->ptr = (char*)p;
 419         p_method->slen = end - p;
 420     } else {
 421         p_method->ptr = NULL;
 422         p_method->slen = 0;
 423     }
 424 }
 425
 426 /* Clear all responses in the transmission list */
 427 static void clear_all_responses(dlg_data *dd)
 428 {
 429     tx_data_list_t *tl;
 430
 431     tl = dd->uas_state->tx_data_list.next;
 432     while (tl != &dd->uas_state->tx_data_list) {
 433         pjsip_tx_data_dec_ref(tl->tdata);
 434         tl = tl->next;
 435     }
 436     pj_list_init(&dd->uas_state->tx_data_list);
 437 }
 438
 439
 440 /*
 441  * Handle incoming PRACK request.
 442  */
 443 PJ_DEF(pj_status_t) pjsip_100rel_on_rx_prack( pjsip_inv_session *inv,
 444                                               pjsip_rx_data *rdata)
 445 {
 446     dlg_data *dd;
 447     pjsip_transaction *tsx;
 448     pjsip_msg *msg;
 449     pjsip_generic_string_hdr *rack_hdr;
 450     pjsip_tx_data *tdata;
 451     pj_uint32_t rseq;
 452     pj_int32_t cseq;
 453     pj_str_t method;
 454     pj_status_t status;
 455
 456     tsx = pjsip_rdata_get_tsx(rdata);
 457     pj_assert(tsx != NULL);
 458
 459     msg = rdata->msg_info.msg;
 460
 461     dd = (dlg_data*) inv->dlg->mod_data[mod_100rel.mod.id];
 462     if (dd == NULL) {
 463         /* UAC sends us PRACK while we didn't send reliable provisional
 464          * response. Respond with 400 (?)
 465          */
 466         const pj_str_t reason = pj_str("Unexpected PRACK");
 467
 468         status = pjsip_dlg_create_response(inv->dlg, rdata, 400,
 469                                            &reason, &tdata);
 470         if (status == PJ_SUCCESS) {
 471             status = pjsip_dlg_send_response(inv->dlg, tsx, tdata);
 472         }
 473         return PJSIP_ENOTINITIALIZED;
 474     }
 475
 476     /* Always reply with 200/OK for PRACK */
 477     status = pjsip_dlg_create_response(inv->dlg, rdata, 200, NULL, &tdata);
 478     if (status == PJ_SUCCESS) {
 479         status = pjsip_dlg_send_response(inv->dlg, tsx, tdata);
 480     }
 481
 482     /* Ignore if we don't have pending transmission */
 483     if (dd->uas_state == NULL || pj_list_empty(&dd->uas_state->tx_data_list)) {
 484         PJ_LOG(4,(dd->inv->dlg->obj_name,
 485                   "PRACK ignored - no pending response"));
 486         return PJ_EIGNORED;
 487     }
 488
 489     /* Find RAck header */
 490     rack_hdr = (pjsip_generic_string_hdr*)
 491                pjsip_msg_find_hdr_by_name(msg, &RACK, NULL);
 492     if (!rack_hdr) {
 493         /* RAck header not found */
 494         PJ_LOG(4,(dd->inv->dlg->obj_name, "No RAck header"));
 495         return PJSIP_EMISSINGHDR;
 496     }
 497
 498     /* Parse RAck header */
 499     parse_rack(&rack_hdr->hvalue, &rseq, &cseq, &method);
 500
 501
 502     /* Match RAck against outgoing transmission */
 503     if (rseq == dd->uas_state->tx_data_list.next->rseq &&
 504         cseq == dd->uas_state->cseq)
 505     {
 506         /*
 507          * Yes this PRACK matches outgoing transmission.
 508          */
 509         tx_data_list_t *tl = dd->uas_state->tx_data_list.next;
 510
 511         if (dd->uas_state->retransmit_timer.id) {
 512             pjsip_endpt_cancel_timer(dd->inv->dlg->endpt,
 513                                      &dd->uas_state->retransmit_timer);
 514             dd->uas_state->retransmit_timer.id = PJ_FALSE;
 515         }
 516
 517         /* Remove from the list */
 518         if (tl != &dd->uas_state->tx_data_list) {
 519             pj_list_erase(tl);
 520
 521             /* Destroy the response */
 522             pjsip_tx_data_dec_ref(tl->tdata);
 523         }
 524
 525         /* Schedule next packet */
 526         dd->uas_state->retransmit_count = 0;
 527         if (!pj_list_empty(&dd->uas_state->tx_data_list)) {
 528             on_retransmit(NULL, &dd->uas_state->retransmit_timer);
 529         }
 530
 531     } else {
 532         /* No it doesn't match */
 533         PJ_LOG(4,(dd->inv->dlg->obj_name,
 534                  "Rx PRACK with no matching reliable response"));
 535         return PJ_EIGNORED;
 536     }
 537
 538     return PJ_SUCCESS;
 539 }
 540
 541
 542 /*
 543  * This is retransmit timer callback, called initially to send the response,
 544  * and subsequently when the retransmission time elapses.
 545  */
 546 static void on_retransmit(pj_timer_heap_t *timer_heap,
 547                           struct pj_timer_entry *entry)
 548 {
 549     dlg_data *dd;
 550     tx_data_list_t *tl;
 551     pjsip_tx_data *tdata;
 552     pj_bool_t final;
 553     pj_time_val delay;
 554
 555     PJ_UNUSED_ARG(timer_heap);
 556
 557     dd = (dlg_data*) entry->user_data;
 558
 559     entry->id = PJ_FALSE;
 560
 561     ++dd->uas_state->retransmit_count;
 562     if (dd->uas_state->retransmit_count >= 7) {
 563         /* If a reliable provisional response is retransmitted for
 564            64*T1 seconds  without reception of a corresponding PRACK,
 565            the UAS SHOULD reject the original request with a 5xx
 566            response.
 567         */
 568         pj_str_t reason = pj_str("Reliable response timed out");
 569         pj_status_t status;
 570
 571         /* Clear all pending responses */
 572         clear_all_responses(dd);
 573
 574         /* Send 500 response */
 575         status = pjsip_inv_end_session(dd->inv, 500, &reason, &tdata);
 576         if (status == PJ_SUCCESS) {
 577             pjsip_dlg_send_response(dd->inv->dlg,
 578                                     dd->inv->invite_tsx,
 579                                     tdata);
 580         }
 581         return;
 582     }
 583
 584     pj_assert(!pj_list_empty(&dd->uas_state->tx_data_list));
 585     tl = dd->uas_state->tx_data_list.next;
 586     tdata = tl->tdata;
 587
 588     pjsip_tx_data_add_ref(tdata);
 589     final = tdata->msg->line.status.code >= 200;
 590
 591     if (dd->uas_state->retransmit_count == 1) {
 592         pjsip_tsx_send_msg(dd->inv->invite_tsx, tdata);
 593     } else {
 594         pjsip_tsx_retransmit_no_state(dd->inv->invite_tsx, tdata);
 595     }
 596
 597     if (final) {
 598         /* This is final response, which will be retransmitted by
 599          * UA layer. There's no more task to do, so clear the
 600          * transmission list and bail out.
 601          */
 602         clear_all_responses(dd);
 603         return;
 604     }
 605
 606     /* Schedule next retransmission */
 607     if (dd->uas_state->retransmit_count < 6) {
 608         delay.sec = 0;
 609         delay.msec = (1 << dd->uas_state->retransmit_count) *
 610                      pjsip_cfg()->tsx.t1;
 611         pj_time_val_normalize(&delay);
 612     } else {
 613         delay.sec = 1;
 614         delay.msec = 500;
 615     }
 616
 617
 618     pjsip_endpt_schedule_timer(dd->inv->dlg->endpt,
 619                                &dd->uas_state->retransmit_timer,
 620                                &delay);
 621
 622     entry->id = PJ_TRUE;
 623 }
 624
 625
 626 /* Clone response. */
 627 static pjsip_tx_data *clone_tdata(dlg_data *dd,
 628                                   const pjsip_tx_data *src)
 629 {
 630     pjsip_tx_data *dst;
 631     const pjsip_hdr *hsrc;
 632     pjsip_msg *msg;
 633     pj_status_t status;
 634
 635     status = pjsip_endpt_create_tdata(dd->inv->dlg->endpt, &dst);
 636     if (status != PJ_SUCCESS)
 637         return NULL;
 638
 639     msg = pjsip_msg_create(dst->pool, PJSIP_RESPONSE_MSG);
 640     dst->msg = msg;
 641     pjsip_tx_data_add_ref(dst);
 642
 643     /* Duplicate status line */
 644     msg->line.status.code = src->msg->line.status.code;
 645     pj_strdup(dst->pool, &msg->line.status.reason,
 646               &src->msg->line.status.reason);
 647
 648     /* Duplicate all headers */
 649     hsrc = src->msg->hdr.next;
 650     while (hsrc != &src->msg->hdr) {
 651         pjsip_hdr *h = (pjsip_hdr*) pjsip_hdr_clone(dst->pool, hsrc);
 652         pjsip_msg_add_hdr(msg, h);
 653         hsrc = hsrc->next;
 654     }
 655
 656     /* Duplicate message body */
 657     if (src->msg->body)
 658         msg->body = pjsip_msg_body_clone(dst->pool, src->msg->body);
 659
 660     PJ_LOG(5,(dd->inv->dlg->obj_name,
 661              "Reliable response %s created",
 662              pjsip_tx_data_get_info(dst)));
 663
 664     return dst;
 665 }
 666
 667
 668 /* Check if any pending response in transmission list has SDP */
 669 static pj_bool_t has_sdp(dlg_data *dd)
 670 {
 671     tx_data_list_t *tl;
 672
 673     tl = dd->uas_state->tx_data_list.next;
 674     while (tl != &dd->uas_state->tx_data_list) {
 675             if (tl->tdata->msg->body)
 676                     return PJ_TRUE;
 677             tl = tl->next;
 678     }
 679
 680     return PJ_FALSE;
 681 }
 682
 683
 684 /* Send response reliably */
 685 PJ_DEF(pj_status_t) pjsip_100rel_tx_response(pjsip_inv_session *inv,
 686                                              pjsip_tx_data *tdata)
 687 {
 688     pjsip_cseq_hdr *cseq_hdr;
 689     pjsip_generic_string_hdr *rseq_hdr;
 690     pjsip_require_hdr *req_hdr;
 691     int status_code;
 692     dlg_data *dd;
 693     pjsip_tx_data *old_tdata;
 694     pj_status_t status;
 695
 696     PJ_ASSERT_RETURN(tdata->msg->type == PJSIP_RESPONSE_MSG,
 697                      PJSIP_ENOTRESPONSEMSG);
 698
 699     status_code = tdata->msg->line.status.code;
 700
 701     /* 100 response doesn't need PRACK */
 702     if (status_code == 100)
 703         return pjsip_dlg_send_response(inv->dlg, inv->invite_tsx, tdata);
 704
 705
 706     /* Get the 100rel data attached to this dialog */
 707     dd = (dlg_data*) inv->dlg->mod_data[mod_100rel.mod.id];
 708     PJ_ASSERT_RETURN(dd != NULL, PJ_EINVALIDOP);
 709
 710
 711     /* Clone tdata.
 712      * We need to clone tdata because we may need to keep it in our
 713      * retransmission list, while the original dialog may modify it
 714      * if it wants to send another response.
 715      */
 716     old_tdata = tdata;
 717     tdata = clone_tdata(dd, old_tdata);
 718     pjsip_tx_data_dec_ref(old_tdata);
 719
 720
 721     /* Get CSeq header, and make sure this is INVITE response */
 722     cseq_hdr = (pjsip_cseq_hdr*)
 723                 pjsip_msg_find_hdr(tdata->msg, PJSIP_H_CSEQ, NULL);
 724     PJ_ASSERT_RETURN(cseq_hdr != NULL, PJ_EBUG);
 725     PJ_ASSERT_RETURN(cseq_hdr->method.id == PJSIP_INVITE_METHOD,
 726         PJ_EINVALIDOP);
 727
 728     /* Remove existing Require header */
 729     req_hdr = find_req_hdr(tdata->msg);
 730     if (req_hdr) {
 731         pj_list_erase(req_hdr);
 732     }
 733
 734     /* Remove existing RSeq header */
 735     rseq_hdr = (pjsip_generic_string_hdr*)
 736         pjsip_msg_find_hdr_by_name(tdata->msg, &RSEQ, NULL);
 737     if (rseq_hdr)
 738         pj_list_erase(rseq_hdr);
 739
 740     /* Different treatment for provisional and final response */
 741     if (status_code/100 == 2) {
 742
 743         /* RFC 3262 Section 3: UAS Behavior:
 744
 745           The UAS MAY send a final response to the initial request
 746           before having received PRACKs for all unacknowledged
 747           reliable provisional responses, unless the final response
 748           is 2xx and any of the unacknowledged reliable provisional
 749           responses contained a session description.  In that case,
 750           it MUST NOT send a final response until those provisional
 751           responses are acknowledged.
 752         */
 753
 754         if (dd->uas_state && has_sdp(dd)) {
 755             /* Yes we have transmitted 1xx with SDP reliably.
 756              * In this case, must queue the 2xx response.
 757              */
 758             tx_data_list_t *tl;
 759
 760             tl = PJ_POOL_ZALLOC_T(tdata->pool, tx_data_list_t);
 761             tl->tdata = tdata;
 762             tl->rseq = (pj_uint32_t)-1;
 763             pj_list_push_back(&dd->uas_state->tx_data_list, tl);
 764
 765             /* Will send later */
 766             status = PJ_SUCCESS;
 767
 768             PJ_LOG(4,(dd->inv->dlg->obj_name,
 769                       "2xx response will be sent after PRACK"));
 770
 771         } else if (dd->uas_state) {
 772             /*
 773             RFC 3262 Section 3: UAS Behavior:
 774
 775             If the UAS does send a final response when reliable
 776             responses are still unacknowledged, it SHOULD NOT
 777             continue to retransmit the unacknowledged reliable
 778             provisional responses, but it MUST be prepared to
 779             process PRACK requests for those outstanding
 780             responses.
 781             */
 782
 783             PJ_LOG(4,(dd->inv->dlg->obj_name,
 784                       "No SDP sent so far, sending 2xx now"));
 785
 786             /* Cancel the retransmit timer */
 787             if (dd->uas_state->retransmit_timer.id) {
 788                 pjsip_endpt_cancel_timer(dd->inv->dlg->endpt,
 789                                          &dd->uas_state->retransmit_timer);
 790                 dd->uas_state->retransmit_timer.id = PJ_FALSE;
 791             }
 792
 793             /* Clear all pending responses (drop 'em) */
 794             clear_all_responses(dd);
 795
 796             /* And transmit the 2xx response */
 797             status=pjsip_dlg_send_response(inv->dlg,
 798                                            inv->invite_tsx, tdata);
 799
 800         } else {
 801             /* We didn't send any reliable provisional response */
 802
 803             /* Transmit the 2xx response */
 804             status=pjsip_dlg_send_response(inv->dlg,
 805                                            inv->invite_tsx, tdata);
 806         }
 807
 808     } else if (status_code >= 300) {
 809
 810         /*
 811         RFC 3262 Section 3: UAS Behavior:
 812
 813         If the UAS does send a final response when reliable
 814         responses are still unacknowledged, it SHOULD NOT
 815         continue to retransmit the unacknowledged reliable
 816         provisional responses, but it MUST be prepared to
 817         process PRACK requests for those outstanding
 818         responses.
 819         */
 820
 821         /* Cancel the retransmit timer */
 822         if (dd->uas_state && dd->uas_state->retransmit_timer.id) {
 823             pjsip_endpt_cancel_timer(dd->inv->dlg->endpt,
 824                                      &dd->uas_state->retransmit_timer);
 825             dd->uas_state->retransmit_timer.id = PJ_FALSE;
 826
 827             /* Clear all pending responses (drop 'em) */
 828             clear_all_responses(dd);
 829         }
 830
 831         /* And transmit the 2xx response */
 832         status=pjsip_dlg_send_response(inv->dlg,
 833                                        inv->invite_tsx, tdata);
 834
 835     } else {
 836         /*
 837          * This is provisional response.
 838          */
 839         char rseq_str[32];
 840         pj_str_t rseq;
 841         tx_data_list_t *tl;
 842
 843         /* Create UAS state if we don't have one */
 844         if (dd->uas_state == NULL) {
 845             dd->uas_state = PJ_POOL_ZALLOC_T(inv->dlg->pool,
 846                                              uas_state_t);
 847             dd->uas_state->cseq = cseq_hdr->cseq;
 848             dd->uas_state->rseq = pj_rand() % 0x7FFF;
 849             pj_list_init(&dd->uas_state->tx_data_list);
 850             dd->uas_state->retransmit_timer.user_data = dd;
 851             dd->uas_state->retransmit_timer.cb = &on_retransmit;
 852         }
 853
 854         /* Check that CSeq match */
 855         PJ_ASSERT_RETURN(cseq_hdr->cseq == dd->uas_state->cseq,
 856                          PJ_EINVALIDOP);
 857
 858         /* Add Require header */
 859         req_hdr = pjsip_require_hdr_create(tdata->pool);
 860         req_hdr->count = 1;
 861         req_hdr->values[0] = tag_100rel;
 862         pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)req_hdr);
 863
 864         /* Add RSeq header */
 865         pj_ansi_snprintf(rseq_str, sizeof(rseq_str), "%u",
 866                          dd->uas_state->rseq);
 867         rseq = pj_str(rseq_str);
 868         rseq_hdr = pjsip_generic_string_hdr_create(tdata->pool,
 869                                                    &RSEQ, &rseq);
 870         pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)rseq_hdr);
 871
 872         /* Create list entry for this response */
 873         tl = PJ_POOL_ZALLOC_T(tdata->pool, tx_data_list_t);
 874         tl->tdata = tdata;
 875         tl->rseq = dd->uas_state->rseq++;
 876
 877         /* Add to queue if there's pending response, otherwise
 878          * transmit immediately.
 879          */
 880         if (!pj_list_empty(&dd->uas_state->tx_data_list)) {
 881
 882             int code = tdata->msg->line.status.code;
 883
 884             /* Will send later */
 885             pj_list_push_back(&dd->uas_state->tx_data_list, tl);
 886             status = PJ_SUCCESS;
 887
 888             PJ_LOG(4,(dd->inv->dlg->obj_name,
 889                       "Reliable %d response enqueued (%d pending)",
 890                       code, pj_list_size(&dd->uas_state->tx_data_list)));
 891
 892         } else {
 893             pj_list_push_back(&dd->uas_state->tx_data_list, tl);
 894
 895             dd->uas_state->retransmit_count = 0;
 896             on_retransmit(NULL, &dd->uas_state->retransmit_timer);
 897             status = PJ_SUCCESS;
 898         }
 899
 900     }
 901
 902     return status;
 903 }
 904
 905