← Back to branch summary

~ubuntu-branches/ubuntu/raring/sflphone/raring

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject/pjsip/src/pjsip/sip_util.c

  • Committer: Package Import Robot
  • Author(s): Francois Marier
  • Date: 2011-11-25 13:24:12 UTC
  • mfrom: (4.1.10 sid)
  • Revision ID: package-import@ubuntu.com-20111125132412-dc4qvhyosk74cd42
Tags: 1.0.1-4
http://bugs.debian.org/649726
Don't assume that arch:all packages will get built (closes: #649726)

Show diffs side-by-side

added added

removed removed

Lines of Context:
daemon/libs/pjproject/pjsip/src/pjsip/sip_util.c
 
1
/* $Id: sip_util.c 3553 2011-05-05 06:14:19Z nanang $ */
 
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/sip_util.h>
 
21
#include <pjsip/sip_transport.h>
 
22
#include <pjsip/sip_msg.h>
 
23
#include <pjsip/sip_endpoint.h>
 
24
#include <pjsip/sip_event.h>
 
25
#include <pjsip/sip_transaction.h>
 
26
#include <pjsip/sip_module.h>
 
27
#include <pjsip/sip_errno.h>
 
28
#include <pj/log.h>
 
29
#include <pj/string.h>
 
30
#include <pj/guid.h>
 
31
#include <pj/pool.h>
 
32
#include <pj/except.h>
 
33
#include <pj/rand.h>
 
34
#include <pj/assert.h>
 
35
#include <pj/errno.h>
 
36
 
 
37
#define THIS_FILE    "endpoint"
 
38
 
 
39
static const char *event_str[] = 
 
40
{
 
41
    "UNIDENTIFIED",
 
42
    "TIMER",
 
43
    "TX_MSG",
 
44
    "RX_MSG",
 
45
    "TRANSPORT_ERROR",
 
46
    "TSX_STATE",
 
47
    "USER",
 
48
};
 
49
 
 
50
static pj_str_t str_TEXT = { "text", 4},
 
51
                str_PLAIN = { "plain", 5 };
 
52
 
 
53
/* Add URI to target-set */
 
54
PJ_DEF(pj_status_t) pjsip_target_set_add_uri( pjsip_target_set *tset,
 
55
                                              pj_pool_t *pool,
 
56
                                              const pjsip_uri *uri,
 
57
                                              int q1000)
 
58
{
 
59
    pjsip_target *t, *pos = NULL;
 
60
 
 
61
    PJ_ASSERT_RETURN(tset && pool && uri, PJ_EINVAL);
 
62
 
 
63
    /* Set q-value to 1 if it is not set */
 
64
    if (q1000 <= 0)
 
65
        q1000 = 1000;
 
66
 
 
67
    /* Scan all the elements to see for duplicates, and at the same time
 
68
     * get the position where the new element should be inserted to
 
69
     * based on the q-value.
 
70
     */
 
71
    t = tset->head.next;
 
72
    while (t != &tset->head) {
 
73
        if (pjsip_uri_cmp(PJSIP_URI_IN_REQ_URI, t->uri, uri)==PJ_SUCCESS)
 
74
            return PJ_EEXISTS;
 
75
        if (pos==NULL && t->q1000 < q1000)
 
76
            pos = t;
 
77
        t = t->next;
 
78
    }
 
79
 
 
80
    /* Create new element */
 
81
    t = PJ_POOL_ZALLOC_T(pool, pjsip_target);
 
82
    t->uri = (pjsip_uri*)pjsip_uri_clone(pool, uri);
 
83
    t->q1000 = q1000;
 
84
 
 
85
    /* Insert */
 
86
    if (pos == NULL)
 
87
        pj_list_push_back(&tset->head, t);
 
88
    else
 
89
        pj_list_insert_before(pos, t);
 
90
 
 
91
    /* Set current target if this is the first URI */
 
92
    if (tset->current == NULL)
 
93
        tset->current = t;
 
94
 
 
95
    return PJ_SUCCESS;
 
96
}
 
97
 
 
98
/* Add URI's in the Contact header in the message to target-set */
 
99
PJ_DEF(pj_status_t) pjsip_target_set_add_from_msg( pjsip_target_set *tset,
 
100
                                                   pj_pool_t *pool,
 
101
                                                   const pjsip_msg *msg)
 
102
{
 
103
    const pjsip_hdr *hdr;
 
104
    unsigned added = 0;
 
105
 
 
106
    PJ_ASSERT_RETURN(tset && pool && msg, PJ_EINVAL);
 
107
 
 
108
    /* Scan for Contact headers and add the URI */
 
109
    hdr = msg->hdr.next;
 
110
    while (hdr != &msg->hdr) {
 
111
        if (hdr->type == PJSIP_H_CONTACT) {
 
112
            const pjsip_contact_hdr *cn_hdr = (const pjsip_contact_hdr*)hdr;
 
113
 
 
114
            if (!cn_hdr->star) {
 
115
                pj_status_t rc;
 
116
                rc = pjsip_target_set_add_uri(tset, pool, cn_hdr->uri, 
 
117
                                              cn_hdr->q1000);
 
118
                if (rc == PJ_SUCCESS)
 
119
                    ++added;
 
120
            }
 
121
        }
 
122
        hdr = hdr->next;
 
123
    }
 
124
 
 
125
    return added ? PJ_SUCCESS : PJ_EEXISTS;
 
126
}
 
127
 
 
128
 
 
129
/* Get next target, if any */
 
130
PJ_DEF(pjsip_target*) pjsip_target_set_get_next(const pjsip_target_set *tset)
 
131
{
 
132
    const pjsip_target *t, *next = NULL;
 
133
 
 
134
    t = tset->head.next;
 
135
    while (t != &tset->head) {
 
136
        if (PJSIP_IS_STATUS_IN_CLASS(t->code, 200)) {
 
137
            /* No more target since one target has been successful */
 
138
            return NULL;
 
139
        }
 
140
        if (PJSIP_IS_STATUS_IN_CLASS(t->code, 600)) {
 
141
            /* No more target since one target returned global error */
 
142
            return NULL;
 
143
        }
 
144
        if (t->code==0 && next==NULL) {
 
145
            /* This would be the next target as long as we don't find
 
146
             * targets with 2xx or 6xx status after this.
 
147
             */
 
148
            next = t;
 
149
        }
 
150
        t = t->next;
 
151
    }
 
152
 
 
153
    return (pjsip_target*)next;
 
154
}
 
155
 
 
156
 
 
157
/* Set current target */
 
158
PJ_DEF(pj_status_t) pjsip_target_set_set_current( pjsip_target_set *tset,
 
159
                                                  pjsip_target *target)
 
160
{
 
161
    PJ_ASSERT_RETURN(tset && target, PJ_EINVAL);
 
162
    PJ_ASSERT_RETURN(pj_list_find_node(tset, target) != NULL, PJ_ENOTFOUND);
 
163
 
 
164
    tset->current = target;
 
165
 
 
166
    return PJ_SUCCESS;
 
167
}
 
168
 
 
169
 
 
170
/* Assign status to a target */
 
171
PJ_DEF(pj_status_t) pjsip_target_assign_status( pjsip_target *target,
 
172
                                                pj_pool_t *pool,
 
173
                                                int status_code,
 
174
                                                const pj_str_t *reason)
 
175
{
 
176
    PJ_ASSERT_RETURN(target && pool && status_code && reason, PJ_EINVAL);
 
177
 
 
178
    target->code = (pjsip_status_code)status_code;
 
179
    pj_strdup(pool, &target->reason, reason);
 
180
 
 
181
    return PJ_SUCCESS;
 
182
}
 
183
 
 
184
 
 
185
 
 
186
/*
 
187
 * Initialize transmit data (msg) with the headers and optional body.
 
188
 * This will just put the headers in the message as it is. Be carefull
 
189
 * when calling this function because once a header is put in a message, 
 
190
 * it CAN NOT be put in other message until the first message is deleted, 
 
191
 * because the way the header is put in the list.
 
192
 * That's why the session will shallow_clone it's headers before calling
 
193
 * this function.
 
194
 */
 
195
static void init_request_throw( pjsip_endpoint *endpt,
 
196
                                pjsip_tx_data *tdata, 
 
197
                                pjsip_method *method,
 
198
                                pjsip_uri *param_target,
 
199
                                pjsip_from_hdr *param_from,
 
200
                                pjsip_to_hdr *param_to, 
 
201
                                pjsip_contact_hdr *param_contact,
 
202
                                pjsip_cid_hdr *param_call_id,
 
203
                                pjsip_cseq_hdr *param_cseq, 
 
204
                                const pj_str_t *param_text)
 
205
{
 
206
    pjsip_msg *msg;
 
207
    pjsip_msg_body *body;
 
208
    pjsip_via_hdr *via;
 
209
    const pjsip_hdr *endpt_hdr;
 
210
 
 
211
    /* Create the message. */
 
212
    msg = tdata->msg = pjsip_msg_create(tdata->pool, PJSIP_REQUEST_MSG);
 
213
 
 
214
    /* Init request URI. */
 
215
    pj_memcpy(&msg->line.req.method, method, sizeof(*method));
 
216
    msg->line.req.uri = param_target;
 
217
 
 
218
    /* Add additional request headers from endpoint. */
 
219
    endpt_hdr = pjsip_endpt_get_request_headers(endpt)->next;
 
220
    while (endpt_hdr != pjsip_endpt_get_request_headers(endpt)) {
 
221
        pjsip_hdr *hdr = (pjsip_hdr*) 
 
222
                         pjsip_hdr_shallow_clone(tdata->pool, endpt_hdr);
 
223
        pjsip_msg_add_hdr( tdata->msg, hdr );
 
224
        endpt_hdr = endpt_hdr->next;
 
225
    }
 
226
 
 
227
    /* Add From header. */
 
228
    if (param_from->tag.slen == 0)
 
229
        pj_create_unique_string(tdata->pool, &param_from->tag);
 
230
    pjsip_msg_add_hdr(msg, (pjsip_hdr*)param_from);
 
231
 
 
232
    /* Add To header. */
 
233
    pjsip_msg_add_hdr(msg, (pjsip_hdr*)param_to);
 
234
 
 
235
    /* Add Contact header. */
 
236
    if (param_contact) {
 
237
        pjsip_msg_add_hdr(msg, (pjsip_hdr*)param_contact);
 
238
    }
 
239
 
 
240
    /* Add Call-ID header. */
 
241
    pjsip_msg_add_hdr(msg, (pjsip_hdr*)param_call_id);
 
242
 
 
243
    /* Add CSeq header. */
 
244
    pjsip_msg_add_hdr(msg, (pjsip_hdr*)param_cseq);
 
245
 
 
246
    /* Add a blank Via header in the front of the message. */
 
247
    via = pjsip_via_hdr_create(tdata->pool);
 
248
    via->rport_param = pjsip_cfg()->endpt.disable_rport ? -1 : 0;
 
249
    pjsip_msg_insert_first_hdr(msg, (pjsip_hdr*)via);
 
250
 
 
251
    /* Add header params as request headers */
 
252
    if (PJSIP_URI_SCHEME_IS_SIP(param_target) || 
 
253
        PJSIP_URI_SCHEME_IS_SIPS(param_target)) 
 
254
    {
 
255
        pjsip_sip_uri *uri = (pjsip_sip_uri*) pjsip_uri_get_uri(param_target);
 
256
        pjsip_param *hparam;
 
257
 
 
258
        hparam = uri->header_param.next;
 
259
        while (hparam != &uri->header_param) {
 
260
            pjsip_generic_string_hdr *hdr;
 
261
 
 
262
            hdr = pjsip_generic_string_hdr_create(tdata->pool, 
 
263
                                                  &hparam->name,
 
264
                                                  &hparam->value);
 
265
            pjsip_msg_add_hdr(msg, (pjsip_hdr*)hdr);
 
266
            hparam = hparam->next;
 
267
        }
 
268
    }
 
269
 
 
270
    /* Create message body. */
 
271
    if (param_text) {
 
272
        body = PJ_POOL_ZALLOC_T(tdata->pool, pjsip_msg_body);
 
273
        body->content_type.type = str_TEXT;
 
274
        body->content_type.subtype = str_PLAIN;
 
275
        body->data = pj_pool_alloc(tdata->pool, param_text->slen );
 
276
        pj_memcpy(body->data, param_text->ptr, param_text->slen);
 
277
        body->len = param_text->slen;
 
278
        body->print_body = &pjsip_print_text_body;
 
279
        msg->body = body;
 
280
    }
 
281
 
 
282
    PJ_LOG(5,(THIS_FILE, "%s created.", 
 
283
                         pjsip_tx_data_get_info(tdata)));
 
284
 
 
285
}
 
286
 
 
287
/*
 
288
 * Create arbitrary request.
 
289
 */
 
290
PJ_DEF(pj_status_t) pjsip_endpt_create_request(  pjsip_endpoint *endpt, 
 
291
                                                 const pjsip_method *method,
 
292
                                                 const pj_str_t *param_target,
 
293
                                                 const pj_str_t *param_from,
 
294
                                                 const pj_str_t *param_to, 
 
295
                                                 const pj_str_t *param_contact,
 
296
                                                 const pj_str_t *param_call_id,
 
297
                                                 int param_cseq, 
 
298
                                                 const pj_str_t *param_text,
 
299
                                                 pjsip_tx_data **p_tdata)
 
300
{
 
301
    pjsip_uri *target;
 
302
    pjsip_tx_data *tdata;
 
303
    pjsip_from_hdr *from;
 
304
    pjsip_to_hdr *to;
 
305
    pjsip_contact_hdr *contact;
 
306
    pjsip_cseq_hdr *cseq = NULL;    /* = NULL, warning in VC6 */
 
307
    pjsip_cid_hdr *call_id;
 
308
    pj_str_t tmp;
 
309
    pj_status_t status;
 
310
    const pj_str_t STR_CONTACT = { "Contact", 7 };
 
311
    PJ_USE_EXCEPTION;
 
312
 
 
313
    status = pjsip_endpt_create_tdata(endpt, &tdata);
 
314
    if (status != PJ_SUCCESS)
 
315
        return status;
 
316
 
 
317
    /* Init reference counter to 1. */
 
318
    pjsip_tx_data_add_ref(tdata);
 
319
 
 
320
    PJ_TRY {
 
321
        /* Request target. */
 
322
        pj_strdup_with_null(tdata->pool, &tmp, param_target);
 
323
        target = pjsip_parse_uri( tdata->pool, tmp.ptr, tmp.slen, 0);
 
324
        if (target == NULL) {
 
325
            status = PJSIP_EINVALIDREQURI;
 
326
            goto on_error;
 
327
        }
 
328
 
 
329
        /* From */
 
330
        from = pjsip_from_hdr_create(tdata->pool);
 
331
        pj_strdup_with_null(tdata->pool, &tmp, param_from);
 
332
        from->uri = pjsip_parse_uri( tdata->pool, tmp.ptr, tmp.slen, 
 
333
                                     PJSIP_PARSE_URI_AS_NAMEADDR);
 
334
        if (from->uri == NULL) {
 
335
            status = PJSIP_EINVALIDHDR;
 
336
            goto on_error;
 
337
        }
 
338
        pj_create_unique_string(tdata->pool, &from->tag);
 
339
 
 
340
        /* To */
 
341
        to = pjsip_to_hdr_create(tdata->pool);
 
342
        pj_strdup_with_null(tdata->pool, &tmp, param_to);
 
343
        to->uri = pjsip_parse_uri( tdata->pool, tmp.ptr, tmp.slen, 
 
344
                                   PJSIP_PARSE_URI_AS_NAMEADDR);
 
345
        if (to->uri == NULL) {
 
346
            status = PJSIP_EINVALIDHDR;
 
347
            goto on_error;
 
348
        }
 
349
 
 
350
        /* Contact. */
 
351
        if (param_contact) {
 
352
            pj_strdup_with_null(tdata->pool, &tmp, param_contact);
 
353
            contact = (pjsip_contact_hdr*)
 
354
                      pjsip_parse_hdr(tdata->pool, &STR_CONTACT, tmp.ptr, 
 
355
                                      tmp.slen, NULL);
 
356
            if (contact == NULL) {
 
357
                status = PJSIP_EINVALIDHDR;
 
358
                goto on_error;
 
359
            }
 
360
        } else {
 
361
            contact = NULL;
 
362
        }
 
363
 
 
364
        /* Call-ID */
 
365
        call_id = pjsip_cid_hdr_create(tdata->pool);
 
366
        if (param_call_id != NULL && param_call_id->slen)
 
367
            pj_strdup(tdata->pool, &call_id->id, param_call_id);
 
368
        else
 
369
            pj_create_unique_string(tdata->pool, &call_id->id);
 
370
 
 
371
        /* CSeq */
 
372
        cseq = pjsip_cseq_hdr_create(tdata->pool);
 
373
        if (param_cseq >= 0)
 
374
            cseq->cseq = param_cseq;
 
375
        else
 
376
            cseq->cseq = pj_rand() & 0xFFFF;
 
377
 
 
378
        /* Method */
 
379
        pjsip_method_copy(tdata->pool, &cseq->method, method);
 
380
 
 
381
        /* Create the request. */
 
382
        init_request_throw( endpt, tdata, &cseq->method, target, from, to, 
 
383
                            contact, call_id, cseq, param_text);
 
384
    }
 
385
    PJ_CATCH_ANY {
 
386
        status = PJ_ENOMEM;
 
387
        goto on_error;
 
388
    }
 
389
    PJ_END
 
390
 
 
391
    *p_tdata = tdata;
 
392
    return PJ_SUCCESS;
 
393
 
 
394
on_error:
 
395
    pjsip_tx_data_dec_ref(tdata);
 
396
    return status;
 
397
}
 
398
 
 
399
PJ_DEF(pj_status_t) pjsip_endpt_create_request_from_hdr( pjsip_endpoint *endpt,
 
400
                                     const pjsip_method *method,
 
401
                                     const pjsip_uri *param_target,
 
402
                                     const pjsip_from_hdr *param_from,
 
403
                                     const pjsip_to_hdr *param_to,
 
404
                                     const pjsip_contact_hdr *param_contact,
 
405
                                     const pjsip_cid_hdr *param_call_id,
 
406
                                     int param_cseq,
 
407
                                     const pj_str_t *param_text,
 
408
                                     pjsip_tx_data **p_tdata)
 
409
{
 
410
    pjsip_uri *target;
 
411
    pjsip_tx_data *tdata;
 
412
    pjsip_from_hdr *from;
 
413
    pjsip_to_hdr *to;
 
414
    pjsip_contact_hdr *contact;
 
415
    pjsip_cid_hdr *call_id;
 
416
    pjsip_cseq_hdr *cseq = NULL; /* The NULL because warning in VC6 */
 
417
    pj_status_t status;
 
418
    PJ_USE_EXCEPTION;
 
419
 
 
420
    /* Check arguments. */
 
421
    PJ_ASSERT_RETURN(endpt && method && param_target && param_from &&
 
422
                     param_to && p_tdata, PJ_EINVAL);
 
423
 
 
424
    /* Create new transmit data. */
 
425
    status = pjsip_endpt_create_tdata(endpt, &tdata);
 
426
    if (status != PJ_SUCCESS)
 
427
        return status;
 
428
 
 
429
    /* Set initial reference counter to 1. */
 
430
    pjsip_tx_data_add_ref(tdata);
 
431
 
 
432
    PJ_TRY {
 
433
        /* Duplicate target URI and headers. */
 
434
        target = (pjsip_uri*) pjsip_uri_clone(tdata->pool, param_target);
 
435
        from = (pjsip_from_hdr*) pjsip_hdr_clone(tdata->pool, param_from);
 
436
        pjsip_fromto_hdr_set_from(from);
 
437
        to = (pjsip_to_hdr*) pjsip_hdr_clone(tdata->pool, param_to);
 
438
        pjsip_fromto_hdr_set_to(to);
 
439
        if (param_contact) {
 
440
            contact = (pjsip_contact_hdr*) 
 
441
                      pjsip_hdr_clone(tdata->pool, param_contact);
 
442
        } else {
 
443
            contact = NULL;
 
444
        }
 
445
        call_id = pjsip_cid_hdr_create(tdata->pool);
 
446
        if (param_call_id != NULL && param_call_id->id.slen)
 
447
            pj_strdup(tdata->pool, &call_id->id, &param_call_id->id);
 
448
        else
 
449
            pj_create_unique_string(tdata->pool, &call_id->id);
 
450
 
 
451
        cseq = pjsip_cseq_hdr_create(tdata->pool);
 
452
        if (param_cseq >= 0)
 
453
            cseq->cseq = param_cseq;
 
454
        else
 
455
            cseq->cseq = pj_rand() % 0xFFFF;
 
456
        pjsip_method_copy(tdata->pool, &cseq->method, method);
 
457
 
 
458
        /* Copy headers to the request. */
 
459
        init_request_throw(endpt, tdata, &cseq->method, target, from, to, 
 
460
                           contact, call_id, cseq, param_text);
 
461
    }
 
462
    PJ_CATCH_ANY {
 
463
        status = PJ_ENOMEM;
 
464
        goto on_error;
 
465
    }
 
466
    PJ_END;
 
467
 
 
468
    *p_tdata = tdata;
 
469
    return PJ_SUCCESS;
 
470
 
 
471
on_error:
 
472
    pjsip_tx_data_dec_ref(tdata);
 
473
    return status;
 
474
}
 
475
 
 
476
/*
 
477
 * Construct a minimal response message for the received request.
 
478
 */
 
479
PJ_DEF(pj_status_t) pjsip_endpt_create_response( pjsip_endpoint *endpt,
 
480
                                                 const pjsip_rx_data *rdata,
 
481
                                                 int st_code,
 
482
                                                 const pj_str_t *st_text,
 
483
                                                 pjsip_tx_data **p_tdata)
 
484
{
 
485
    pjsip_tx_data *tdata;
 
486
    pjsip_msg *msg, *req_msg;
 
487
    pjsip_hdr *hdr;
 
488
    pjsip_to_hdr *to_hdr;
 
489
    pjsip_via_hdr *top_via = NULL, *via;
 
490
    pjsip_rr_hdr *rr;
 
491
    pj_status_t status;
 
492
 
 
493
    /* Check arguments. */
 
494
    PJ_ASSERT_RETURN(endpt && rdata && p_tdata, PJ_EINVAL);
 
495
 
 
496
    /* Check status code. */
 
497
    PJ_ASSERT_RETURN(st_code >= 100 && st_code <= 699, PJ_EINVAL);
 
498
 
 
499
    /* rdata must be a request message. */
 
500
    req_msg = rdata->msg_info.msg;
 
501
    pj_assert(req_msg->type == PJSIP_REQUEST_MSG);
 
502
 
 
503
    /* Request MUST NOT be ACK request! */
 
504
    PJ_ASSERT_RETURN(req_msg->line.req.method.id != PJSIP_ACK_METHOD,
 
505
                     PJ_EINVALIDOP);
 
506
 
 
507
    /* Create a new transmit buffer. */
 
508
    status = pjsip_endpt_create_tdata( endpt, &tdata);
 
509
    if (status != PJ_SUCCESS)
 
510
        return status;
 
511
 
 
512
    /* Set initial reference count to 1. */
 
513
    pjsip_tx_data_add_ref(tdata);
 
514
 
 
515
    /* Create new response message. */
 
516
    tdata->msg = msg = pjsip_msg_create(tdata->pool, PJSIP_RESPONSE_MSG);
 
517
 
 
518
    /* Set status code and reason text. */
 
519
    msg->line.status.code = st_code;
 
520
    if (st_text)
 
521
        pj_strdup(tdata->pool, &msg->line.status.reason, st_text);
 
522
    else
 
523
        msg->line.status.reason = *pjsip_get_status_text(st_code);
 
524
 
 
525
    /* Set TX data attributes. */
 
526
    tdata->rx_timestamp = rdata->pkt_info.timestamp;
 
527
 
 
528
    /* Copy all the via headers, in order. */
 
529
    via = rdata->msg_info.via;
 
530
    while (via) {
 
531
        pjsip_via_hdr *new_via;
 
532
 
 
533
        new_via = (pjsip_via_hdr*)pjsip_hdr_clone(tdata->pool, via);
 
534
        if (top_via == NULL)
 
535
            top_via = new_via;
 
536
 
 
537
        pjsip_msg_add_hdr( msg, (pjsip_hdr*)new_via);
 
538
        via = via->next;
 
539
        if (via != (void*)&req_msg->hdr)
 
540
            via = (pjsip_via_hdr*) 
 
541
                  pjsip_msg_find_hdr(req_msg, PJSIP_H_VIA, via);
 
542
        else
 
543
            break;
 
544
    }
 
545
 
 
546
    /* Copy all Record-Route headers, in order. */
 
547
    rr = (pjsip_rr_hdr*) 
 
548
         pjsip_msg_find_hdr(req_msg, PJSIP_H_RECORD_ROUTE, NULL);
 
549
    while (rr) {
 
550
        pjsip_msg_add_hdr(msg, (pjsip_hdr*) pjsip_hdr_clone(tdata->pool, rr));
 
551
        rr = rr->next;
 
552
        if (rr != (void*)&req_msg->hdr)
 
553
            rr = (pjsip_rr_hdr*) pjsip_msg_find_hdr(req_msg, 
 
554
                                                    PJSIP_H_RECORD_ROUTE, rr);
 
555
        else
 
556
            break;
 
557
    }
 
558
 
 
559
    /* Copy Call-ID header. */
 
560
    hdr = (pjsip_hdr*) pjsip_msg_find_hdr( req_msg, PJSIP_H_CALL_ID, NULL);
 
561
    pjsip_msg_add_hdr(msg, (pjsip_hdr*) pjsip_hdr_clone(tdata->pool, hdr));
 
562
 
 
563
    /* Copy From header. */
 
564
    hdr = (pjsip_hdr*) pjsip_hdr_clone(tdata->pool, rdata->msg_info.from);
 
565
    pjsip_msg_add_hdr( msg, hdr);
 
566
 
 
567
    /* Copy To header. */
 
568
    to_hdr = (pjsip_to_hdr*) pjsip_hdr_clone(tdata->pool, rdata->msg_info.to);
 
569
    pjsip_msg_add_hdr( msg, (pjsip_hdr*)to_hdr);
 
570
 
 
571
    /* Must add To tag in the response (Section 8.2.6.2), except if this is
 
572
     * 100 (Trying) response. Same tag must be created for the same request
 
573
     * (e.g. same tag in provisional and final response). The easiest way
 
574
     * to do this is to derive the tag from Via branch parameter (or to
 
575
     * use it directly).
 
576
     */
 
577
    if (to_hdr->tag.slen==0 && st_code > 100 && top_via) {
 
578
        to_hdr->tag = top_via->branch_param;
 
579
    }
 
580
 
 
581
    /* Copy CSeq header. */
 
582
    hdr = (pjsip_hdr*) pjsip_hdr_clone(tdata->pool, rdata->msg_info.cseq);
 
583
    pjsip_msg_add_hdr( msg, hdr);
 
584
 
 
585
    /* All done. */
 
586
    *p_tdata = tdata;
 
587
 
 
588
    PJ_LOG(5,(THIS_FILE, "%s created", pjsip_tx_data_get_info(tdata)));
 
589
    return PJ_SUCCESS;
 
590
}
 
591
 
 
592
 
 
593
/*
 
594
 * Construct ACK for 3xx-6xx final response (according to chapter 17.1.1 of
 
595
 * RFC3261). Note that the generation of ACK for 2xx response is different,
 
596
 * and one must not use this function to generate such ACK.
 
597
 */
 
598
PJ_DEF(pj_status_t) pjsip_endpt_create_ack( pjsip_endpoint *endpt,
 
599
                                            const pjsip_tx_data *tdata,
 
600
                                            const pjsip_rx_data *rdata,
 
601
                                            pjsip_tx_data **ack_tdata)
 
602
{
 
603
    pjsip_tx_data *ack = NULL;
 
604
    const pjsip_msg *invite_msg;
 
605
    const pjsip_from_hdr *from_hdr;
 
606
    const pjsip_to_hdr *to_hdr;
 
607
    const pjsip_cid_hdr *cid_hdr;
 
608
    const pjsip_cseq_hdr *cseq_hdr;
 
609
    const pjsip_hdr *hdr;
 
610
    pjsip_hdr *via;
 
611
    pjsip_to_hdr *to;
 
612
    pj_status_t status;
 
613
 
 
614
    /* rdata must be a non-2xx final response. */
 
615
    pj_assert(rdata->msg_info.msg->type==PJSIP_RESPONSE_MSG &&
 
616
              rdata->msg_info.msg->line.status.code >= 300);
 
617
 
 
618
    /* Initialize return value to NULL. */
 
619
    *ack_tdata = NULL;
 
620
 
 
621
    /* The original INVITE message. */
 
622
    invite_msg = tdata->msg;
 
623
 
 
624
    /* Get the headers from original INVITE request. */
 
625
#   define FIND_HDR(m,HNAME) pjsip_msg_find_hdr(m, PJSIP_H_##HNAME, NULL)
 
626
 
 
627
    from_hdr = (const pjsip_from_hdr*) FIND_HDR(invite_msg, FROM);
 
628
    PJ_ASSERT_ON_FAIL(from_hdr != NULL, goto on_missing_hdr);
 
629
 
 
630
    to_hdr = (const pjsip_to_hdr*) FIND_HDR(invite_msg, TO);
 
631
    PJ_ASSERT_ON_FAIL(to_hdr != NULL, goto on_missing_hdr);
 
632
 
 
633
    cid_hdr = (const pjsip_cid_hdr*) FIND_HDR(invite_msg, CALL_ID);
 
634
    PJ_ASSERT_ON_FAIL(to_hdr != NULL, goto on_missing_hdr);
 
635
 
 
636
    cseq_hdr = (const pjsip_cseq_hdr*) FIND_HDR(invite_msg, CSEQ);
 
637
    PJ_ASSERT_ON_FAIL(to_hdr != NULL, goto on_missing_hdr);
 
638
 
 
639
#   undef FIND_HDR
 
640
 
 
641
    /* Create new request message from the headers. */
 
642
    status = pjsip_endpt_create_request_from_hdr(endpt, 
 
643
                                                 pjsip_get_ack_method(),
 
644
                                                 tdata->msg->line.req.uri,
 
645
                                                 from_hdr, to_hdr,
 
646
                                                 NULL, cid_hdr,
 
647
                                                 cseq_hdr->cseq, NULL,
 
648
                                                 &ack);
 
649
 
 
650
    if (status != PJ_SUCCESS)
 
651
        return status;
 
652
 
 
653
    /* Update tag in To header with the one from the response (if any). */
 
654
    to = (pjsip_to_hdr*) pjsip_msg_find_hdr(ack->msg, PJSIP_H_TO, NULL);
 
655
    pj_strdup(ack->pool, &to->tag, &rdata->msg_info.to->tag);
 
656
 
 
657
 
 
658
    /* Clear Via headers in the new request. */
 
659
    while ((via=(pjsip_hdr*)pjsip_msg_find_hdr(ack->msg, PJSIP_H_VIA, NULL)) != NULL)
 
660
        pj_list_erase(via);
 
661
 
 
662
    /* Must contain single Via, just as the original INVITE. */
 
663
    hdr = (pjsip_hdr*) pjsip_msg_find_hdr( invite_msg, PJSIP_H_VIA, NULL);
 
664
    pjsip_msg_insert_first_hdr( ack->msg, 
 
665
                                (pjsip_hdr*) pjsip_hdr_clone(ack->pool,hdr) );
 
666
 
 
667
    /* If the original INVITE has Route headers, those header fields MUST 
 
668
     * appear in the ACK.
 
669
     */
 
670
    hdr = (pjsip_hdr*) pjsip_msg_find_hdr( invite_msg, PJSIP_H_ROUTE, NULL);
 
671
    while (hdr != NULL) {
 
672
        pjsip_msg_add_hdr( ack->msg, 
 
673
                           (pjsip_hdr*) pjsip_hdr_clone(ack->pool, hdr) );
 
674
        hdr = hdr->next;
 
675
        if (hdr == &invite_msg->hdr)
 
676
            break;
 
677
        hdr = (pjsip_hdr*) pjsip_msg_find_hdr( invite_msg, PJSIP_H_ROUTE, hdr);
 
678
    }
 
679
 
 
680
    /* We're done.
 
681
     * "tdata" parameter now contains the ACK message.
 
682
     */
 
683
    *ack_tdata = ack;
 
684
    return PJ_SUCCESS;
 
685
 
 
686
on_missing_hdr:
 
687
    if (ack)
 
688
        pjsip_tx_data_dec_ref(ack);
 
689
    return PJSIP_EMISSINGHDR;
 
690
}
 
691
 
 
692
 
 
693
/*
 
694
 * Construct CANCEL request for the previously sent request, according to
 
695
 * chapter 9.1 of RFC3261.
 
696
 */
 
697
PJ_DEF(pj_status_t) pjsip_endpt_create_cancel( pjsip_endpoint *endpt,
 
698
                                               const pjsip_tx_data *req_tdata,
 
699
                                               pjsip_tx_data **p_tdata)
 
700
{
 
701
    pjsip_tx_data *cancel_tdata = NULL;
 
702
    const pjsip_from_hdr *from_hdr;
 
703
    const pjsip_to_hdr *to_hdr;
 
704
    const pjsip_cid_hdr *cid_hdr;
 
705
    const pjsip_cseq_hdr *cseq_hdr;
 
706
    const pjsip_hdr *hdr;
 
707
    pjsip_hdr *via;
 
708
    pj_status_t status;
 
709
 
 
710
    /* The transmit buffer must INVITE request. */
 
711
    PJ_ASSERT_RETURN(req_tdata->msg->type == PJSIP_REQUEST_MSG &&
 
712
                     req_tdata->msg->line.req.method.id == PJSIP_INVITE_METHOD,
 
713
                     PJ_EINVAL);
 
714
 
 
715
    /* Get the headers from original INVITE request. */
 
716
#   define FIND_HDR(m,HNAME) pjsip_msg_find_hdr(m, PJSIP_H_##HNAME, NULL)
 
717
 
 
718
    from_hdr = (const pjsip_from_hdr*) FIND_HDR(req_tdata->msg, FROM);
 
719
    PJ_ASSERT_ON_FAIL(from_hdr != NULL, goto on_missing_hdr);
 
720
 
 
721
    to_hdr = (const pjsip_to_hdr*) FIND_HDR(req_tdata->msg, TO);
 
722
    PJ_ASSERT_ON_FAIL(to_hdr != NULL, goto on_missing_hdr);
 
723
 
 
724
    cid_hdr = (const pjsip_cid_hdr*) FIND_HDR(req_tdata->msg, CALL_ID);
 
725
    PJ_ASSERT_ON_FAIL(to_hdr != NULL, goto on_missing_hdr);
 
726
 
 
727
    cseq_hdr = (const pjsip_cseq_hdr*) FIND_HDR(req_tdata->msg, CSEQ);
 
728
    PJ_ASSERT_ON_FAIL(to_hdr != NULL, goto on_missing_hdr);
 
729
 
 
730
#   undef FIND_HDR
 
731
 
 
732
    /* Create new request message from the headers. */
 
733
    status = pjsip_endpt_create_request_from_hdr(endpt, 
 
734
                                                 pjsip_get_cancel_method(),
 
735
                                                 req_tdata->msg->line.req.uri,
 
736
                                                 from_hdr, to_hdr,
 
737
                                                 NULL, cid_hdr,
 
738
                                                 cseq_hdr->cseq, NULL,
 
739
                                                 &cancel_tdata);
 
740
 
 
741
    if (status != PJ_SUCCESS)
 
742
        return status;
 
743
 
 
744
    /* Clear Via headers in the new request. */
 
745
    while ((via=(pjsip_hdr*)pjsip_msg_find_hdr(cancel_tdata->msg, PJSIP_H_VIA, NULL)) != NULL)
 
746
        pj_list_erase(via);
 
747
 
 
748
 
 
749
    /* Must only have single Via which matches the top-most Via in the 
 
750
     * request being cancelled. 
 
751
     */
 
752
    hdr = (pjsip_hdr*) pjsip_msg_find_hdr(req_tdata->msg, PJSIP_H_VIA, NULL);
 
753
    if (hdr) {
 
754
        pjsip_msg_insert_first_hdr(cancel_tdata->msg, 
 
755
                                   (pjsip_hdr*)pjsip_hdr_clone(cancel_tdata->pool, hdr));
 
756
    }
 
757
 
 
758
    /* If the original request has Route header, the CANCEL request must also
 
759
     * has exactly the same.
 
760
     * Copy "Route" header from the request.
 
761
     */
 
762
    hdr = (pjsip_hdr*) pjsip_msg_find_hdr(req_tdata->msg, PJSIP_H_ROUTE, NULL);
 
763
    while (hdr != NULL) {
 
764
        pjsip_msg_add_hdr(cancel_tdata->msg, 
 
765
                          (pjsip_hdr*) pjsip_hdr_clone(cancel_tdata->pool, hdr));
 
766
        hdr = hdr->next;
 
767
        if (hdr != &req_tdata->msg->hdr)
 
768
            hdr = (pjsip_hdr*) pjsip_msg_find_hdr(req_tdata->msg, 
 
769
                                                  PJSIP_H_ROUTE, hdr);
 
770
        else
 
771
            break;
 
772
    }
 
773
 
 
774
    /* Must also copy the saved strict route header, otherwise CANCEL will be
 
775
     * sent with swapped Route and request URI!
 
776
     */
 
777
    if (req_tdata->saved_strict_route) {
 
778
        cancel_tdata->saved_strict_route = (pjsip_route_hdr*)
 
779
            pjsip_hdr_clone(cancel_tdata->pool, req_tdata->saved_strict_route);
 
780
    }
 
781
 
 
782
    /* Copy the destination host name from the original request */
 
783
    pj_strdup(cancel_tdata->pool, &cancel_tdata->dest_info.name,
 
784
              &req_tdata->dest_info.name);
 
785
 
 
786
    /* Finally copy the destination info from the original request */
 
787
    pj_memcpy(&cancel_tdata->dest_info, &req_tdata->dest_info,
 
788
              sizeof(req_tdata->dest_info));
 
789
 
 
790
    /* Done.
 
791
     * Return the transmit buffer containing the CANCEL request.
 
792
     */
 
793
    *p_tdata = cancel_tdata;
 
794
    return PJ_SUCCESS;
 
795
 
 
796
on_missing_hdr:
 
797
    if (cancel_tdata)
 
798
        pjsip_tx_data_dec_ref(cancel_tdata);
 
799
    return PJSIP_EMISSINGHDR;
 
800
}
 
801
 
 
802
 
 
803
/* Fill-up destination information from a target URI */
 
804
static pj_status_t get_dest_info(const pjsip_uri *target_uri, 
 
805
                                 pj_pool_t *pool,
 
806
                                 pjsip_host_info *dest_info)
 
807
{
 
808
    /* The target URI must be a SIP/SIPS URL so we can resolve it's address.
 
809
     * Otherwise we're in trouble (i.e. there's no host part in tel: URL).
 
810
     */
 
811
    pj_bzero(dest_info, sizeof(*dest_info));
 
812
 
 
813
    if (PJSIP_URI_SCHEME_IS_SIPS(target_uri)) {
 
814
        pjsip_uri *uri = (pjsip_uri*) target_uri;
 
815
        const pjsip_sip_uri *url=(const pjsip_sip_uri*)pjsip_uri_get_uri(uri);
 
816
        dest_info->flag |= (PJSIP_TRANSPORT_SECURE | PJSIP_TRANSPORT_RELIABLE);
 
817
        if (url->maddr_param.slen)
 
818
            pj_strdup(pool, &dest_info->addr.host, &url->maddr_param);
 
819
        else
 
820
            pj_strdup(pool, &dest_info->addr.host, &url->host);
 
821
        dest_info->addr.port = url->port;
 
822
        dest_info->type = 
 
823
            pjsip_transport_get_type_from_name(&url->transport_param);
 
824
 
 
825
    } else if (PJSIP_URI_SCHEME_IS_SIP(target_uri)) {
 
826
        pjsip_uri *uri = (pjsip_uri*) target_uri;
 
827
        const pjsip_sip_uri *url=(const pjsip_sip_uri*)pjsip_uri_get_uri(uri);
 
828
        if (url->maddr_param.slen)
 
829
            pj_strdup(pool, &dest_info->addr.host, &url->maddr_param);
 
830
        else
 
831
            pj_strdup(pool, &dest_info->addr.host, &url->host);
 
832
        dest_info->addr.port = url->port;
 
833
        dest_info->type = 
 
834
            pjsip_transport_get_type_from_name(&url->transport_param);
 
835
        dest_info->flag = 
 
836
            pjsip_transport_get_flag_from_type(dest_info->type);
 
837
    } else {
 
838
        /* Should have never reached here; app should have configured route
 
839
         * set when sending to tel: URI
 
840
        pj_assert(!"Unsupported URI scheme!");
 
841
         */
 
842
        PJ_TODO(SUPPORT_REQUEST_ADDR_RESOLUTION_FOR_TEL_URI);
 
843
        return PJSIP_ENOROUTESET;
 
844
    }
 
845
 
 
846
    /* Handle IPv6 (http://trac.pjsip.org/repos/ticket/861) */
 
847
    if (dest_info->type != PJSIP_TRANSPORT_UNSPECIFIED && 
 
848
        pj_strchr(&dest_info->addr.host, ':'))
 
849
    {
 
850
        dest_info->type = (pjsip_transport_type_e)
 
851
                          ((int)dest_info->type | PJSIP_TRANSPORT_IPV6);
 
852
    }
 
853
 
 
854
    return PJ_SUCCESS;
 
855
}
 
856
 
 
857
 
 
858
/*
 
859
 * Find which destination to be used to send the request message, based
 
860
 * on the request URI and Route headers in the message. The procedure
 
861
 * used here follows the guidelines on sending the request in RFC 3261
 
862
 * chapter 8.1.2.
 
863
 */
 
864
PJ_DEF(pj_status_t) pjsip_get_request_dest(const pjsip_tx_data *tdata,
 
865
                                           pjsip_host_info *dest_info )
 
866
{
 
867
    const pjsip_uri *target_uri;
 
868
    const pjsip_route_hdr *first_route_hdr;
 
869
    
 
870
    PJ_ASSERT_RETURN(tdata->msg->type == PJSIP_REQUEST_MSG, 
 
871
                     PJSIP_ENOTREQUESTMSG);
 
872
    PJ_ASSERT_RETURN(dest_info != NULL, PJ_EINVAL);
 
873
 
 
874
    /* Get the first "Route" header from the message.
 
875
     */
 
876
    first_route_hdr = (const pjsip_route_hdr*) 
 
877
                      pjsip_msg_find_hdr(tdata->msg, PJSIP_H_ROUTE, NULL);
 
878
    if (first_route_hdr) {
 
879
        target_uri = first_route_hdr->name_addr.uri;
 
880
    } else {
 
881
        target_uri = tdata->msg->line.req.uri;
 
882
    }
 
883
 
 
884
    return get_dest_info(target_uri, (pj_pool_t*)tdata->pool, dest_info);
 
885
}
 
886
 
 
887
 
 
888
/*
 
889
 * Process route-set found in the request and calculate
 
890
 * the destination to be used to send the request message, based
 
891
 * on the request URI and Route headers in the message. The procedure
 
892
 * used here follows the guidelines on sending the request in RFC 3261
 
893
 * chapter 8.1.2.
 
894
 */
 
895
PJ_DEF(pj_status_t) pjsip_process_route_set(pjsip_tx_data *tdata,
 
896
                                            pjsip_host_info *dest_info )
 
897
{
 
898
    const pjsip_uri *new_request_uri, *target_uri;
 
899
    const pjsip_name_addr *topmost_route_uri;
 
900
    pjsip_route_hdr *first_route_hdr, *last_route_hdr;
 
901
    pj_status_t status;
 
902
    
 
903
    PJ_ASSERT_RETURN(tdata->msg->type == PJSIP_REQUEST_MSG, 
 
904
                     PJSIP_ENOTREQUESTMSG);
 
905
    PJ_ASSERT_RETURN(dest_info != NULL, PJ_EINVAL);
 
906
 
 
907
    /* If the request contains strict route, check that the strict route
 
908
     * has been restored to its original values before processing the
 
909
     * route set. The strict route is restored to the original values
 
910
     * with pjsip_restore_strict_route_set(). If caller did not restore
 
911
     * the strict route before calling this function, we need to call it
 
912
     * here, or otherwise the strict-route and Request-URI will be swapped
 
913
     * twice!
 
914
     */
 
915
    if (tdata->saved_strict_route != NULL) {
 
916
        pjsip_restore_strict_route_set(tdata);
 
917
    }
 
918
    PJ_ASSERT_RETURN(tdata->saved_strict_route==NULL, PJ_EBUG);
 
919
 
 
920
    /* Find the first and last "Route" headers from the message. */
 
921
    last_route_hdr = first_route_hdr = (pjsip_route_hdr*)
 
922
        pjsip_msg_find_hdr(tdata->msg, PJSIP_H_ROUTE, NULL);
 
923
    if (first_route_hdr) {
 
924
        topmost_route_uri = &first_route_hdr->name_addr;
 
925
        while (last_route_hdr->next != (void*)&tdata->msg->hdr) {
 
926
            pjsip_route_hdr *hdr;
 
927
            hdr = (pjsip_route_hdr*)
 
928
                  pjsip_msg_find_hdr(tdata->msg, PJSIP_H_ROUTE, 
 
929
                                     last_route_hdr->next);
 
930
            if (!hdr)
 
931
                break;
 
932
            last_route_hdr = hdr;
 
933
        }
 
934
    } else {
 
935
        topmost_route_uri = NULL;
 
936
    }
 
937
 
 
938
    /* If Route headers exist, and the first element indicates loose-route,
 
939
     * the URI is taken from the Request-URI, and we keep all existing Route
 
940
     * headers intact.
 
941
     * If Route headers exist, and the first element DOESN'T indicate loose
 
942
     * route, the URI is taken from the first Route header, and remove the
 
943
     * first Route header from the message.
 
944
     * Otherwise if there's no Route headers, the URI is taken from the
 
945
     * Request-URI.
 
946
     */
 
947
    if (topmost_route_uri) {
 
948
        pj_bool_t has_lr_param;
 
949
 
 
950
        if (PJSIP_URI_SCHEME_IS_SIP(topmost_route_uri) ||
 
951
            PJSIP_URI_SCHEME_IS_SIPS(topmost_route_uri))
 
952
        {
 
953
            const pjsip_sip_uri *url = (const pjsip_sip_uri*)
 
954
                pjsip_uri_get_uri((const void*)topmost_route_uri);
 
955
            has_lr_param = url->lr_param;
 
956
        } else {
 
957
            has_lr_param = 0;
 
958
        }
 
959
 
 
960
        if (has_lr_param) {
 
961
            new_request_uri = tdata->msg->line.req.uri;
 
962
            /* We shouldn't need to delete topmost Route if it has lr param.
 
963
             * But seems like it breaks some proxy implementation, so we
 
964
             * delete it anyway.
 
965
             */
 
966
            /*
 
967
            pj_list_erase(first_route_hdr);
 
968
            if (first_route_hdr == last_route_hdr)
 
969
                last_route_hdr = NULL;
 
970
            */
 
971
        } else {
 
972
            new_request_uri = (const pjsip_uri*) 
 
973
                              pjsip_uri_get_uri((pjsip_uri*)topmost_route_uri);
 
974
            pj_list_erase(first_route_hdr);
 
975
            tdata->saved_strict_route = first_route_hdr;
 
976
            if (first_route_hdr == last_route_hdr)
 
977
                first_route_hdr = last_route_hdr = NULL;
 
978
        }
 
979
 
 
980
        target_uri = (pjsip_uri*)topmost_route_uri;
 
981
 
 
982
    } else {
 
983
        target_uri = new_request_uri = tdata->msg->line.req.uri;
 
984
    }
 
985
 
 
986
    /* Fill up the destination host/port from the URI. */
 
987
    status = get_dest_info(target_uri, tdata->pool, dest_info);
 
988
    if (status != PJ_SUCCESS)
 
989
        return status;
 
990
 
 
991
    /* If target URI is different than request URI, replace 
 
992
     * request URI add put the original URI in the last Route header.
 
993
     */
 
994
    if (new_request_uri && new_request_uri!=tdata->msg->line.req.uri) {
 
995
        pjsip_route_hdr *route = pjsip_route_hdr_create(tdata->pool);
 
996
        route->name_addr.uri = (pjsip_uri*) 
 
997
                               pjsip_uri_get_uri(tdata->msg->line.req.uri);
 
998
        if (last_route_hdr)
 
999
            pj_list_insert_after(last_route_hdr, route);
 
1000
        else
 
1001
            pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)route);
 
1002
        tdata->msg->line.req.uri = (pjsip_uri*)new_request_uri;
 
1003
    }
 
1004
 
 
1005
    /* Success. */
 
1006
    return PJ_SUCCESS;  
 
1007
}
 
1008
 
 
1009
 
 
1010
/*
 
1011
 * Swap the request URI and strict route back to the original position
 
1012
 * before #pjsip_process_route_set() function is called. This function
 
1013
 * should only used internally by PJSIP client authentication module.
 
1014
 */
 
1015
PJ_DEF(void) pjsip_restore_strict_route_set(pjsip_tx_data *tdata)
 
1016
{
 
1017
    pjsip_route_hdr *first_route_hdr, *last_route_hdr;
 
1018
 
 
1019
    /* Check if we have found strict route before */
 
1020
    if (tdata->saved_strict_route == NULL) {
 
1021
        /* This request doesn't contain strict route */
 
1022
        return;
 
1023
    }
 
1024
 
 
1025
    /* Find the first "Route" headers from the message. */
 
1026
    first_route_hdr = (pjsip_route_hdr*)
 
1027
                      pjsip_msg_find_hdr(tdata->msg, PJSIP_H_ROUTE, NULL);
 
1028
 
 
1029
    if (first_route_hdr == NULL) {
 
1030
        /* User has modified message route? We don't expect this! */
 
1031
        pj_assert(!"Message route was modified?");
 
1032
        tdata->saved_strict_route = NULL;
 
1033
        return;
 
1034
    }
 
1035
 
 
1036
    /* Find last Route header */
 
1037
    last_route_hdr = first_route_hdr;
 
1038
    while (last_route_hdr->next != (void*)&tdata->msg->hdr) {
 
1039
        pjsip_route_hdr *hdr;
 
1040
        hdr = (pjsip_route_hdr*)
 
1041
              pjsip_msg_find_hdr(tdata->msg, PJSIP_H_ROUTE, 
 
1042
                                 last_route_hdr->next);
 
1043
        if (!hdr)
 
1044
            break;
 
1045
        last_route_hdr = hdr;
 
1046
    }
 
1047
 
 
1048
    /* Put the last Route header as request URI, delete last Route
 
1049
     * header, and insert the saved strict route as the first Route.
 
1050
     */
 
1051
    tdata->msg->line.req.uri = last_route_hdr->name_addr.uri;
 
1052
    pj_list_insert_before(first_route_hdr, tdata->saved_strict_route);
 
1053
    pj_list_erase(last_route_hdr);
 
1054
 
 
1055
    /* Reset */
 
1056
    tdata->saved_strict_route = NULL;
 
1057
}
 
1058
 
 
1059
 
 
1060
/* Transport callback for sending stateless request. 
 
1061
 * This is one of the most bizzare function in pjsip, so
 
1062
 * good luck if you happen to debug this function!!
 
1063
 */
 
1064
static void stateless_send_transport_cb( void *token,
 
1065
                                         pjsip_tx_data *tdata,
 
1066
                                         pj_ssize_t sent )
 
1067
{
 
1068
    pjsip_send_state *stateless_data = (pjsip_send_state*) token;
 
1069
 
 
1070
    PJ_UNUSED_ARG(tdata);
 
1071
    pj_assert(tdata == stateless_data->tdata);
 
1072
 
 
1073
    for (;;) {
 
1074
        pj_status_t status;
 
1075
        pj_bool_t cont;
 
1076
 
 
1077
        pj_sockaddr_t *cur_addr;
 
1078
        pjsip_transport_type_e cur_addr_type;
 
1079
        int cur_addr_len;
 
1080
 
 
1081
        pjsip_via_hdr *via;
 
1082
 
 
1083
        if (sent == -PJ_EPENDING) {
 
1084
            /* This is the initial process.
 
1085
             * When the process started, this function will be called by
 
1086
             * stateless_send_resolver_callback() with sent argument set to
 
1087
             * -PJ_EPENDING.
 
1088
             */
 
1089
            cont = PJ_TRUE;
 
1090
        } else {
 
1091
            /* There are two conditions here:
 
1092
             * (1) Message is sent (i.e. sent > 0),
 
1093
             * (2) Failure (i.e. sent <= 0)
 
1094
             */
 
1095
            cont = (sent > 0) ? PJ_FALSE :
 
1096
                   (tdata->dest_info.cur_addr<tdata->dest_info.addr.count-1);
 
1097
            if (stateless_data->app_cb) {
 
1098
                (*stateless_data->app_cb)(stateless_data, sent, &cont);
 
1099
            } else {
 
1100
                /* Doesn't have application callback.
 
1101
                 * Terminate the process.
 
1102
                 */
 
1103
                cont = PJ_FALSE;
 
1104
            }
 
1105
        }
 
1106
 
 
1107
        /* Finished with this transport. */
 
1108
        if (stateless_data->cur_transport) {
 
1109
            pjsip_transport_dec_ref(stateless_data->cur_transport);
 
1110
            stateless_data->cur_transport = NULL;
 
1111
        }
 
1112
 
 
1113
        /* Done if application doesn't want to continue. */
 
1114
        if (sent > 0 || !cont) {
 
1115
            pjsip_tx_data_dec_ref(tdata);
 
1116
            return;
 
1117
        }
 
1118
 
 
1119
        /* Try next address, if any, and only when this is not the 
 
1120
         * first invocation. 
 
1121
         */
 
1122
        if (sent != -PJ_EPENDING) {
 
1123
            tdata->dest_info.cur_addr++;
 
1124
        }
 
1125
 
 
1126
        /* Have next address? */
 
1127
        if (tdata->dest_info.cur_addr >= tdata->dest_info.addr.count) {
 
1128
            /* This only happens when a rather buggy application has
 
1129
             * sent 'cont' to PJ_TRUE when the initial value was PJ_FALSE.
 
1130
             * In this case just stop the processing; we don't need to
 
1131
             * call the callback again as application has been informed
 
1132
             * before.
 
1133
             */
 
1134
            pjsip_tx_data_dec_ref(tdata);
 
1135
            return;
 
1136
        }
 
1137
 
 
1138
        /* Keep current server address information handy. */
 
1139
        cur_addr = &tdata->dest_info.addr.entry[tdata->dest_info.cur_addr].addr;
 
1140
        cur_addr_type = tdata->dest_info.addr.entry[tdata->dest_info.cur_addr].type;
 
1141
        cur_addr_len = tdata->dest_info.addr.entry[tdata->dest_info.cur_addr].addr_len;
 
1142
 
 
1143
        /* Acquire transport. */
 
1144
        status = pjsip_endpt_acquire_transport2(stateless_data->endpt,
 
1145
                                                cur_addr_type,
 
1146
                                                cur_addr,
 
1147
                                                cur_addr_len,
 
1148
                                                &tdata->tp_sel,
 
1149
                                                tdata,
 
1150
                                                &stateless_data->cur_transport);
 
1151
        if (status != PJ_SUCCESS) {
 
1152
            sent = -status;
 
1153
            continue;
 
1154
        }
 
1155
 
 
1156
        /* Modify Via header. */
 
1157
        via = (pjsip_via_hdr*) pjsip_msg_find_hdr( tdata->msg,
 
1158
                                                   PJSIP_H_VIA, NULL);
 
1159
        if (!via) {
 
1160
            /* Shouldn't happen if request was created with PJSIP API! 
 
1161
             * But we handle the case anyway for robustness.
 
1162
             */
 
1163
            pj_assert(!"Via header not found!");
 
1164
            via = pjsip_via_hdr_create(tdata->pool);
 
1165
            pjsip_msg_insert_first_hdr(tdata->msg, (pjsip_hdr*)via);
 
1166
        }
 
1167
 
 
1168
        if (via->branch_param.slen == 0) {
 
1169
            pj_str_t tmp;
 
1170
            via->branch_param.ptr = (char*)pj_pool_alloc(tdata->pool,
 
1171
                                                         PJSIP_MAX_BRANCH_LEN);
 
1172
            via->branch_param.slen = PJSIP_MAX_BRANCH_LEN;
 
1173
            pj_memcpy(via->branch_param.ptr, PJSIP_RFC3261_BRANCH_ID,
 
1174
                      PJSIP_RFC3261_BRANCH_LEN);
 
1175
            tmp.ptr = via->branch_param.ptr + PJSIP_RFC3261_BRANCH_LEN + 2;
 
1176
            *(tmp.ptr-2) = 80; *(tmp.ptr-1) = 106;
 
1177
            pj_generate_unique_string(&tmp);
 
1178
        }
 
1179
 
 
1180
        via->transport = pj_str(stateless_data->cur_transport->type_name);
 
1181
        via->sent_by = stateless_data->cur_transport->local_name;
 
1182
        via->rport_param = pjsip_cfg()->endpt.disable_rport ? -1 : 0;
 
1183
 
 
1184
        pjsip_tx_data_invalidate_msg(tdata);
 
1185
 
 
1186
        /* Send message using this transport. */
 
1187
        status = pjsip_transport_send( stateless_data->cur_transport,
 
1188
                                       tdata,
 
1189
                                       cur_addr,
 
1190
                                       cur_addr_len,
 
1191
                                       stateless_data,
 
1192
                                       &stateless_send_transport_cb);
 
1193
        if (status == PJ_SUCCESS) {
 
1194
            /* Recursively call this function. */
 
1195
            sent = tdata->buf.cur - tdata->buf.start;
 
1196
            stateless_send_transport_cb( stateless_data, tdata, sent );
 
1197
            return;
 
1198
        } else if (status == PJ_EPENDING) {
 
1199
            /* This callback will be called later. */
 
1200
            return;
 
1201
        } else {
 
1202
            /* Recursively call this function. */
 
1203
            sent = -status;
 
1204
            stateless_send_transport_cb( stateless_data, tdata, sent );
 
1205
            return;
 
1206
        }
 
1207
    }
 
1208
 
 
1209
}
 
1210
 
 
1211
/* Resolver callback for sending stateless request. */
 
1212
static void 
 
1213
stateless_send_resolver_callback( pj_status_t status,
 
1214
                                  void *token,
 
1215
                                  const struct pjsip_server_addresses *addr)
 
1216
{
 
1217
    pjsip_send_state *stateless_data = (pjsip_send_state*) token;
 
1218
    pjsip_tx_data *tdata = stateless_data->tdata;
 
1219
 
 
1220
    /* Fail on server resolution. */
 
1221
    if (status != PJ_SUCCESS) {
 
1222
        if (stateless_data->app_cb) {
 
1223
            pj_bool_t cont = PJ_FALSE;
 
1224
            (*stateless_data->app_cb)(stateless_data, -status, &cont);
 
1225
        }
 
1226
        pjsip_tx_data_dec_ref(tdata);
 
1227
        return;
 
1228
    }
 
1229
 
 
1230
    /* Copy server addresses */
 
1231
    if (addr && addr != &tdata->dest_info.addr) {
 
1232
        pj_memcpy( &tdata->dest_info.addr, addr, 
 
1233
                   sizeof(pjsip_server_addresses));
 
1234
    }
 
1235
    pj_assert(tdata->dest_info.addr.count != 0);
 
1236
 
 
1237
#if !defined(PJSIP_DONT_SWITCH_TO_TCP) || PJSIP_DONT_SWITCH_TO_TCP==0
 
1238
    /* RFC 3261 section 18.1.1:
 
1239
     * If a request is within 200 bytes of the path MTU, or if it is larger
 
1240
     * than 1300 bytes and the path MTU is unknown, the request MUST be sent
 
1241
     * using an RFC 2914 [43] congestion controlled transport protocol, such
 
1242
     * as TCP.
 
1243
     */
 
1244
    if (tdata->msg->type == PJSIP_REQUEST_MSG &&
 
1245
        tdata->dest_info.addr.count > 0 && 
 
1246
        tdata->dest_info.addr.entry[0].type == PJSIP_TRANSPORT_UDP)
 
1247
    {
 
1248
        int len;
 
1249
 
 
1250
        /* Encode the request */
 
1251
        status = pjsip_tx_data_encode(tdata);
 
1252
        if (status != PJ_SUCCESS) {
 
1253
            if (stateless_data->app_cb) {
 
1254
                pj_bool_t cont = PJ_FALSE;
 
1255
                (*stateless_data->app_cb)(stateless_data, -status, &cont);
 
1256
            }
 
1257
            pjsip_tx_data_dec_ref(tdata);
 
1258
            return;
 
1259
        }
 
1260
 
 
1261
        /* Check if request message is larger than 1300 bytes. */
 
1262
        len = tdata->buf.cur - tdata->buf.start;
 
1263
        if (len >= PJSIP_UDP_SIZE_THRESHOLD) {
 
1264
            int i;
 
1265
            int count = tdata->dest_info.addr.count;
 
1266
 
 
1267
            PJ_LOG(5,(THIS_FILE, "%s exceeds UDP size threshold (%u), "
 
1268
                                 "sending with TCP",
 
1269
                                 pjsip_tx_data_get_info(tdata),
 
1270
                                 PJSIP_UDP_SIZE_THRESHOLD));
 
1271
 
 
1272
            /* Insert "TCP version" of resolved UDP addresses at the
 
1273
             * beginning.
 
1274
             */
 
1275
            if (count * 2 > PJSIP_MAX_RESOLVED_ADDRESSES)
 
1276
                count = PJSIP_MAX_RESOLVED_ADDRESSES / 2;
 
1277
            for (i = 0; i < count; ++i) {
 
1278
                pj_memcpy(&tdata->dest_info.addr.entry[i+count],
 
1279
                          &tdata->dest_info.addr.entry[i],
 
1280
                          sizeof(tdata->dest_info.addr.entry[0]));
 
1281
                tdata->dest_info.addr.entry[i].type = PJSIP_TRANSPORT_TCP;
 
1282
            }
 
1283
            tdata->dest_info.addr.count = count * 2;
 
1284
        }
 
1285
    }
 
1286
#endif /* !PJSIP_DONT_SWITCH_TO_TCP */
 
1287
 
 
1288
    /* Process the addresses. */
 
1289
    stateless_send_transport_cb( stateless_data, tdata, -PJ_EPENDING);
 
1290
}
 
1291
 
 
1292
/*
 
1293
 * Send stateless request.
 
1294
 * The sending process consists of several stages:
 
1295
 *  - determine which host to contact (#pjsip_get_request_addr).
 
1296
 *  - resolve the host (#pjsip_endpt_resolve)
 
1297
 *  - establish transport (#pjsip_endpt_acquire_transport)
 
1298
 *  - send the message (#pjsip_transport_send)
 
1299
 */
 
1300
PJ_DEF(pj_status_t) pjsip_endpt_send_request_stateless(pjsip_endpoint *endpt, 
 
1301
                                   pjsip_tx_data *tdata,
 
1302
                                   void *token,
 
1303
                                   pjsip_send_callback cb)
 
1304
{
 
1305
    pjsip_host_info dest_info;
 
1306
    pjsip_send_state *stateless_data;
 
1307
    pj_status_t status;
 
1308
 
 
1309
    PJ_ASSERT_RETURN(endpt && tdata, PJ_EINVAL);
 
1310
 
 
1311
    /* Get destination name to contact. */
 
1312
    status = pjsip_process_route_set(tdata, &dest_info);
 
1313
    if (status != PJ_SUCCESS)
 
1314
        return status;
 
1315
 
 
1316
    /* Keep stateless data. */
 
1317
    stateless_data = PJ_POOL_ZALLOC_T(tdata->pool, pjsip_send_state);
 
1318
    stateless_data->token = token;
 
1319
    stateless_data->endpt = endpt;
 
1320
    stateless_data->tdata = tdata;
 
1321
    stateless_data->app_cb = cb;
 
1322
 
 
1323
    /* If destination info has not been initialized (this applies for most
 
1324
     * all requests except CANCEL), resolve destination host. The processing
 
1325
     * then resumed when the resolving callback is called. For CANCEL, the
 
1326
     * destination info must have been copied from the original INVITE so
 
1327
     * proceed to sending the request directly.
 
1328
     */
 
1329
    if (tdata->dest_info.addr.count == 0) {
 
1330
        /* Copy the destination host name to TX data */
 
1331
        pj_strdup(tdata->pool, &tdata->dest_info.name, &dest_info.addr.host);
 
1332
 
 
1333
        pjsip_endpt_resolve( endpt, tdata->pool, &dest_info, stateless_data,
 
1334
                             &stateless_send_resolver_callback);
 
1335
    } else {
 
1336
        PJ_LOG(5,(THIS_FILE, "%s: skipping target resolution because "
 
1337
                             "address is already set",
 
1338
                             pjsip_tx_data_get_info(tdata)));
 
1339
        stateless_send_resolver_callback(PJ_SUCCESS, stateless_data,
 
1340
                                         &tdata->dest_info.addr);
 
1341
    }
 
1342
    return PJ_SUCCESS;
 
1343
}
 
1344
 
 
1345
 
 
1346
/*
 
1347
 * Send raw data to a destination.
 
1348
 */
 
1349
PJ_DEF(pj_status_t) pjsip_endpt_send_raw( pjsip_endpoint *endpt,
 
1350
                                          pjsip_transport_type_e tp_type,
 
1351
                                          const pjsip_tpselector *sel,
 
1352
                                          const void *raw_data,
 
1353
                                          pj_size_t data_len,
 
1354
                                          const pj_sockaddr_t *addr,
 
1355
                                          int addr_len,
 
1356
                                          void *token,
 
1357
                                          pjsip_tp_send_callback cb)
 
1358
{
 
1359
    return pjsip_tpmgr_send_raw(pjsip_endpt_get_tpmgr(endpt), tp_type, sel,
 
1360
                                NULL, raw_data, data_len, addr, addr_len,
 
1361
                                token, cb);
 
1362
}
 
1363
 
 
1364
 
 
1365
/* Callback data for sending raw data */
 
1366
struct send_raw_data
 
1367
{
 
1368
    pjsip_endpoint          *endpt;
 
1369
    pjsip_tx_data           *tdata;
 
1370
    pjsip_tpselector        *sel;
 
1371
    void                    *app_token;
 
1372
    pjsip_tp_send_callback   app_cb;
 
1373
};
 
1374
 
 
1375
 
 
1376
/* Resolver callback for sending raw data. */
 
1377
static void send_raw_resolver_callback( pj_status_t status,
 
1378
                                        void *token,
 
1379
                                        const pjsip_server_addresses *addr)
 
1380
{
 
1381
    struct send_raw_data *sraw_data = (struct send_raw_data*) token;
 
1382
 
 
1383
    if (status != PJ_SUCCESS) {
 
1384
        if (sraw_data->app_cb) {
 
1385
            (*sraw_data->app_cb)(sraw_data->app_token, sraw_data->tdata,
 
1386
                                 -status);
 
1387
        }
 
1388
    } else {
 
1389
        pj_size_t data_len;
 
1390
 
 
1391
        pj_assert(addr->count != 0);
 
1392
 
 
1393
        data_len = sraw_data->tdata->buf.cur - sraw_data->tdata->buf.start;
 
1394
        status = pjsip_tpmgr_send_raw(pjsip_endpt_get_tpmgr(sraw_data->endpt),
 
1395
                                      addr->entry[0].type,
 
1396
                                      sraw_data->sel, sraw_data->tdata,
 
1397
                                      sraw_data->tdata->buf.start, data_len,
 
1398
                                      &addr->entry[0].addr, 
 
1399
                                      addr->entry[0].addr_len, 
 
1400
                                      sraw_data->app_token,
 
1401
                                      sraw_data->app_cb);
 
1402
        if (status == PJ_SUCCESS) {
 
1403
            (*sraw_data->app_cb)(sraw_data->app_token, sraw_data->tdata,
 
1404
                                 data_len);
 
1405
        } else if (status != PJ_EPENDING) {
 
1406
            (*sraw_data->app_cb)(sraw_data->app_token, sraw_data->tdata,
 
1407
                                 -status);
 
1408
        }
 
1409
    }
 
1410
 
 
1411
    if (sraw_data->sel) {
 
1412
        pjsip_tpselector_dec_ref(sraw_data->sel);
 
1413
    }
 
1414
    pjsip_tx_data_dec_ref(sraw_data->tdata);
 
1415
}
 
1416
 
 
1417
 
 
1418
/*
 
1419
 * Send raw data to the specified destination URI. 
 
1420
 */
 
1421
PJ_DEF(pj_status_t) pjsip_endpt_send_raw_to_uri(pjsip_endpoint *endpt,
 
1422
                                                const pj_str_t *p_dst_uri,
 
1423
                                                const pjsip_tpselector *sel,
 
1424
                                                const void *raw_data,
 
1425
                                                pj_size_t data_len,
 
1426
                                                void *token,
 
1427
                                                pjsip_tp_send_callback cb)
 
1428
{
 
1429
    pjsip_tx_data *tdata;
 
1430
    struct send_raw_data *sraw_data;
 
1431
    pj_str_t dst_uri;
 
1432
    pjsip_uri *uri;
 
1433
    pjsip_host_info dest_info;
 
1434
    pj_status_t status;
 
1435
 
 
1436
    /* Allocate buffer */
 
1437
    status = pjsip_endpt_create_tdata(endpt, &tdata);
 
1438
    if (status != PJ_SUCCESS)
 
1439
        return status;
 
1440
 
 
1441
    pjsip_tx_data_add_ref(tdata);
 
1442
 
 
1443
    /* Duplicate URI since parser requires URI to be NULL terminated */
 
1444
    pj_strdup_with_null(tdata->pool, &dst_uri, p_dst_uri);
 
1445
 
 
1446
    /* Parse URI */
 
1447
    uri = pjsip_parse_uri(tdata->pool, dst_uri.ptr, dst_uri.slen, 0);
 
1448
    if (uri == NULL) {
 
1449
        pjsip_tx_data_dec_ref(tdata);
 
1450
        return PJSIP_EINVALIDURI;
 
1451
    }
 
1452
 
 
1453
    /* Build destination info. */
 
1454
    status = get_dest_info(uri, tdata->pool, &dest_info);
 
1455
    if (status != PJ_SUCCESS) {
 
1456
        pjsip_tx_data_dec_ref(tdata);
 
1457
        return status;
 
1458
    }
 
1459
 
 
1460
    /* Copy data (note: data_len may be zero!) */
 
1461
    tdata->buf.start = (char*) pj_pool_alloc(tdata->pool, data_len+1);
 
1462
    tdata->buf.end = tdata->buf.start + data_len + 1;
 
1463
    if (data_len)
 
1464
        pj_memcpy(tdata->buf.start, raw_data, data_len);
 
1465
    tdata->buf.cur = tdata->buf.start + data_len;
 
1466
 
 
1467
    /* Init send_raw_data */
 
1468
    sraw_data = PJ_POOL_ZALLOC_T(tdata->pool, struct send_raw_data);
 
1469
    sraw_data->endpt = endpt;
 
1470
    sraw_data->tdata = tdata;
 
1471
    sraw_data->app_token = token;
 
1472
    sraw_data->app_cb = cb;
 
1473
 
 
1474
    if (sel) {
 
1475
        sraw_data->sel = PJ_POOL_ALLOC_T(tdata->pool, pjsip_tpselector);
 
1476
        pj_memcpy(sraw_data->sel, sel, sizeof(pjsip_tpselector));
 
1477
        pjsip_tpselector_add_ref(sraw_data->sel);
 
1478
    }
 
1479
 
 
1480
    /* Copy the destination host name to TX data */
 
1481
    pj_strdup(tdata->pool, &tdata->dest_info.name, &dest_info.addr.host);
 
1482
 
 
1483
    /* Resolve destination host.
 
1484
     * The processing then resumed when the resolving callback is called.
 
1485
     */
 
1486
    pjsip_endpt_resolve( endpt, tdata->pool, &dest_info, sraw_data,
 
1487
                         &send_raw_resolver_callback);
 
1488
    return PJ_SUCCESS;
 
1489
}
 
1490
 
 
1491
 
 
1492
/*
 
1493
 * Determine which address (and transport) to use to send response message
 
1494
 * based on the received request. This function follows the specification
 
1495
 * in section 18.2.2 of RFC 3261 and RFC 3581 for calculating the destination
 
1496
 * address and transport.
 
1497
 */
 
1498
PJ_DEF(pj_status_t) pjsip_get_response_addr( pj_pool_t *pool,
 
1499
                                             pjsip_rx_data *rdata,
 
1500
                                             pjsip_response_addr *res_addr )
 
1501
{
 
1502
    pjsip_transport *src_transport = rdata->tp_info.transport;
 
1503
 
 
1504
    /* Check arguments. */
 
1505
    PJ_ASSERT_RETURN(pool && rdata && res_addr, PJ_EINVAL);
 
1506
 
 
1507
    /* rdata must be a request message! */
 
1508
    PJ_ASSERT_RETURN(rdata->msg_info.msg->type == PJSIP_REQUEST_MSG,
 
1509
                     PJ_EINVAL);
 
1510
 
 
1511
    /* All requests must have "received" parameter.
 
1512
     * This must always be done in transport layer.
 
1513
     */
 
1514
    pj_assert(rdata->msg_info.via->recvd_param.slen != 0);
 
1515
 
 
1516
    /* Do the calculation based on RFC 3261 Section 18.2.2 and RFC 3581 */
 
1517
 
 
1518
    if (PJSIP_TRANSPORT_IS_RELIABLE(src_transport)) {
 
1519
        /* For reliable protocol such as TCP or SCTP, or TLS over those, the
 
1520
         * response MUST be sent using the existing connection to the source
 
1521
         * of the original request that created the transaction, if that 
 
1522
         * connection is still open. 
 
1523
         * If that connection is no longer open, the server SHOULD open a 
 
1524
         * connection to the IP address in the received parameter, if present,
 
1525
         * using the port in the sent-by value, or the default port for that 
 
1526
         * transport, if no port is specified. 
 
1527
         * If that connection attempt fails, the server SHOULD use the 
 
1528
         * procedures in [4] for servers in order to determine the IP address
 
1529
         * and port to open the connection and send the response to.
 
1530
         */
 
1531
        res_addr->transport = rdata->tp_info.transport;
 
1532
        pj_memcpy(&res_addr->addr, &rdata->pkt_info.src_addr,
 
1533
                  rdata->pkt_info.src_addr_len);
 
1534
        res_addr->addr_len = rdata->pkt_info.src_addr_len;
 
1535
        res_addr->dst_host.type=(pjsip_transport_type_e)src_transport->key.type;
 
1536
        res_addr->dst_host.flag = src_transport->flag;
 
1537
        pj_strdup( pool, &res_addr->dst_host.addr.host, 
 
1538
                   &rdata->msg_info.via->recvd_param);
 
1539
        res_addr->dst_host.addr.port = rdata->msg_info.via->sent_by.port;
 
1540
        if (res_addr->dst_host.addr.port == 0) {
 
1541
            res_addr->dst_host.addr.port = 
 
1542
                pjsip_transport_get_default_port_for_type(res_addr->dst_host.type);
 
1543
        }
 
1544
 
 
1545
    } else if (rdata->msg_info.via->maddr_param.slen) {
 
1546
        /* Otherwise, if the Via header field value contains a maddr parameter,
 
1547
         * the response MUST be forwarded to the address listed there, using 
 
1548
         * the port indicated in sent-by, or port 5060 if none is present. 
 
1549
         * If the address is a multicast address, the response SHOULD be sent 
 
1550
         * using the TTL indicated in the ttl parameter, or with a TTL of 1 if
 
1551
         * that parameter is not present. 
 
1552
         */
 
1553
        res_addr->transport = NULL;
 
1554
        res_addr->dst_host.type=(pjsip_transport_type_e)src_transport->key.type;
 
1555
        res_addr->dst_host.flag = src_transport->flag;
 
1556
        pj_strdup( pool, &res_addr->dst_host.addr.host, 
 
1557
                   &rdata->msg_info.via->maddr_param);
 
1558
        res_addr->dst_host.addr.port = rdata->msg_info.via->sent_by.port;
 
1559
        if (res_addr->dst_host.addr.port == 0)
 
1560
            res_addr->dst_host.addr.port = 5060;
 
1561
 
 
1562
    } else if (rdata->msg_info.via->rport_param >= 0) {
 
1563
        /* There is both a "received" parameter and an "rport" parameter, 
 
1564
         * the response MUST be sent to the IP address listed in the "received"
 
1565
         * parameter, and the port in the "rport" parameter. 
 
1566
         * The response MUST be sent from the same address and port that the 
 
1567
         * corresponding request was received on.
 
1568
         */
 
1569
        res_addr->transport = rdata->tp_info.transport;
 
1570
        pj_memcpy(&res_addr->addr, &rdata->pkt_info.src_addr,
 
1571
                  rdata->pkt_info.src_addr_len);
 
1572
        res_addr->addr_len = rdata->pkt_info.src_addr_len;
 
1573
        res_addr->dst_host.type=(pjsip_transport_type_e)src_transport->key.type;
 
1574
        res_addr->dst_host.flag = src_transport->flag;
 
1575
        pj_strdup( pool, &res_addr->dst_host.addr.host, 
 
1576
                   &rdata->msg_info.via->recvd_param);
 
1577
        res_addr->dst_host.addr.port = rdata->msg_info.via->sent_by.port;
 
1578
        if (res_addr->dst_host.addr.port == 0) {
 
1579
            res_addr->dst_host.addr.port = 
 
1580
                pjsip_transport_get_default_port_for_type(res_addr->dst_host.type);
 
1581
        }
 
1582
 
 
1583
    } else {
 
1584
        res_addr->transport = NULL;
 
1585
        res_addr->dst_host.type=(pjsip_transport_type_e)src_transport->key.type;
 
1586
        res_addr->dst_host.flag = src_transport->flag;
 
1587
        pj_strdup( pool, &res_addr->dst_host.addr.host, 
 
1588
                   &rdata->msg_info.via->recvd_param);
 
1589
        res_addr->dst_host.addr.port = rdata->msg_info.via->sent_by.port;
 
1590
        if (res_addr->dst_host.addr.port == 0) {
 
1591
            res_addr->dst_host.addr.port = 
 
1592
                pjsip_transport_get_default_port_for_type(res_addr->dst_host.type);
 
1593
        }
 
1594
    }
 
1595
 
 
1596
    return PJ_SUCCESS;
 
1597
}
 
1598
 
 
1599
/*
 
1600
 * Callback called by transport during send_response.
 
1601
 */
 
1602
static void send_response_transport_cb(void *token, pjsip_tx_data *tdata,
 
1603
                                       pj_ssize_t sent)
 
1604
{
 
1605
    pjsip_send_state *send_state = (pjsip_send_state*) token;
 
1606
    pj_bool_t cont = PJ_FALSE;
 
1607
 
 
1608
    /* Call callback, if any. */
 
1609
    if (send_state->app_cb)
 
1610
        (*send_state->app_cb)(send_state, sent, &cont);
 
1611
 
 
1612
    /* Decrement transport reference counter. */
 
1613
    pjsip_transport_dec_ref(send_state->cur_transport);
 
1614
 
 
1615
    /* Decrement transmit data ref counter. */
 
1616
    pjsip_tx_data_dec_ref(tdata);
 
1617
}
 
1618
 
 
1619
/*
 
1620
 * Resolver calback during send_response.
 
1621
 */
 
1622
static void send_response_resolver_cb( pj_status_t status, void *token,
 
1623
                                       const pjsip_server_addresses *addr )
 
1624
{
 
1625
    pjsip_send_state *send_state = (pjsip_send_state*) token;
 
1626
 
 
1627
    if (status != PJ_SUCCESS) {
 
1628
        if (send_state->app_cb) {
 
1629
            pj_bool_t cont = PJ_FALSE;
 
1630
            (*send_state->app_cb)(send_state, -status, &cont);
 
1631
        }
 
1632
        pjsip_tx_data_dec_ref(send_state->tdata);
 
1633
        return;
 
1634
    }
 
1635
 
 
1636
    /* Only handle the first address resolved. */
 
1637
 
 
1638
    /* Acquire transport. */
 
1639
    status = pjsip_endpt_acquire_transport2(send_state->endpt, 
 
1640
                                            addr->entry[0].type,
 
1641
                                            &addr->entry[0].addr,
 
1642
                                            addr->entry[0].addr_len,
 
1643
                                            &send_state->tdata->tp_sel,
 
1644
                                            send_state->tdata,
 
1645
                                            &send_state->cur_transport);
 
1646
    if (status != PJ_SUCCESS) {
 
1647
        if (send_state->app_cb) {
 
1648
            pj_bool_t cont = PJ_FALSE;
 
1649
            (*send_state->app_cb)(send_state, -status, &cont);
 
1650
        }
 
1651
        pjsip_tx_data_dec_ref(send_state->tdata);
 
1652
        return;
 
1653
    }
 
1654
 
 
1655
    /* Update address in send_state. */
 
1656
    pj_memcpy(&send_state->tdata->dest_info.addr, addr, sizeof(*addr));
 
1657
 
 
1658
    /* Send response using the transoprt. */
 
1659
    status = pjsip_transport_send( send_state->cur_transport, 
 
1660
                                   send_state->tdata,
 
1661
                                   &addr->entry[0].addr,
 
1662
                                   addr->entry[0].addr_len,
 
1663
                                   send_state,
 
1664
                                   &send_response_transport_cb);
 
1665
    if (status == PJ_SUCCESS) {
 
1666
        pj_ssize_t sent = send_state->tdata->buf.cur - 
 
1667
                          send_state->tdata->buf.start;
 
1668
        send_response_transport_cb(send_state, send_state->tdata, sent);
 
1669
 
 
1670
    } else if (status == PJ_EPENDING) {
 
1671
        /* Transport callback will be called later. */
 
1672
    } else {
 
1673
        send_response_transport_cb(send_state, send_state->tdata, -status);
 
1674
    }
 
1675
}
 
1676
 
 
1677
/*
 
1678
 * Send response.
 
1679
 */
 
1680
PJ_DEF(pj_status_t) pjsip_endpt_send_response( pjsip_endpoint *endpt,
 
1681
                                               pjsip_response_addr *res_addr,
 
1682
                                               pjsip_tx_data *tdata,
 
1683
                                               void *token,
 
1684
                                               pjsip_send_callback cb)
 
1685
{
 
1686
    /* Determine which transports and addresses to send the response,
 
1687
     * based on Section 18.2.2 of RFC 3261.
 
1688
     */
 
1689
    pjsip_send_state *send_state;
 
1690
    pj_status_t status;
 
1691
 
 
1692
    /* Create structure to keep the sending state. */
 
1693
    send_state = PJ_POOL_ZALLOC_T(tdata->pool, pjsip_send_state);
 
1694
    send_state->endpt = endpt;
 
1695
    send_state->tdata = tdata;
 
1696
    send_state->token = token;
 
1697
    send_state->app_cb = cb;
 
1698
 
 
1699
    if (res_addr->transport != NULL) {
 
1700
        send_state->cur_transport = res_addr->transport;
 
1701
        pjsip_transport_add_ref(send_state->cur_transport);
 
1702
 
 
1703
        status = pjsip_transport_send( send_state->cur_transport, tdata, 
 
1704
                                       &res_addr->addr,
 
1705
                                       res_addr->addr_len,
 
1706
                                       send_state,
 
1707
                                       &send_response_transport_cb );
 
1708
        if (status == PJ_SUCCESS) {
 
1709
            pj_ssize_t sent = tdata->buf.cur - tdata->buf.start;
 
1710
            send_response_transport_cb(send_state, tdata, sent);
 
1711
            return PJ_SUCCESS;
 
1712
        } else if (status == PJ_EPENDING) {
 
1713
            /* Callback will be called later. */
 
1714
            return PJ_SUCCESS;
 
1715
        } else {
 
1716
            pjsip_transport_dec_ref(send_state->cur_transport);
 
1717
            return status;
 
1718
        }
 
1719
    } else {
 
1720
        /* Copy the destination host name to TX data */
 
1721
        pj_strdup(tdata->pool, &tdata->dest_info.name, 
 
1722
                  &res_addr->dst_host.addr.host);
 
1723
 
 
1724
        pjsip_endpt_resolve(endpt, tdata->pool, &res_addr->dst_host, 
 
1725
                            send_state, &send_response_resolver_cb);
 
1726
        return PJ_SUCCESS;
 
1727
    }
 
1728
}
 
1729
 
 
1730
/*
 
1731
 * Send response combo
 
1732
 */
 
1733
PJ_DEF(pj_status_t) pjsip_endpt_send_response2( pjsip_endpoint *endpt,
 
1734
                                                pjsip_rx_data *rdata,
 
1735
                                                pjsip_tx_data *tdata,
 
1736
                                                void *token,
 
1737
                                                pjsip_send_callback cb)
 
1738
{
 
1739
    pjsip_response_addr res_addr;
 
1740
    pj_status_t status;
 
1741
 
 
1742
    status = pjsip_get_response_addr(tdata->pool, rdata, &res_addr);
 
1743
    if (status != PJ_SUCCESS) {
 
1744
        pjsip_tx_data_dec_ref(tdata);
 
1745
        return PJ_SUCCESS;
 
1746
    }
 
1747
 
 
1748
    status = pjsip_endpt_send_response(endpt, &res_addr, tdata, token, cb);
 
1749
    return status;
 
1750
}
 
1751
 
 
1752
 
 
1753
/*
 
1754
 * Send response
 
1755
 */
 
1756
PJ_DEF(pj_status_t) pjsip_endpt_respond_stateless( pjsip_endpoint *endpt,
 
1757
                                                   pjsip_rx_data *rdata,
 
1758
                                                   int st_code,
 
1759
                                                   const pj_str_t *st_text,
 
1760
                                                   const pjsip_hdr *hdr_list,
 
1761
                                                   const pjsip_msg_body *body)
 
1762
{
 
1763
    pj_status_t status;
 
1764
    pjsip_response_addr res_addr;
 
1765
    pjsip_tx_data *tdata;
 
1766
 
 
1767
    /* Verify arguments. */
 
1768
    PJ_ASSERT_RETURN(endpt && rdata, PJ_EINVAL);
 
1769
    PJ_ASSERT_RETURN(rdata->msg_info.msg->type == PJSIP_REQUEST_MSG,
 
1770
                     PJSIP_ENOTREQUESTMSG);
 
1771
 
 
1772
    /* Check that no UAS transaction has been created for this request. 
 
1773
     * If UAS transaction has been created for this request, application
 
1774
     * MUST send the response statefully using that transaction.
 
1775
     */
 
1776
    PJ_ASSERT_RETURN(pjsip_rdata_get_tsx(rdata)==NULL, PJ_EINVALIDOP);
 
1777
 
 
1778
    /* Create response message */
 
1779
    status = pjsip_endpt_create_response( endpt, rdata, st_code, st_text, 
 
1780
                                          &tdata);
 
1781
    if (status != PJ_SUCCESS)
 
1782
        return status;
 
1783
 
 
1784
    /* Add the message headers, if any */
 
1785
    if (hdr_list) {
 
1786
        const pjsip_hdr *hdr = hdr_list->next;
 
1787
        while (hdr != hdr_list) {
 
1788
            pjsip_msg_add_hdr(tdata->msg, 
 
1789
                              (pjsip_hdr*) pjsip_hdr_clone(tdata->pool, hdr) );
 
1790
            hdr = hdr->next;
 
1791
        }
 
1792
    }
 
1793
 
 
1794
    /* Add the message body, if any. */
 
1795
    if (body) {
 
1796
        tdata->msg->body = pjsip_msg_body_clone( tdata->pool, body );
 
1797
        if (tdata->msg->body == NULL) {
 
1798
            pjsip_tx_data_dec_ref(tdata);
 
1799
            return status;
 
1800
        }
 
1801
    }
 
1802
 
 
1803
    /* Get where to send request. */
 
1804
    status = pjsip_get_response_addr( tdata->pool, rdata, &res_addr );
 
1805
    if (status != PJ_SUCCESS) {
 
1806
        pjsip_tx_data_dec_ref(tdata);
 
1807
        return status;
 
1808
    }
 
1809
 
 
1810
    /* Send! */
 
1811
    status = pjsip_endpt_send_response( endpt, &res_addr, tdata, NULL, NULL );
 
1812
    if (status != PJ_SUCCESS) {
 
1813
        pjsip_tx_data_dec_ref(tdata);
 
1814
        return status;
 
1815
    }
 
1816
 
 
1817
    return PJ_SUCCESS;
 
1818
}
 
1819
 
 
1820
 
 
1821
/*
 
1822
 * Get the event string from the event ID.
 
1823
 */
 
1824
PJ_DEF(const char *) pjsip_event_str(pjsip_event_id_e e)
 
1825
{
 
1826
    return event_str[e];
 
1827
}
 
1828