← Back to branch summary

~ubuntu-branches/ubuntu/wily/sflphone/wily

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject-2.0.1/pjlib-util/src/pjlib-util/http_client.c

  • Committer: Package Import Robot
  • Author(s): Mark Purcell
  • Date: 2014-01-28 18:23:36 UTC
  • mfrom: (1.1.11)
  • mto: This revision was merged to the branch mainline in revision 24.
  • Revision ID: package-import@ubuntu.com-20140128182336-3xenud1kbnwmf3mz
http://bugs.debian.org/735846
http://bugs.debian.org/727164
http://bugs.debian.org/718178
http://bugs.debian.org/736583
http://bugs.debian.org/722040
http://bugs.debian.org/736746
* New upstream release 
  - Fixes "New Upstream Release" (Closes: #735846)
  - Fixes "Ringtone does not stop" (Closes: #727164)
  - Fixes "[sflphone-kde] crash on startup" (Closes: #718178)
  - Fixes "sflphone GUI crashes when call is hung up" (Closes: #736583)
* Build-Depends: ensure GnuTLS 2.6
  - libucommon-dev (>= 6.0.7-1.1), libccrtp-dev (>= 2.0.6-3)
  - Fixes "FTBFS Build-Depends libgnutls{26,28}-dev" (Closes: #722040)
* Fix "boost 1.49 is going away" unversioned Build-Depends: (Closes: #736746)
* Add Build-Depends: libsndfile-dev, nepomuk-core-dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
daemon/libs/pjproject-2.0.1/pjlib-util/src/pjlib-util/http_client.c
1
 
/* $Id: http_client.c 3841 2011-10-24 09:28:13Z ming $ */
2
 
/*
3
 
 * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
4
 
 *
5
 
 * This program is free software; you can redistribute it and/or modify
6
 
 * it under the terms of the GNU General Public License as published by
7
 
 * the Free Software Foundation; either version 2 of the License, or
8
 
 * (at your option) any later version.
9
 
 *
10
 
 * This program is distributed in the hope that it will be useful,
11
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 * GNU General Public License for more details.
14
 
 *
15
 
 * You should have received a copy of the GNU General Public License
16
 
 * along with this program; if not, write to the Free Software
17
 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 
 */
19
 
 
20
 
#include <pjlib-util/http_client.h>
21
 
#include <pj/activesock.h>
22
 
#include <pj/assert.h>
23
 
#include <pj/ctype.h>
24
 
#include <pj/errno.h>
25
 
#include <pj/except.h>
26
 
#include <pj/pool.h>
27
 
#include <pj/string.h>
28
 
#include <pj/timer.h>
29
 
#include <pj/rand.h>
30
 
#include <pjlib-util/base64.h>
31
 
#include <pjlib-util/errno.h>
32
 
#include <pjlib-util/md5.h>
33
 
#include <pjlib-util/scanner.h>
34
 
#include <pjlib-util/string.h>
35
 
 
36
 
#define THIS_FILE   "http_client.c"
37
 
 
38
 
#if 0
39
 
    /* Enable some tracing */
40
 
    #define TRACE_(arg) PJ_LOG(3,arg)
41
 
#else
42
 
    #define TRACE_(arg)
43
 
#endif
44
 
 
45
 
#define NUM_PROTOCOL            2
46
 
#define HTTP_1_0                "1.0"
47
 
#define HTTP_1_1                "1.1"
48
 
#define CONTENT_LENGTH          "Content-Length"
49
 
/* Buffer size for sending/receiving messages. */
50
 
#define BUF_SIZE                2048
51
 
/* Initial data buffer size to store the data in case content-
52
 
 * length is not specified in the server's response.
53
 
 */
54
 
#define INITIAL_DATA_BUF_SIZE   2048
55
 
#define INITIAL_POOL_SIZE       1024
56
 
#define POOL_INCREMENT_SIZE     512
57
 
 
58
 
enum http_protocol
59
 
{
60
 
    PROTOCOL_HTTP,
61
 
    PROTOCOL_HTTPS
62
 
};
63
 
 
64
 
static const char *http_protocol_names[NUM_PROTOCOL] =
65
 
{
66
 
    "HTTP",
67
 
    "HTTPS"
68
 
};
69
 
 
70
 
static const unsigned int http_default_port[NUM_PROTOCOL] =
71
 
{
72
 
    80,
73
 
    443
74
 
};
75
 
 
76
 
enum http_method
77
 
{
78
 
    HTTP_GET,
79
 
    HTTP_PUT,
80
 
    HTTP_DELETE
81
 
};
82
 
 
83
 
static const char *http_method_names[3] =
84
 
{
85
 
    "GET",
86
 
    "PUT",
87
 
    "DELETE"
88
 
};
89
 
 
90
 
enum http_state
91
 
{
92
 
    IDLE,
93
 
    CONNECTING,
94
 
    SENDING_REQUEST,
95
 
    SENDING_REQUEST_BODY,
96
 
    REQUEST_SENT,
97
 
    READING_RESPONSE,
98
 
    READING_DATA,
99
 
    READING_COMPLETE,
100
 
    ABORTING,
101
 
};
102
 
 
103
 
enum auth_state
104
 
{
105
 
    AUTH_NONE,          /* Not authenticating */
106
 
    AUTH_RETRYING,      /* New request with auth has been submitted */
107
 
    AUTH_DONE           /* Done retrying the request with auth. */
108
 
};
109
 
 
110
 
struct pj_http_req
111
 
{
112
 
    pj_str_t                url;        /* Request URL */
113
 
    pj_http_url             hurl;       /* Parsed request URL */
114
 
    pj_sockaddr             addr;       /* The host's socket address */
115
 
    pj_http_req_param       param;      /* HTTP request parameters */
116
 
    pj_pool_t               *pool;      /* Pool to allocate memory from */
117
 
    pj_timer_heap_t         *timer;     /* Timer for timeout management */
118
 
    pj_ioqueue_t            *ioqueue;   /* Ioqueue to use */
119
 
    pj_http_req_callback    cb;         /* Callbacks */
120
 
    pj_activesock_t         *asock;     /* Active socket */
121
 
    pj_status_t             error;      /* Error status */
122
 
    pj_str_t                buffer;     /* Buffer to send/receive msgs */
123
 
    enum http_state         state;      /* State of the HTTP request */
124
 
    enum auth_state         auth_state; /* Authentication state */
125
 
    pj_timer_entry          timer_entry;/* Timer entry */
126
 
    pj_bool_t               resolved;   /* Whether URL's host is resolved */
127
 
    pj_http_resp            response;   /* HTTP response */
128
 
    pj_ioqueue_op_key_t     op_key;
129
 
    struct tcp_state
130
 
    {
131
 
        /* Total data sent so far if the data is sent in segments (i.e.
132
 
         * if on_send_data() is not NULL and if param.reqdata.total_size > 0)
133
 
         */
134
 
        pj_size_t tot_chunk_size;
135
 
        /* Size of data to be sent (in a single activesock operation).*/
136
 
        pj_size_t send_size;
137
 
        /* Data size sent so far. */
138
 
        pj_size_t current_send_size;
139
 
        /* Total data received so far. */
140
 
        pj_size_t current_read_size;
141
 
    } tcp_state;
142
 
};
143
 
 
144
 
/* Start sending the request */
145
 
static pj_status_t http_req_start_sending(pj_http_req *hreq);
146
 
/* Start reading the response */
147
 
static pj_status_t http_req_start_reading(pj_http_req *hreq);
148
 
/* End the request */
149
 
static pj_status_t http_req_end_request(pj_http_req *hreq);
150
 
/* Parse the header data and populate the header fields with the result. */
151
 
static pj_status_t http_headers_parse(char *hdata, pj_size_t size,
152
 
                                      pj_http_headers *headers);
153
 
/* Parse the response */
154
 
static pj_status_t http_response_parse(pj_pool_t *pool,
155
 
                                       pj_http_resp *response,
156
 
                                       void *data, pj_size_t size,
157
 
                                       pj_size_t *remainder);
158
 
/* Restart the request with authentication */
159
 
static void restart_req_with_auth(pj_http_req *hreq);
160
 
/* Parse authentication challenge */
161
 
static pj_status_t parse_auth_chal(pj_pool_t *pool, pj_str_t *input,
162
 
                                   pj_http_auth_chal *chal);
163
 
 
164
 
static pj_uint16_t get_http_default_port(const pj_str_t *protocol)
165
 
{
166
 
    int i;
167
 
 
168
 
    for (i = 0; i < NUM_PROTOCOL; i++) {
169
 
        if (!pj_stricmp2(protocol, http_protocol_names[i])) {
170
 
            return (pj_uint16_t)http_default_port[i];
171
 
        }
172
 
    }
173
 
    return 0;
174
 
}
175
 
 
176
 
static const char * get_protocol(const pj_str_t *protocol)
177
 
{
178
 
    int i;
179
 
 
180
 
    for (i = 0; i < NUM_PROTOCOL; i++) {
181
 
        if (!pj_stricmp2(protocol, http_protocol_names[i])) {
182
 
            return http_protocol_names[i];
183
 
        }
184
 
    }
185
 
 
186
 
    /* Should not happen */
187
 
    pj_assert(0);
188
 
    return NULL;
189
 
}
190
 
 
191
 
 
192
 
/* Syntax error handler for parser. */
193
 
static void on_syntax_error(pj_scanner *scanner)
194
 
{
195
 
    PJ_UNUSED_ARG(scanner);
196
 
    PJ_THROW(PJ_EINVAL);  // syntax error
197
 
}
198
 
 
199
 
/* Callback when connection is established to the server */
200
 
static pj_bool_t http_on_connect(pj_activesock_t *asock,
201
 
                                 pj_status_t status)
202
 
{
203
 
    pj_http_req *hreq = (pj_http_req*) pj_activesock_get_user_data(asock);
204
 
 
205
 
    if (hreq->state == ABORTING || hreq->state == IDLE)
206
 
        return PJ_FALSE;
207
 
 
208
 
    if (status != PJ_SUCCESS) {
209
 
        hreq->error = status;
210
 
        pj_http_req_cancel(hreq, PJ_TRUE);
211
 
        return PJ_FALSE;
212
 
    }
213
 
 
214
 
    /* OK, we are connected. Start sending the request */
215
 
    hreq->state = SENDING_REQUEST;
216
 
    http_req_start_sending(hreq);
217
 
    return PJ_TRUE;
218
 
}
219
 
 
220
 
static pj_bool_t http_on_data_sent(pj_activesock_t *asock,
221
 
                                   pj_ioqueue_op_key_t *op_key,
222
 
                                   pj_ssize_t sent)
223
 
{
224
 
    pj_http_req *hreq = (pj_http_req*) pj_activesock_get_user_data(asock);
225
 
 
226
 
    PJ_UNUSED_ARG(op_key);
227
 
 
228
 
    if (hreq->state == ABORTING || hreq->state == IDLE)
229
 
        return PJ_FALSE;
230
 
 
231
 
    if (sent <= 0) {
232
 
        hreq->error = (sent < 0 ? -sent : PJLIB_UTIL_EHTTPLOST);
233
 
        pj_http_req_cancel(hreq, PJ_TRUE);
234
 
        return PJ_FALSE;
235
 
    }
236
 
 
237
 
    hreq->tcp_state.current_send_size += sent;
238
 
    TRACE_((THIS_FILE, "\nData sent: %d out of %d bytes",
239
 
           hreq->tcp_state.current_send_size, hreq->tcp_state.send_size));
240
 
    if (hreq->tcp_state.current_send_size == hreq->tcp_state.send_size) {
241
 
        /* Find out whether there is a request body to send. */
242
 
        if (hreq->param.reqdata.total_size > 0 ||
243
 
            hreq->param.reqdata.size > 0)
244
 
        {
245
 
            if (hreq->state == SENDING_REQUEST) {
246
 
                /* Start sending the request body */
247
 
                hreq->state = SENDING_REQUEST_BODY;
248
 
                hreq->tcp_state.tot_chunk_size = 0;
249
 
                pj_assert(hreq->param.reqdata.total_size == 0 ||
250
 
                          (hreq->param.reqdata.total_size > 0 &&
251
 
                          hreq->param.reqdata.size == 0));
252
 
            } else {
253
 
                /* Continue sending the next chunk of the request body */
254
 
                hreq->tcp_state.tot_chunk_size += hreq->tcp_state.send_size;
255
 
                if (hreq->tcp_state.tot_chunk_size ==
256
 
                    hreq->param.reqdata.total_size ||
257
 
                    hreq->param.reqdata.total_size == 0)
258
 
                {
259
 
                    /* Finish sending all the chunks, start reading
260
 
                     * the response.
261
 
                     */
262
 
                    hreq->state = REQUEST_SENT;
263
 
                    http_req_start_reading(hreq);
264
 
                    return PJ_TRUE;
265
 
                }
266
 
            }
267
 
            if (hreq->param.reqdata.total_size > 0 &&
268
 
                hreq->cb.on_send_data)
269
 
            {
270
 
                /* Call the callback for the application to provide
271
 
                 * the next chunk of data to be sent.
272
 
                 */
273
 
                (*hreq->cb.on_send_data)(hreq, &hreq->param.reqdata.data,
274
 
                                         &hreq->param.reqdata.size);
275
 
                /* Make sure the total data size given by the user does not
276
 
                 * exceed what the user originally said.
277
 
                 */
278
 
                pj_assert(hreq->tcp_state.tot_chunk_size +
279
 
                          hreq->param.reqdata.size <=
280
 
                          hreq->param.reqdata.total_size);
281
 
            }
282
 
            http_req_start_sending(hreq);
283
 
        } else {
284
 
            /* No request body, proceed to reading the server's response. */
285
 
            hreq->state = REQUEST_SENT;
286
 
            http_req_start_reading(hreq);
287
 
        }
288
 
    }
289
 
    return PJ_TRUE;
290
 
}
291
 
 
292
 
static pj_bool_t http_on_data_read(pj_activesock_t *asock,
293
 
                                  void *data,
294
 
                                  pj_size_t size,
295
 
                                  pj_status_t status,
296
 
                                  pj_size_t *remainder)
297
 
{
298
 
    pj_http_req *hreq = (pj_http_req*) pj_activesock_get_user_data(asock);
299
 
 
300
 
    TRACE_((THIS_FILE, "\nData received: %d bytes", size));
301
 
 
302
 
    if (hreq->state == ABORTING || hreq->state == IDLE)
303
 
        return PJ_FALSE;
304
 
 
305
 
    if (hreq->state == READING_RESPONSE) {
306
 
        pj_status_t st;
307
 
        pj_size_t rem;
308
 
 
309
 
        if (status != PJ_SUCCESS && status != PJ_EPENDING) {
310
 
            hreq->error = status;
311
 
            pj_http_req_cancel(hreq, PJ_TRUE);
312
 
            return PJ_FALSE;
313
 
        }
314
 
 
315
 
        /* Parse the response. */
316
 
        st = http_response_parse(hreq->pool, &hreq->response,
317
 
                                 data, size, &rem);
318
 
        if (st == PJLIB_UTIL_EHTTPINCHDR) {
319
 
            /* If we already use up all our buffer and still
320
 
             * hasn't received the whole header, return error
321
 
             */
322
 
            if (size == BUF_SIZE) {
323
 
                hreq->error = PJ_ETOOBIG; // response header size is too big
324
 
                pj_http_req_cancel(hreq, PJ_TRUE);
325
 
                return PJ_FALSE;
326
 
            }
327
 
            /* Keep the data if we do not get the whole response header */
328
 
            *remainder = size;
329
 
        } else {
330
 
            hreq->state = READING_DATA;
331
 
            if (st != PJ_SUCCESS) {
332
 
                /* Server replied with an invalid (or unknown) response
333
 
                 * format. We'll just pass the whole (unparsed) response
334
 
                 * to the user.
335
 
                 */
336
 
                hreq->response.data = data;
337
 
                hreq->response.size = size - rem;
338
 
            }
339
 
 
340
 
            /* If code is 401 or 407, find and parse WWW-Authenticate or
341
 
             * Proxy-Authenticate header
342
 
             */
343
 
            if (hreq->response.status_code == 401 ||
344
 
                hreq->response.status_code == 407)
345
 
            {
346
 
                const pj_str_t STR_WWW_AUTH = { "WWW-Authenticate", 16 };
347
 
                const pj_str_t STR_PROXY_AUTH = { "Proxy-Authenticate", 18 };
348
 
                pj_http_resp *response = &hreq->response;
349
 
                pj_http_headers *hdrs = &response->headers;
350
 
                unsigned i;
351
 
 
352
 
                status = PJ_ENOTFOUND;
353
 
                for (i = 0; i < hdrs->count; i++) {
354
 
                    if (!pj_stricmp(&hdrs->header[i].name, &STR_WWW_AUTH) ||
355
 
                        !pj_stricmp(&hdrs->header[i].name, &STR_PROXY_AUTH))
356
 
                    {
357
 
                        status = parse_auth_chal(hreq->pool,
358
 
                                                 &hdrs->header[i].value,
359
 
                                                 &response->auth_chal);
360
 
                        break;
361
 
                    }
362
 
                }
363
 
 
364
 
                /* Check if we should perform authentication */
365
 
                if (status == PJ_SUCCESS &&
366
 
                    hreq->auth_state == AUTH_NONE &&
367
 
                    hreq->response.auth_chal.scheme.slen &&
368
 
                    hreq->param.auth_cred.username.slen &&
369
 
                    (hreq->param.auth_cred.scheme.slen == 0 ||
370
 
                     !pj_stricmp(&hreq->response.auth_chal.scheme,
371
 
                                 &hreq->param.auth_cred.scheme)) &&
372
 
                    (hreq->param.auth_cred.realm.slen == 0 ||
373
 
                     !pj_stricmp(&hreq->response.auth_chal.realm,
374
 
                                 &hreq->param.auth_cred.realm))
375
 
                    )
376
 
                    {
377
 
                    /* Yes, authentication is required and we have been
378
 
                     * configured with credential.
379
 
                     */
380
 
                    restart_req_with_auth(hreq);
381
 
                    if (hreq->auth_state == AUTH_RETRYING) {
382
 
                        /* We'll be resending the request with auth. This
383
 
                         * connection has been closed.
384
 
                         */
385
 
                        return PJ_FALSE;
386
 
                    }
387
 
                }
388
 
            }
389
 
 
390
 
            /* We already received the response header, call the
391
 
             * appropriate callback.
392
 
             */
393
 
            if (hreq->cb.on_response)
394
 
                (*hreq->cb.on_response)(hreq, &hreq->response);
395
 
            hreq->response.data = NULL;
396
 
            hreq->response.size = 0;
397
 
 
398
 
            if (rem > 0 || hreq->response.content_length == 0)
399
 
                return http_on_data_read(asock, (rem == 0 ? NULL:
400
 
                                         (char *)data + size - rem),
401
 
                                         rem, PJ_SUCCESS, NULL);
402
 
        }
403
 
 
404
 
        return PJ_TRUE;
405
 
    }
406
 
 
407
 
    if (hreq->state != READING_DATA)
408
 
        return PJ_FALSE;
409
 
    if (hreq->cb.on_data_read) {
410
 
        /* If application wishes to receive the data once available, call
411
 
         * its callback.
412
 
         */
413
 
        if (size > 0)
414
 
            (*hreq->cb.on_data_read)(hreq, data, size);
415
 
    } else {
416
 
        if (hreq->response.size == 0) {
417
 
            /* If we know the content length, allocate the data based
418
 
             * on that, otherwise we'll use initial buffer size and grow
419
 
             * it later if necessary.
420
 
             */
421
 
            hreq->response.size = (hreq->response.content_length == -1 ?
422
 
                                   INITIAL_DATA_BUF_SIZE :
423
 
                                   hreq->response.content_length);
424
 
            hreq->response.data = pj_pool_alloc(hreq->pool,
425
 
                                                hreq->response.size);
426
 
        }
427
 
 
428
 
        /* If the size of data received exceeds its current size,
429
 
         * grow the buffer by a factor of 2.
430
 
         */
431
 
        if (hreq->tcp_state.current_read_size + size >
432
 
            hreq->response.size)
433
 
        {
434
 
            void *olddata = hreq->response.data;
435
 
 
436
 
            hreq->response.data = pj_pool_alloc(hreq->pool,
437
 
                                                hreq->response.size << 1);
438
 
            pj_memcpy(hreq->response.data, olddata, hreq->response.size);
439
 
            hreq->response.size <<= 1;
440
 
        }
441
 
 
442
 
        /* Append the response data. */
443
 
        pj_memcpy((char *)hreq->response.data +
444
 
                  hreq->tcp_state.current_read_size, data, size);
445
 
    }
446
 
    hreq->tcp_state.current_read_size += size;
447
 
 
448
 
    /* If the total data received so far is equal to the content length
449
 
     * or if it's already EOF.
450
 
     */
451
 
    if ((hreq->response.content_length >=0 &&
452
 
        (pj_ssize_t)hreq->tcp_state.current_read_size >=
453
 
        hreq->response.content_length) ||
454
 
        (status == PJ_EEOF && hreq->response.content_length == -1))
455
 
    {
456
 
        /* Finish reading */
457
 
        http_req_end_request(hreq);
458
 
        hreq->response.size = hreq->tcp_state.current_read_size;
459
 
 
460
 
        /* HTTP request is completed, call the callback. */
461
 
        if (hreq->cb.on_complete) {
462
 
            (*hreq->cb.on_complete)(hreq, PJ_SUCCESS, &hreq->response);
463
 
        }
464
 
 
465
 
        return PJ_FALSE;
466
 
    }
467
 
 
468
 
    /* Error status or premature EOF. */
469
 
    if ((status != PJ_SUCCESS && status != PJ_EPENDING && status != PJ_EEOF)
470
 
        || (status == PJ_EEOF && hreq->response.content_length > -1))
471
 
    {
472
 
        hreq->error = status;
473
 
        pj_http_req_cancel(hreq, PJ_TRUE);
474
 
        return PJ_FALSE;
475
 
    }
476
 
 
477
 
    return PJ_TRUE;
478
 
}
479
 
 
480
 
/* Callback to be called when query has timed out */
481
 
static void on_timeout( pj_timer_heap_t *timer_heap,
482
 
                        struct pj_timer_entry *entry)
483
 
{
484
 
    pj_http_req *hreq = (pj_http_req *) entry->user_data;
485
 
 
486
 
    PJ_UNUSED_ARG(timer_heap);
487
 
 
488
 
    /* Recheck that the request is still not completed, since there is a
489
 
     * slight possibility of race condition (timer elapsed while at the
490
 
     * same time response arrives).
491
 
     */
492
 
    if (hreq->state == READING_COMPLETE) {
493
 
        /* Yeah, we finish on time */
494
 
        return;
495
 
    }
496
 
 
497
 
    /* Invalidate id. */
498
 
    hreq->timer_entry.id = 0;
499
 
 
500
 
    /* Request timed out. */
501
 
    hreq->error = PJ_ETIMEDOUT;
502
 
    pj_http_req_cancel(hreq, PJ_TRUE);
503
 
}
504
 
 
505
 
/* Parse authentication challenge */
506
 
static pj_status_t parse_auth_chal(pj_pool_t *pool, pj_str_t *input,
507
 
                                   pj_http_auth_chal *chal)
508
 
{
509
 
    pj_scanner scanner;
510
 
    const pj_str_t REALM_STR    =    { "realm", 5},
511
 
                NONCE_STR       =    { "nonce", 5},
512
 
                ALGORITHM_STR   =    { "algorithm", 9 },
513
 
                STALE_STR       =    { "stale", 5},
514
 
                QOP_STR         =    { "qop", 3},
515
 
                OPAQUE_STR      =    { "opaque", 6};
516
 
    pj_status_t status = PJ_SUCCESS;
517
 
    PJ_USE_EXCEPTION ;
518
 
 
519
 
    pj_scan_init(&scanner, input->ptr, input->slen, PJ_SCAN_AUTOSKIP_WS,
520
 
                 &on_syntax_error);
521
 
    PJ_TRY {
522
 
        /* Get auth scheme */
523
 
        if (*scanner.curptr == '"') {
524
 
            pj_scan_get_quote(&scanner, '"', '"', &chal->scheme);
525
 
            chal->scheme.ptr++;
526
 
            chal->scheme.slen -= 2;
527
 
        } else {
528
 
            pj_scan_get_until_chr(&scanner, " \t\r\n", &chal->scheme);
529
 
        }
530
 
 
531
 
        /* Loop parsing all parameters */
532
 
        for (;;) {
533
 
            const char *end_param = ", \t\r\n;";
534
 
            pj_str_t name, value;
535
 
 
536
 
            /* Get pair of parameter name and value */
537
 
            value.ptr = NULL;
538
 
            value.slen = 0;
539
 
            pj_scan_get_until_chr(&scanner, "=, \t\r\n", &name);
540
 
            if (*scanner.curptr == '=') {
541
 
                pj_scan_get_char(&scanner);
542
 
                if (!pj_scan_is_eof(&scanner)) {
543
 
                    if (*scanner.curptr == '"' || *scanner.curptr == '\'') {
544
 
                        int quote_char = *scanner.curptr;
545
 
                        pj_scan_get_quote(&scanner, quote_char, quote_char,
546
 
                                          &value);
547
 
                        value.ptr++;
548
 
                        value.slen -= 2;
549
 
                    } else if (!strchr(end_param, *scanner.curptr)) {
550
 
                        pj_scan_get_until_chr(&scanner, end_param, &value);
551
 
                    }
552
 
                }
553
 
                value = pj_str_unescape(pool, &value);
554
 
            }
555
 
 
556
 
            if (!pj_stricmp(&name, &REALM_STR)) {
557
 
                chal->realm = value;
558
 
 
559
 
            } else if (!pj_stricmp(&name, &NONCE_STR)) {
560
 
                chal->nonce = value;
561
 
 
562
 
            } else if (!pj_stricmp(&name, &ALGORITHM_STR)) {
563
 
                chal->algorithm = value;
564
 
 
565
 
            } else if (!pj_stricmp(&name, &OPAQUE_STR)) {
566
 
                chal->opaque = value;
567
 
 
568
 
            } else if (!pj_stricmp(&name, &QOP_STR)) {
569
 
                chal->qop = value;
570
 
 
571
 
            } else if (!pj_stricmp(&name, &STALE_STR)) {
572
 
                chal->stale = value.slen &&
573
 
                              (*value.ptr != '0') &&
574
 
                              (*value.ptr != 'f') &&
575
 
                              (*value.ptr != 'F');
576
 
 
577
 
            }
578
 
 
579
 
            /* Eat comma */
580
 
            if (!pj_scan_is_eof(&scanner) && *scanner.curptr == ',')
581
 
                pj_scan_get_char(&scanner);
582
 
            else
583
 
                break;
584
 
        }
585
 
 
586
 
    }
587
 
    PJ_CATCH_ANY {
588
 
        status = PJ_GET_EXCEPTION();
589
 
        pj_bzero(chal, sizeof(*chal));
590
 
        TRACE_((THIS_FILE, "Error: parsing of auth header failed"));
591
 
    }
592
 
    PJ_END;
593
 
    pj_scan_fini(&scanner);
594
 
    return status;
595
 
}
596
 
 
597
 
/* The same as #pj_http_headers_add_elmt() with char * as
598
 
 * its parameters.
599
 
 */
600
 
PJ_DEF(pj_status_t) pj_http_headers_add_elmt2(pj_http_headers *headers,
601
 
                                              char *name, char *val)
602
 
{
603
 
    pj_str_t f, v;
604
 
    pj_cstr(&f, name);
605
 
    pj_cstr(&v, val);
606
 
    return pj_http_headers_add_elmt(headers, &f, &v);
607
 
}
608
 
 
609
 
PJ_DEF(pj_status_t) pj_http_headers_add_elmt(pj_http_headers *headers,
610
 
                                             pj_str_t *name,
611
 
                                             pj_str_t *val)
612
 
{
613
 
    PJ_ASSERT_RETURN(headers && name && val, PJ_FALSE);
614
 
    if (headers->count >= PJ_HTTP_HEADER_SIZE)
615
 
        return PJ_ETOOMANY;
616
 
    pj_strassign(&headers->header[headers->count].name, name);
617
 
    pj_strassign(&headers->header[headers->count++].value, val);
618
 
    return PJ_SUCCESS;
619
 
}
620
 
 
621
 
static pj_status_t http_response_parse(pj_pool_t *pool,
622
 
                                       pj_http_resp *response,
623
 
                                       void *data, pj_size_t size,
624
 
                                       pj_size_t *remainder)
625
 
{
626
 
    pj_size_t i;
627
 
    char *cptr;
628
 
    char *end_status, *newdata;
629
 
    pj_scanner scanner;
630
 
    pj_str_t s;
631
 
    const pj_str_t STR_CONTENT_LENGTH = { CONTENT_LENGTH, 14 };
632
 
    pj_status_t status;
633
 
 
634
 
    PJ_USE_EXCEPTION;
635
 
 
636
 
    PJ_ASSERT_RETURN(response, PJ_EINVAL);
637
 
    if (size < 2)
638
 
        return PJLIB_UTIL_EHTTPINCHDR;
639
 
    /* Detect whether we already receive the response's status-line
640
 
     * and its headers. We're looking for a pair of CRLFs. A pair of
641
 
     * LFs is also supported although it is not RFC standard.
642
 
     */
643
 
    cptr = (char *)data;
644
 
    for (i = 1, cptr++; i < size; i++, cptr++) {
645
 
        if (*cptr == '\n') {
646
 
            if (*(cptr - 1) == '\n')
647
 
                break;
648
 
            if (*(cptr - 1) == '\r') {
649
 
                if (i >= 3 && *(cptr - 2) == '\n' && *(cptr - 3) == '\r')
650
 
                    break;
651
 
            }
652
 
        }
653
 
    }
654
 
    if (i == size)
655
 
        return PJLIB_UTIL_EHTTPINCHDR;
656
 
    *remainder = size - 1 - i;
657
 
 
658
 
    pj_bzero(response, sizeof(response));
659
 
    response->content_length = -1;
660
 
 
661
 
    newdata = (char*) pj_pool_alloc(pool, i);
662
 
    pj_memcpy(newdata, data, i);
663
 
 
664
 
    /* Parse the status-line. */
665
 
    pj_scan_init(&scanner, newdata, i, 0, &on_syntax_error);
666
 
    PJ_TRY {
667
 
        pj_scan_get_until_ch(&scanner, ' ', &response->version);
668
 
        pj_scan_advance_n(&scanner, 1, PJ_FALSE);
669
 
        pj_scan_get_until_ch(&scanner, ' ', &s);
670
 
        response->status_code = (pj_uint16_t)pj_strtoul(&s);
671
 
        pj_scan_advance_n(&scanner, 1, PJ_FALSE);
672
 
        pj_scan_get_until_ch(&scanner, '\n', &response->reason);
673
 
        if (response->reason.ptr[response->reason.slen-1] == '\r')
674
 
            response->reason.slen--;
675
 
    }
676
 
    PJ_CATCH_ANY {
677
 
        pj_scan_fini(&scanner);
678
 
        return PJ_GET_EXCEPTION();
679
 
    }
680
 
    PJ_END;
681
 
 
682
 
    end_status = scanner.curptr;
683
 
    pj_scan_fini(&scanner);
684
 
 
685
 
    /* Parse the response headers. */
686
 
    size = i - 2 - (end_status - newdata);
687
 
    if (size > 0) {
688
 
        status = http_headers_parse(end_status + 1, size,
689
 
                                    &response->headers);
690
 
    } else {
691
 
        status = PJ_SUCCESS;
692
 
    }
693
 
 
694
 
    /* Find content-length header field. */
695
 
    for (i = 0; i < response->headers.count; i++) {
696
 
        if (!pj_stricmp(&response->headers.header[i].name,
697
 
                        &STR_CONTENT_LENGTH))
698
 
        {
699
 
            response->content_length =
700
 
                pj_strtoul(&response->headers.header[i].value);
701
 
            /* If content length is zero, make sure that it is because the
702
 
             * header value is really zero and not due to parsing error.
703
 
             */
704
 
            if (response->content_length == 0) {
705
 
                if (pj_strcmp2(&response->headers.header[i].value, "0")) {
706
 
                    response->content_length = -1;
707
 
                }
708
 
            }
709
 
            break;
710
 
        }
711
 
    }
712
 
 
713
 
    return status;
714
 
}
715
 
 
716
 
static pj_status_t http_headers_parse(char *hdata, pj_size_t size,
717
 
                                      pj_http_headers *headers)
718
 
{
719
 
    pj_scanner scanner;
720
 
    pj_str_t s, s2;
721
 
    pj_status_t status;
722
 
    PJ_USE_EXCEPTION;
723
 
 
724
 
    PJ_ASSERT_RETURN(headers, PJ_EINVAL);
725
 
 
726
 
    pj_scan_init(&scanner, hdata, size, 0, &on_syntax_error);
727
 
 
728
 
    /* Parse each line of header field consisting of header field name and
729
 
     * value, separated by ":" and any number of white spaces.
730
 
     */
731
 
    PJ_TRY {
732
 
        do {
733
 
            pj_scan_get_until_chr(&scanner, ":\n", &s);
734
 
            if (*scanner.curptr == ':') {
735
 
                pj_scan_advance_n(&scanner, 1, PJ_TRUE);
736
 
                pj_scan_get_until_ch(&scanner, '\n', &s2);
737
 
                if (s2.ptr[s2.slen-1] == '\r')
738
 
                    s2.slen--;
739
 
                status = pj_http_headers_add_elmt(headers, &s, &s2);
740
 
                if (status != PJ_SUCCESS)
741
 
                    PJ_THROW(status);
742
 
            }
743
 
            pj_scan_advance_n(&scanner, 1, PJ_TRUE);
744
 
            /* Finish parsing */
745
 
            if (pj_scan_is_eof(&scanner))
746
 
                break;
747
 
        } while (1);
748
 
    }
749
 
    PJ_CATCH_ANY {
750
 
        pj_scan_fini(&scanner);
751
 
        return PJ_GET_EXCEPTION();
752
 
    }
753
 
    PJ_END;
754
 
 
755
 
    pj_scan_fini(&scanner);
756
 
 
757
 
    return PJ_SUCCESS;
758
 
}
759
 
 
760
 
PJ_DEF(void) pj_http_req_param_default(pj_http_req_param *param)
761
 
{
762
 
    pj_assert(param);
763
 
    pj_bzero(param, sizeof(*param));
764
 
    param->addr_family = pj_AF_INET();
765
 
    pj_strset2(&param->method, (char*)http_method_names[HTTP_GET]);
766
 
    pj_strset2(&param->version, (char*)HTTP_1_0);
767
 
    param->timeout.msec = PJ_HTTP_DEFAULT_TIMEOUT;
768
 
    pj_time_val_normalize(&param->timeout);
769
 
    param->max_retries = 3;
770
 
}
771
 
 
772
 
/* Get the location of '@' character to indicate the end of
773
 
 * user:passwd part of an URI. If user:passwd part is not
774
 
 * present, NULL will be returned.
775
 
 */
776
 
static char *get_url_at_pos(const char *str, long len)
777
 
{
778
 
    const char *end = str + len;
779
 
    const char *p = str;
780
 
 
781
 
    /* skip scheme: */
782
 
    while (p!=end && *p!='/') ++p;
783
 
    if (p!=end && *p=='/') ++p;
784
 
    if (p!=end && *p=='/') ++p;
785
 
    if (p==end) return NULL;
786
 
 
787
 
    for (; p!=end; ++p) {
788
 
        switch (*p) {
789
 
        case '/':
790
 
            return NULL;
791
 
        case '@':
792
 
            return (char*)p;
793
 
        }
794
 
    }
795
 
 
796
 
    return NULL;
797
 
}
798
 
 
799
 
 
800
 
PJ_DEF(pj_status_t) pj_http_req_parse_url(const pj_str_t *url,
801
 
                                          pj_http_url *hurl)
802
 
{
803
 
    pj_scanner scanner;
804
 
    int len = url->slen;
805
 
    PJ_USE_EXCEPTION;
806
 
 
807
 
    if (!len) return -1;
808
 
 
809
 
    pj_bzero(hurl, sizeof(*hurl));
810
 
    pj_scan_init(&scanner, url->ptr, url->slen, 0, &on_syntax_error);
811
 
 
812
 
    PJ_TRY {
813
 
        pj_str_t s;
814
 
 
815
 
        /* Exhaust any whitespaces. */
816
 
        pj_scan_skip_whitespace(&scanner);
817
 
 
818
 
        /* Parse the protocol */
819
 
        pj_scan_get_until_ch(&scanner, ':', &s);
820
 
        if (!pj_stricmp2(&s, http_protocol_names[PROTOCOL_HTTP])) {
821
 
            pj_strset2(&hurl->protocol,
822
 
                       (char*)http_protocol_names[PROTOCOL_HTTP]);
823
 
        } else if (!pj_stricmp2(&s, http_protocol_names[PROTOCOL_HTTPS])) {
824
 
            pj_strset2(&hurl->protocol,
825
 
                       (char*)http_protocol_names[PROTOCOL_HTTPS]);
826
 
        } else {
827
 
            PJ_THROW(PJ_ENOTSUP); // unsupported protocol
828
 
        }
829
 
 
830
 
        if (pj_scan_strcmp(&scanner, "://", 3)) {
831
 
            PJ_THROW(PJLIB_UTIL_EHTTPINURL); // no "://" after protocol name
832
 
        }
833
 
        pj_scan_advance_n(&scanner, 3, PJ_FALSE);
834
 
 
835
 
        if (get_url_at_pos(url->ptr, url->slen)) {
836
 
            /* Parse username and password */
837
 
            pj_scan_get_until_chr(&scanner, ":@", &hurl->username);
838
 
            if (*scanner.curptr == ':') {
839
 
                pj_scan_get_char(&scanner);
840
 
                pj_scan_get_until_chr(&scanner, "@", &hurl->passwd);
841
 
            } else {
842
 
                hurl->passwd.slen = 0;
843
 
            }
844
 
            pj_scan_get_char(&scanner);
845
 
        }
846
 
 
847
 
        /* Parse the host and port number (if any) */
848
 
        pj_scan_get_until_chr(&scanner, ":/", &s);
849
 
        pj_strassign(&hurl->host, &s);
850
 
        if (hurl->host.slen==0)
851
 
            PJ_THROW(PJ_EINVAL);
852
 
        if (pj_scan_is_eof(&scanner) || *scanner.curptr == '/') {
853
 
            /* No port number specified */
854
 
            /* Assume default http/https port number */
855
 
            hurl->port = get_http_default_port(&hurl->protocol);
856
 
            pj_assert(hurl->port > 0);
857
 
        } else {
858
 
            pj_scan_advance_n(&scanner, 1, PJ_FALSE);
859
 
            pj_scan_get_until_ch(&scanner, '/', &s);
860
 
            /* Parse the port number */
861
 
            hurl->port = (pj_uint16_t)pj_strtoul(&s);
862
 
            if (!hurl->port)
863
 
                PJ_THROW(PJLIB_UTIL_EHTTPINPORT); // invalid port number
864
 
        }
865
 
 
866
 
        if (!pj_scan_is_eof(&scanner)) {
867
 
            hurl->path.ptr = scanner.curptr;
868
 
            hurl->path.slen = scanner.end - scanner.curptr;
869
 
        } else {
870
 
            /* no path, append '/' */
871
 
            pj_cstr(&hurl->path, "/");
872
 
        }
873
 
    }
874
 
    PJ_CATCH_ANY {
875
 
        pj_scan_fini(&scanner);
876
 
        return PJ_GET_EXCEPTION();
877
 
    }
878
 
    PJ_END;
879
 
 
880
 
    pj_scan_fini(&scanner);
881
 
    return PJ_SUCCESS;
882
 
}
883
 
 
884
 
PJ_DEF(void) pj_http_req_set_timeout(pj_http_req *http_req,
885
 
                                     const pj_time_val* timeout)
886
 
{
887
 
    pj_memcpy(&http_req->param.timeout, timeout, sizeof(*timeout));
888
 
}
889
 
 
890
 
PJ_DEF(pj_status_t) pj_http_req_create(pj_pool_t *pool,
891
 
                                       const pj_str_t *url,
892
 
                                       pj_timer_heap_t *timer,
893
 
                                       pj_ioqueue_t *ioqueue,
894
 
                                       const pj_http_req_param *param,
895
 
                                       const pj_http_req_callback *hcb,
896
 
                                       pj_http_req **http_req)
897
 
{
898
 
    pj_pool_t *own_pool;
899
 
    pj_http_req *hreq;
900
 
    char *at_pos;
901
 
    pj_status_t status;
902
 
 
903
 
    PJ_ASSERT_RETURN(pool && url && timer && ioqueue &&
904
 
                     hcb && http_req, PJ_EINVAL);
905
 
 
906
 
    *http_req = NULL;
907
 
    own_pool = pj_pool_create(pool->factory, NULL, INITIAL_POOL_SIZE,
908
 
                              POOL_INCREMENT_SIZE, NULL);
909
 
    hreq = PJ_POOL_ZALLOC_T(own_pool, struct pj_http_req);
910
 
    if (!hreq)
911
 
        return PJ_ENOMEM;
912
 
 
913
 
    /* Initialization */
914
 
    hreq->pool = own_pool;
915
 
    hreq->ioqueue = ioqueue;
916
 
    hreq->timer = timer;
917
 
    hreq->asock = NULL;
918
 
    pj_memcpy(&hreq->cb, hcb, sizeof(*hcb));
919
 
    hreq->state = IDLE;
920
 
    hreq->resolved = PJ_FALSE;
921
 
    hreq->buffer.ptr = NULL;
922
 
    pj_timer_entry_init(&hreq->timer_entry, 0, hreq, &on_timeout);
923
 
 
924
 
    /* Initialize parameter */
925
 
    if (param) {
926
 
        pj_memcpy(&hreq->param, param, sizeof(*param));
927
 
        /* TODO: validate the param here
928
 
         * Should we validate the method as well? If yes, based on all HTTP
929
 
         * methods or based on supported methods only? For the later, one
930
 
         * drawback would be that you can't use this if the method is not
931
 
         * officially supported
932
 
         */
933
 
        PJ_ASSERT_RETURN(hreq->param.addr_family==PJ_AF_UNSPEC ||
934
 
                         hreq->param.addr_family==PJ_AF_INET ||
935
 
                         hreq->param.addr_family==PJ_AF_INET6, PJ_EAFNOTSUP);
936
 
        PJ_ASSERT_RETURN(!pj_strcmp2(&hreq->param.version, HTTP_1_0) ||
937
 
                         !pj_strcmp2(&hreq->param.version, HTTP_1_1),
938
 
                         PJ_ENOTSUP);
939
 
        pj_time_val_normalize(&hreq->param.timeout);
940
 
    } else {
941
 
        pj_http_req_param_default(&hreq->param);
942
 
    }
943
 
 
944
 
    /* Parse the URL */
945
 
    if (!pj_strdup_with_null(hreq->pool, &hreq->url, url)) {
946
 
        pj_pool_release(hreq->pool);
947
 
        return PJ_ENOMEM;
948
 
    }
949
 
    status = pj_http_req_parse_url(&hreq->url, &hreq->hurl);
950
 
    if (status != PJ_SUCCESS) {
951
 
        pj_pool_release(hreq->pool);
952
 
        return status; // Invalid URL supplied
953
 
    }
954
 
 
955
 
    /* If URL contains username/password, move them to credential and
956
 
     * remove them from the URL.
957
 
     */
958
 
    if ((at_pos=get_url_at_pos(hreq->url.ptr, hreq->url.slen)) != NULL) {
959
 
        pj_str_t tmp;
960
 
        char *user_pos = pj_strchr(&hreq->url, '/');
961
 
        int removed_len;
962
 
 
963
 
        /* Save credential first, unescape the string */
964
 
        tmp = pj_str_unescape(hreq->pool, &hreq->hurl.username);;
965
 
        pj_strdup(hreq->pool, &hreq->param.auth_cred.username, &tmp);
966
 
 
967
 
        tmp = pj_str_unescape(hreq->pool, &hreq->hurl.passwd);
968
 
        pj_strdup(hreq->pool, &hreq->param.auth_cred.data, &tmp);
969
 
 
970
 
        hreq->hurl.username.ptr = hreq->hurl.passwd.ptr = NULL;
971
 
        hreq->hurl.username.slen = hreq->hurl.passwd.slen = 0;
972
 
 
973
 
        /* Remove "username:password@" from the URL */
974
 
        pj_assert(user_pos != 0 && user_pos < at_pos);
975
 
        user_pos += 2;
976
 
        removed_len = at_pos + 1 - user_pos;
977
 
        pj_memmove(user_pos, at_pos+1, hreq->url.ptr+hreq->url.slen-at_pos-1);
978
 
        hreq->url.slen -= removed_len;
979
 
 
980
 
        /* Need to adjust hostname and path pointers due to memmove*/
981
 
        if (hreq->hurl.host.ptr > user_pos &&
982
 
            hreq->hurl.host.ptr < user_pos + hreq->url.slen)
983
 
        {
984
 
            hreq->hurl.host.ptr -= removed_len;
985
 
        }
986
 
        /* path may come from a string constant, don't shift it if so */
987
 
        if (hreq->hurl.path.ptr > user_pos &&
988
 
            hreq->hurl.path.ptr < user_pos + hreq->url.slen)
989
 
        {
990
 
            hreq->hurl.path.ptr -= removed_len;
991
 
        }
992
 
    }
993
 
 
994
 
    *http_req = hreq;
995
 
    return PJ_SUCCESS;
996
 
}
997
 
 
998
 
PJ_DEF(pj_bool_t) pj_http_req_is_running(const pj_http_req *http_req)
999
 
{
1000
 
   PJ_ASSERT_RETURN(http_req, PJ_FALSE);
1001
 
   return (http_req->state != IDLE);
1002
 
}
1003
 
 
1004
 
PJ_DEF(void*) pj_http_req_get_user_data(pj_http_req *http_req)
1005
 
{
1006
 
    PJ_ASSERT_RETURN(http_req, NULL);
1007
 
    return http_req->param.user_data;
1008
 
}
1009
 
 
1010
 
static pj_status_t start_http_req(pj_http_req *http_req,
1011
 
                                  pj_bool_t notify_on_fail)
1012
 
{
1013
 
    pj_sock_t sock = PJ_INVALID_SOCKET;
1014
 
    pj_status_t status;
1015
 
    pj_activesock_cb asock_cb;
1016
 
    int retry = 0;
1017
 
 
1018
 
    PJ_ASSERT_RETURN(http_req, PJ_EINVAL);
1019
 
    /* Http request is not idle, a request was initiated before and
1020
 
     * is still in progress
1021
 
     */
1022
 
    PJ_ASSERT_RETURN(http_req->state == IDLE, PJ_EBUSY);
1023
 
 
1024
 
    /* Reset few things to make sure restarting works */
1025
 
    http_req->error = 0;
1026
 
    http_req->response.headers.count = 0;
1027
 
    pj_bzero(&http_req->tcp_state, sizeof(http_req->tcp_state));
1028
 
 
1029
 
    if (!http_req->resolved) {
1030
 
        /* Resolve the Internet address of the host */
1031
 
        status = pj_sockaddr_init(http_req->param.addr_family,
1032
 
                                  &http_req->addr, &http_req->hurl.host,
1033
 
                                  http_req->hurl.port);
1034
 
        if (status != PJ_SUCCESS ||
1035
 
            !pj_sockaddr_has_addr(&http_req->addr) ||
1036
 
            (http_req->param.addr_family==pj_AF_INET() &&
1037
 
             http_req->addr.ipv4.sin_addr.s_addr==PJ_INADDR_NONE))
1038
 
        {
1039
 
            goto on_return;
1040
 
        }
1041
 
        http_req->resolved = PJ_TRUE;
1042
 
    }
1043
 
 
1044
 
    status = pj_sock_socket(http_req->param.addr_family, pj_SOCK_STREAM(),
1045
 
                            0, &sock);
1046
 
    if (status != PJ_SUCCESS)
1047
 
        goto on_return; // error creating socket
1048
 
 
1049
 
    pj_bzero(&asock_cb, sizeof(asock_cb));
1050
 
    asock_cb.on_data_read = &http_on_data_read;
1051
 
    asock_cb.on_data_sent = &http_on_data_sent;
1052
 
    asock_cb.on_connect_complete = &http_on_connect;
1053
 
 
1054
 
    do
1055
 
    {
1056
 
        pj_sockaddr_in bound_addr;
1057
 
        pj_uint16_t port = 0;
1058
 
 
1059
 
        /* If we are using port restriction.
1060
 
         * Get a random port within the range
1061
 
         */
1062
 
        if (http_req->param.source_port_range_start != 0) {
1063
 
            port = (pj_uint16_t)
1064
 
                   (http_req->param.source_port_range_start +
1065
 
                    (pj_rand() % http_req->param.source_port_range_size));
1066
 
        }
1067
 
 
1068
 
        pj_sockaddr_in_init(&bound_addr, NULL, port);
1069
 
        status = pj_sock_bind(sock, &bound_addr, sizeof(bound_addr));
1070
 
 
1071
 
    } while (status != PJ_SUCCESS && (retry++ < http_req->param.max_retries));
1072
 
 
1073
 
    if (status != PJ_SUCCESS) {
1074
 
        PJ_PERROR(1,(THIS_FILE, status,
1075
 
                     "Unable to bind to the requested port"));
1076
 
        pj_sock_close(sock);
1077
 
        goto on_return;
1078
 
    }
1079
 
 
1080
 
    // TODO: should we set whole data to 0 by default?
1081
 
    // or add it in the param?
1082
 
    status = pj_activesock_create(http_req->pool, sock, pj_SOCK_STREAM(),
1083
 
                                  NULL, http_req->ioqueue,
1084
 
                                  &asock_cb, http_req, &http_req->asock);
1085
 
    if (status != PJ_SUCCESS) {
1086
 
        pj_sock_close(sock);
1087
 
        goto on_return; // error creating activesock
1088
 
    }
1089
 
 
1090
 
    /* Schedule timeout timer for the request */
1091
 
    pj_assert(http_req->timer_entry.id == 0);
1092
 
    http_req->timer_entry.id = 1;
1093
 
    status = pj_timer_heap_schedule(http_req->timer, &http_req->timer_entry,
1094
 
                                    &http_req->param.timeout);
1095
 
    if (status != PJ_SUCCESS) {
1096
 
        http_req->timer_entry.id = 0;
1097
 
        goto on_return; // error scheduling timer
1098
 
    }
1099
 
 
1100
 
    /* Connect to host */
1101
 
    http_req->state = CONNECTING;
1102
 
    status = pj_activesock_start_connect(http_req->asock, http_req->pool,
1103
 
                                         (pj_sock_t *)&(http_req->addr),
1104
 
                                         pj_sockaddr_get_len(&http_req->addr));
1105
 
    if (status == PJ_SUCCESS) {
1106
 
        http_req->state = SENDING_REQUEST;
1107
 
        status =  http_req_start_sending(http_req);
1108
 
        if (status != PJ_SUCCESS)
1109
 
            goto on_return;
1110
 
    } else if (status != PJ_EPENDING) {
1111
 
        goto on_return; // error connecting
1112
 
    }
1113
 
 
1114
 
    return PJ_SUCCESS;
1115
 
 
1116
 
on_return:
1117
 
    http_req->error = status;
1118
 
    if (notify_on_fail)
1119
 
        pj_http_req_cancel(http_req, PJ_TRUE);
1120
 
    else
1121
 
        http_req_end_request(http_req);
1122
 
 
1123
 
    return status;
1124
 
}
1125
 
 
1126
 
/* Starts an asynchronous HTTP request to the URL specified. */
1127
 
PJ_DEF(pj_status_t) pj_http_req_start(pj_http_req *http_req)
1128
 
{
1129
 
    return start_http_req(http_req, PJ_FALSE);
1130
 
}
1131
 
 
1132
 
/* Respond to basic authentication challenge */
1133
 
static pj_status_t auth_respond_basic(pj_http_req *hreq)
1134
 
{
1135
 
    /* Basic authentication:
1136
 
     *      credentials       = "Basic" basic-credentials
1137
 
     *      basic-credentials = base64-user-pass
1138
 
     *      base64-user-pass  = <base64 [4] encoding of user-pass>
1139
 
     *      user-pass         = userid ":" password
1140
 
     *
1141
 
     * Sample:
1142
 
     *       Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==
1143
 
     */
1144
 
    pj_str_t user_pass;
1145
 
    pj_http_header_elmt *phdr;
1146
 
    int len;
1147
 
 
1148
 
    /* Use send buffer to store userid ":" password */
1149
 
    user_pass.ptr = hreq->buffer.ptr;
1150
 
    pj_strcpy(&user_pass, &hreq->param.auth_cred.username);
1151
 
    pj_strcat2(&user_pass, ":");
1152
 
    pj_strcat(&user_pass, &hreq->param.auth_cred.data);
1153
 
 
1154
 
    /* Create Authorization header */
1155
 
    phdr = &hreq->param.headers.header[hreq->param.headers.count++];
1156
 
    pj_bzero(phdr, sizeof(*phdr));
1157
 
    if (hreq->response.status_code == 401)
1158
 
        phdr->name = pj_str("Authorization");
1159
 
    else
1160
 
        phdr->name = pj_str("Proxy-Authorization");
1161
 
 
1162
 
    len = PJ_BASE256_TO_BASE64_LEN(user_pass.slen) + 10;
1163
 
    phdr->value.ptr = (char*)pj_pool_alloc(hreq->pool, len);
1164
 
    phdr->value.slen = 0;
1165
 
 
1166
 
    pj_strcpy2(&phdr->value, "Basic ");
1167
 
    len -= phdr->value.slen;
1168
 
    pj_base64_encode((pj_uint8_t*)user_pass.ptr, (int)user_pass.slen,
1169
 
                     phdr->value.ptr + phdr->value.slen, &len);
1170
 
    phdr->value.slen += len;
1171
 
 
1172
 
    return PJ_SUCCESS;
1173
 
}
1174
 
 
1175
 
/** Length of digest string. */
1176
 
#define MD5_STRLEN 32
1177
 
/* A macro just to get rid of type mismatch between char and unsigned char */
1178
 
#define MD5_APPEND(pms,buf,len) pj_md5_update(pms, (const pj_uint8_t*)buf, len)
1179
 
 
1180
 
/* Transform digest to string.
1181
 
 * output must be at least PJSIP_MD5STRLEN+1 bytes.
1182
 
 *
1183
 
 * NOTE: THE OUTPUT STRING IS NOT NULL TERMINATED!
1184
 
 */
1185
 
static void digest2str(const unsigned char digest[], char *output)
1186
 
{
1187
 
    int i;
1188
 
    for (i = 0; i<16; ++i) {
1189
 
        pj_val_to_hex_digit(digest[i], output);
1190
 
        output += 2;
1191
 
    }
1192
 
}
1193
 
 
1194
 
static void auth_create_digest_response(pj_str_t *result,
1195
 
                                        const pj_http_auth_cred *cred,
1196
 
                                        const pj_str_t *nonce,
1197
 
                                        const pj_str_t *nc,
1198
 
                                        const pj_str_t *cnonce,
1199
 
                                        const pj_str_t *qop,
1200
 
                                        const pj_str_t *uri,
1201
 
                                        const pj_str_t *realm,
1202
 
                                        const pj_str_t *method)
1203
 
{
1204
 
    char ha1[MD5_STRLEN];
1205
 
    char ha2[MD5_STRLEN];
1206
 
    unsigned char digest[16];
1207
 
    pj_md5_context pms;
1208
 
 
1209
 
    pj_assert(result->slen >= MD5_STRLEN);
1210
 
 
1211
 
    TRACE_((THIS_FILE, "Begin creating digest"));
1212
 
 
1213
 
    if (cred->data_type == 0) {
1214
 
        /***
1215
 
         *** ha1 = MD5(username ":" realm ":" password)
1216
 
         ***/
1217
 
        pj_md5_init(&pms);
1218
 
        MD5_APPEND( &pms, cred->username.ptr, cred->username.slen);
1219
 
        MD5_APPEND( &pms, ":", 1);
1220
 
        MD5_APPEND( &pms, realm->ptr, realm->slen);
1221
 
        MD5_APPEND( &pms, ":", 1);
1222
 
        MD5_APPEND( &pms, cred->data.ptr, cred->data.slen);
1223
 
        pj_md5_final(&pms, digest);
1224
 
 
1225
 
        digest2str(digest, ha1);
1226
 
 
1227
 
    } else if (cred->data_type == 1) {
1228
 
        pj_assert(cred->data.slen == 32);
1229
 
        pj_memcpy( ha1, cred->data.ptr, cred->data.slen );
1230
 
    } else {
1231
 
        pj_assert(!"Invalid data_type");
1232
 
    }
1233
 
 
1234
 
    TRACE_((THIS_FILE, "  ha1=%.32s", ha1));
1235
 
 
1236
 
    /***
1237
 
     *** ha2 = MD5(method ":" req_uri)
1238
 
     ***/
1239
 
    pj_md5_init(&pms);
1240
 
    MD5_APPEND( &pms, method->ptr, method->slen);
1241
 
    MD5_APPEND( &pms, ":", 1);
1242
 
    MD5_APPEND( &pms, uri->ptr, uri->slen);
1243
 
    pj_md5_final(&pms, digest);
1244
 
    digest2str(digest, ha2);
1245
 
 
1246
 
    TRACE_((THIS_FILE, "  ha2=%.32s", ha2));
1247
 
 
1248
 
    /***
1249
 
     *** When qop is not used:
1250
 
     ***    response = MD5(ha1 ":" nonce ":" ha2)
1251
 
     ***
1252
 
     *** When qop=auth is used:
1253
 
     ***    response = MD5(ha1 ":" nonce ":" nc ":" cnonce ":" qop ":" ha2)
1254
 
     ***/
1255
 
    pj_md5_init(&pms);
1256
 
    MD5_APPEND( &pms, ha1, MD5_STRLEN);
1257
 
    MD5_APPEND( &pms, ":", 1);
1258
 
    MD5_APPEND( &pms, nonce->ptr, nonce->slen);
1259
 
    if (qop && qop->slen != 0) {
1260
 
        MD5_APPEND( &pms, ":", 1);
1261
 
        MD5_APPEND( &pms, nc->ptr, nc->slen);
1262
 
        MD5_APPEND( &pms, ":", 1);
1263
 
        MD5_APPEND( &pms, cnonce->ptr, cnonce->slen);
1264
 
        MD5_APPEND( &pms, ":", 1);
1265
 
        MD5_APPEND( &pms, qop->ptr, qop->slen);
1266
 
    }
1267
 
    MD5_APPEND( &pms, ":", 1);
1268
 
    MD5_APPEND( &pms, ha2, MD5_STRLEN);
1269
 
 
1270
 
    /* This is the final response digest. */
1271
 
    pj_md5_final(&pms, digest);
1272
 
 
1273
 
    /* Convert digest to string and store in chal->response. */
1274
 
    result->slen = MD5_STRLEN;
1275
 
    digest2str(digest, result->ptr);
1276
 
 
1277
 
    TRACE_((THIS_FILE, "  digest=%.32s", result->ptr));
1278
 
    TRACE_((THIS_FILE, "Digest created"));
1279
 
}
1280
 
 
1281
 
/* Find out if qop offer contains "auth" token */
1282
 
static pj_bool_t auth_has_qop( pj_pool_t *pool, const pj_str_t *qop_offer)
1283
 
{
1284
 
    pj_str_t qop;
1285
 
    char *p;
1286
 
 
1287
 
    pj_strdup_with_null( pool, &qop, qop_offer);
1288
 
    p = qop.ptr;
1289
 
    while (*p) {
1290
 
        *p = (char)pj_tolower(*p);
1291
 
        ++p;
1292
 
    }
1293
 
 
1294
 
    p = qop.ptr;
1295
 
    while (*p) {
1296
 
        if (*p=='a' && *(p+1)=='u' && *(p+2)=='t' && *(p+3)=='h') {
1297
 
            int e = *(p+4);
1298
 
            if (e=='"' || e==',' || e==0)
1299
 
                return PJ_TRUE;
1300
 
            else
1301
 
                p += 4;
1302
 
        } else {
1303
 
            ++p;
1304
 
        }
1305
 
    }
1306
 
 
1307
 
    return PJ_FALSE;
1308
 
}
1309
 
 
1310
 
#define STR_PREC(s) (int)(s).slen, (s).ptr
1311
 
 
1312
 
/* Respond to digest authentication */
1313
 
static pj_status_t auth_respond_digest(pj_http_req *hreq)
1314
 
{
1315
 
    const pj_http_auth_chal *chal = &hreq->response.auth_chal;
1316
 
    const pj_http_auth_cred *cred = &hreq->param.auth_cred;
1317
 
    pj_http_header_elmt *phdr;
1318
 
    char digest_response_buf[MD5_STRLEN];
1319
 
    int len;
1320
 
    pj_str_t digest_response;
1321
 
 
1322
 
    /* Check algorithm is supported. We only support MD5 */
1323
 
    if (chal->algorithm.slen!=0 &&
1324
 
        pj_stricmp2(&chal->algorithm, "MD5"))
1325
 
    {
1326
 
        TRACE_((THIS_FILE, "Error: Unsupported digest algorithm \"%.*s\"",
1327
 
                  chal->algorithm.slen, chal->algorithm.ptr));
1328
 
        return PJ_ENOTSUP;
1329
 
    }
1330
 
 
1331
 
    /* Add Authorization header */
1332
 
    phdr = &hreq->param.headers.header[hreq->param.headers.count++];
1333
 
    pj_bzero(phdr, sizeof(*phdr));
1334
 
    if (hreq->response.status_code == 401)
1335
 
        phdr->name = pj_str("Authorization");
1336
 
    else
1337
 
        phdr->name = pj_str("Proxy-Authorization");
1338
 
 
1339
 
    /* Allocate space for the header */
1340
 
    len = 8 + /* Digest */
1341
 
          16 + hreq->param.auth_cred.username.slen + /* username= */
1342
 
          12 + chal->realm.slen + /* realm= */
1343
 
          12 + chal->nonce.slen + /* nonce= */
1344
 
          8 + hreq->hurl.path.slen + /* uri= */
1345
 
          16 + /* algorithm=MD5 */
1346
 
          16 + MD5_STRLEN + /* response= */
1347
 
          12 + /* qop=auth */
1348
 
          8 + /* nc=.. */
1349
 
          30 + /* cnonce= */
1350
 
          12 + chal->opaque.slen + /* opaque=".." */
1351
 
          0;
1352
 
    phdr->value.ptr = (char*)pj_pool_alloc(hreq->pool, len);
1353
 
 
1354
 
    /* Configure buffer to temporarily store the digest */
1355
 
    digest_response.ptr = digest_response_buf;
1356
 
    digest_response.slen = MD5_STRLEN;
1357
 
 
1358
 
    if (chal->qop.slen == 0) {
1359
 
        const pj_str_t STR_MD5 = { "MD5", 3 };
1360
 
 
1361
 
        /* Server doesn't require quality of protection. */
1362
 
        auth_create_digest_response(&digest_response, cred,
1363
 
                                    &chal->nonce, NULL, NULL,  NULL,
1364
 
                                    &hreq->hurl.path, &chal->realm,
1365
 
                                    &hreq->param.method);
1366
 
 
1367
 
        len = pj_ansi_snprintf(
1368
 
                phdr->value.ptr, len,
1369
 
                "Digest username=\"%.*s\", "
1370
 
                "realm=\"%.*s\", "
1371
 
                "nonce=\"%.*s\", "
1372
 
                "uri=\"%.*s\", "
1373
 
                "algorithm=%.*s, "
1374
 
                "response=\"%.*s\"",
1375
 
                STR_PREC(cred->username),
1376
 
                STR_PREC(chal->realm),
1377
 
                STR_PREC(chal->nonce),
1378
 
                STR_PREC(hreq->hurl.path),
1379
 
                STR_PREC(STR_MD5),
1380
 
                STR_PREC(digest_response));
1381
 
        if (len < 0)
1382
 
            return PJ_ETOOSMALL;
1383
 
        phdr->value.slen = len;
1384
 
 
1385
 
    } else if (auth_has_qop(hreq->pool, &chal->qop)) {
1386
 
        /* Server requires quality of protection.
1387
 
         * We respond with selecting "qop=auth" protection.
1388
 
         */
1389
 
        const pj_str_t STR_MD5 = { "MD5", 3 };
1390
 
        const pj_str_t qop = pj_str("auth");
1391
 
        const pj_str_t nc = pj_str("00000001");
1392
 
        const pj_str_t cnonce = pj_str("b39971");
1393
 
 
1394
 
        auth_create_digest_response(&digest_response, cred,
1395
 
                                    &chal->nonce, &nc, &cnonce, &qop,
1396
 
                                    &hreq->hurl.path, &chal->realm,
1397
 
                                    &hreq->param.method);
1398
 
        len = pj_ansi_snprintf(
1399
 
                phdr->value.ptr, len,
1400
 
                "Digest username=\"%.*s\", "
1401
 
                "realm=\"%.*s\", "
1402
 
                "nonce=\"%.*s\", "
1403
 
                "uri=\"%.*s\", "
1404
 
                "algorithm=%.*s, "
1405
 
                "response=\"%.*s\", "
1406
 
                "qop=%.*s, "
1407
 
                "nc=%.*s, "
1408
 
                "cnonce=\"%.*s\"",
1409
 
                STR_PREC(cred->username),
1410
 
                STR_PREC(chal->realm),
1411
 
                STR_PREC(chal->nonce),
1412
 
                STR_PREC(hreq->hurl.path),
1413
 
                STR_PREC(STR_MD5),
1414
 
                STR_PREC(digest_response),
1415
 
                STR_PREC(qop),
1416
 
                STR_PREC(nc),
1417
 
                STR_PREC(cnonce));
1418
 
        if (len < 0)
1419
 
            return PJ_ETOOSMALL;
1420
 
        phdr->value.slen = len;
1421
 
 
1422
 
        if (chal->opaque.slen) {
1423
 
            pj_strcat2(&phdr->value, ", opaque=\"");
1424
 
            pj_strcat(&phdr->value, &chal->opaque);
1425
 
            pj_strcat2(&phdr->value, "\"");
1426
 
        }
1427
 
 
1428
 
    } else {
1429
 
        /* Server requires quality protection that we don't support. */
1430
 
        TRACE_((THIS_FILE, "Error: Unsupported qop offer %.*s",
1431
 
                chal->qop.slen, chal->qop.ptr));
1432
 
        return PJ_ENOTSUP;
1433
 
    }
1434
 
 
1435
 
    return PJ_SUCCESS;
1436
 
}
1437
 
 
1438
 
 
1439
 
static void restart_req_with_auth(pj_http_req *hreq)
1440
 
{
1441
 
    pj_http_auth_chal *chal = &hreq->response.auth_chal;
1442
 
    pj_http_auth_cred *cred = &hreq->param.auth_cred;
1443
 
    pj_status_t status;
1444
 
 
1445
 
    if (hreq->param.headers.count >= PJ_HTTP_HEADER_SIZE) {
1446
 
        TRACE_((THIS_FILE, "Error: no place to put Authorization header"));
1447
 
        hreq->auth_state = AUTH_DONE;
1448
 
        return;
1449
 
    }
1450
 
 
1451
 
    /* If credential specifies specific scheme, make sure they match */
1452
 
    if (cred->scheme.slen && pj_stricmp(&chal->scheme, &cred->scheme)) {
1453
 
        status = PJ_ENOTSUP;
1454
 
        TRACE_((THIS_FILE, "Error: auth schemes mismatch"));
1455
 
        goto on_error;
1456
 
    }
1457
 
 
1458
 
    /* If credential specifies specific realm, make sure they match */
1459
 
    if (cred->realm.slen && pj_stricmp(&chal->realm, &cred->realm)) {
1460
 
        status = PJ_ENOTSUP;
1461
 
        TRACE_((THIS_FILE, "Error: auth realms mismatch"));
1462
 
        goto on_error;
1463
 
    }
1464
 
 
1465
 
    if (!pj_stricmp2(&chal->scheme, "basic")) {
1466
 
        status = auth_respond_basic(hreq);
1467
 
    } else if (!pj_stricmp2(&chal->scheme, "digest")) {
1468
 
        status = auth_respond_digest(hreq);
1469
 
    } else {
1470
 
        TRACE_((THIS_FILE, "Error: unsupported HTTP auth scheme"));
1471
 
        status = PJ_ENOTSUP;
1472
 
    }
1473
 
 
1474
 
    if (status != PJ_SUCCESS)
1475
 
        goto on_error;
1476
 
 
1477
 
    http_req_end_request(hreq);
1478
 
 
1479
 
    status = start_http_req(hreq, PJ_TRUE);
1480
 
    if (status != PJ_SUCCESS)
1481
 
        goto on_error;
1482
 
 
1483
 
    hreq->auth_state = AUTH_RETRYING;
1484
 
    return;
1485
 
 
1486
 
on_error:
1487
 
    hreq->auth_state = AUTH_DONE;
1488
 
}
1489
 
 
1490
 
 
1491
 
/* snprintf() to a pj_str_t struct with an option to append the
1492
 
 * result at the back of the string.
1493
 
 */
1494
 
void str_snprintf(pj_str_t *s, size_t size,
1495
 
                  pj_bool_t append, const char *format, ...)
1496
 
{
1497
 
    va_list arg;
1498
 
    int retval;
1499
 
 
1500
 
    va_start(arg, format);
1501
 
    if (!append)
1502
 
        s->slen = 0;
1503
 
    size -= s->slen;
1504
 
    retval = pj_ansi_vsnprintf(s->ptr + s->slen,
1505
 
                               size, format, arg);
1506
 
    s->slen += ((retval < (int)size) ? retval : size - 1);
1507
 
    va_end(arg);
1508
 
}
1509
 
 
1510
 
static pj_status_t http_req_start_sending(pj_http_req *hreq)
1511
 
{
1512
 
    pj_status_t status;
1513
 
    pj_str_t pkt;
1514
 
    pj_ssize_t len;
1515
 
    pj_size_t i;
1516
 
 
1517
 
    PJ_ASSERT_RETURN(hreq->state == SENDING_REQUEST ||
1518
 
                     hreq->state == SENDING_REQUEST_BODY, PJ_EBUG);
1519
 
 
1520
 
    if (hreq->state == SENDING_REQUEST) {
1521
 
        /* Prepare the request data */
1522
 
        if (!hreq->buffer.ptr)
1523
 
            hreq->buffer.ptr = (char*)pj_pool_alloc(hreq->pool, BUF_SIZE);
1524
 
        pj_strassign(&pkt, &hreq->buffer);
1525
 
        pkt.slen = 0;
1526
 
        /* Start-line */
1527
 
        str_snprintf(&pkt, BUF_SIZE, PJ_TRUE, "%.*s %.*s %s/%.*s\r\n",
1528
 
                     STR_PREC(hreq->param.method),
1529
 
                     STR_PREC(hreq->hurl.path),
1530
 
                     get_protocol(&hreq->hurl.protocol),
1531
 
                     STR_PREC(hreq->param.version));
1532
 
        /* Header field "Host" */
1533
 
        str_snprintf(&pkt, BUF_SIZE, PJ_TRUE, "Host: %.*s:%d\r\n",
1534
 
                     STR_PREC(hreq->hurl.host), hreq->hurl.port);
1535
 
        if (!pj_strcmp2(&hreq->param.method, http_method_names[HTTP_PUT])) {
1536
 
            char buf[16];
1537
 
 
1538
 
            /* Header field "Content-Length" */
1539
 
            pj_utoa(hreq->param.reqdata.total_size ?
1540
 
                    hreq->param.reqdata.total_size:
1541
 
                    hreq->param.reqdata.size, buf);
1542
 
            str_snprintf(&pkt, BUF_SIZE, PJ_TRUE, "%s: %s\r\n",
1543
 
                         CONTENT_LENGTH, buf);
1544
 
        }
1545
 
 
1546
 
        /* Append user-specified headers */
1547
 
        for (i = 0; i < hreq->param.headers.count; i++) {
1548
 
            str_snprintf(&pkt, BUF_SIZE, PJ_TRUE, "%.*s: %.*s\r\n",
1549
 
                         STR_PREC(hreq->param.headers.header[i].name),
1550
 
                         STR_PREC(hreq->param.headers.header[i].value));
1551
 
        }
1552
 
        if (pkt.slen >= BUF_SIZE - 1) {
1553
 
            status = PJLIB_UTIL_EHTTPINSBUF;
1554
 
            goto on_return;
1555
 
        }
1556
 
 
1557
 
        pj_strcat2(&pkt, "\r\n");
1558
 
        pkt.ptr[pkt.slen] = 0;
1559
 
        TRACE_((THIS_FILE, "%s", pkt.ptr));
1560
 
    } else {
1561
 
        pkt.ptr = (char*)hreq->param.reqdata.data;
1562
 
        pkt.slen = hreq->param.reqdata.size;
1563
 
    }
1564
 
 
1565
 
    /* Send the request */
1566
 
    len = pj_strlen(&pkt);
1567
 
    pj_ioqueue_op_key_init(&hreq->op_key, sizeof(hreq->op_key));
1568
 
    hreq->tcp_state.send_size = len;
1569
 
    hreq->tcp_state.current_send_size = 0;
1570
 
    status = pj_activesock_send(hreq->asock, &hreq->op_key,
1571
 
                                pkt.ptr, &len, 0);
1572
 
 
1573
 
    if (status == PJ_SUCCESS) {
1574
 
        http_on_data_sent(hreq->asock, &hreq->op_key, len);
1575
 
    } else if (status != PJ_EPENDING) {
1576
 
        goto on_return; // error sending data
1577
 
    }
1578
 
 
1579
 
    return PJ_SUCCESS;
1580
 
 
1581
 
on_return:
1582
 
    http_req_end_request(hreq);
1583
 
    return status;
1584
 
}
1585
 
 
1586
 
static pj_status_t http_req_start_reading(pj_http_req *hreq)
1587
 
{
1588
 
    pj_status_t status;
1589
 
 
1590
 
    PJ_ASSERT_RETURN(hreq->state == REQUEST_SENT, PJ_EBUG);
1591
 
 
1592
 
    /* Receive the response */
1593
 
    hreq->state = READING_RESPONSE;
1594
 
    hreq->tcp_state.current_read_size = 0;
1595
 
    pj_assert(hreq->buffer.ptr);
1596
 
    status = pj_activesock_start_read2(hreq->asock, hreq->pool, BUF_SIZE,
1597
 
                                       (void**)&hreq->buffer.ptr, 0);
1598
 
    if (status != PJ_SUCCESS) {
1599
 
        /* Error reading */
1600
 
        http_req_end_request(hreq);
1601
 
        return status;
1602
 
    }
1603
 
 
1604
 
    return PJ_SUCCESS;
1605
 
}
1606
 
 
1607
 
static pj_status_t http_req_end_request(pj_http_req *hreq)
1608
 
{
1609
 
    if (hreq->asock) {
1610
 
        pj_activesock_close(hreq->asock);
1611
 
        hreq->asock = NULL;
1612
 
    }
1613
 
 
1614
 
    /* Cancel query timeout timer. */
1615
 
    if (hreq->timer_entry.id != 0) {
1616
 
        pj_timer_heap_cancel(hreq->timer, &hreq->timer_entry);
1617
 
        /* Invalidate id. */
1618
 
        hreq->timer_entry.id = 0;
1619
 
    }
1620
 
 
1621
 
    hreq->state = IDLE;
1622
 
 
1623
 
    return PJ_SUCCESS;
1624
 
}
1625
 
 
1626
 
PJ_DEF(pj_status_t) pj_http_req_cancel(pj_http_req *http_req,
1627
 
                                       pj_bool_t notify)
1628
 
{
1629
 
    http_req->state = ABORTING;
1630
 
 
1631
 
    http_req_end_request(http_req);
1632
 
 
1633
 
    if (notify && http_req->cb.on_complete) {
1634
 
        (*http_req->cb.on_complete)(http_req, (!http_req->error?
1635
 
                                    PJ_ECANCELLED: http_req->error), NULL);
1636
 
    }
1637
 
 
1638
 
    return PJ_SUCCESS;
1639
 
}
1640
 
 
1641
 
 
1642
 
PJ_DEF(pj_status_t) pj_http_req_destroy(pj_http_req *http_req)
1643
 
{
1644
 
    PJ_ASSERT_RETURN(http_req, PJ_EINVAL);
1645
 
 
1646
 
    /* If there is any pending request, cancel it */
1647
 
    if (http_req->state != IDLE) {
1648
 
        pj_http_req_cancel(http_req, PJ_FALSE);
1649
 
    }
1650
 
 
1651
 
    pj_pool_release(http_req->pool);
1652
 
 
1653
 
    return PJ_SUCCESS;
1654
 
}