source: lib/http_client.c @ dcf155d

Last change on this file since dcf155d was 792a93b, checked in by Wilmer van der Gaast <wilmer@…>, at 2011-12-23T12:44:08Z

Merging SSL certificate verification for GnuTLS, with help from AopicieR.

  • Property mode set to 100644
File size: 12.7 KB
Line 
1  /********************************************************************\
2  * BitlBee -- An IRC to other IM-networks gateway                     *
3  *                                                                    *
4  * Copyright 2002-2011 Wilmer van der Gaast and others                *
5  \********************************************************************/
6
7/* HTTP(S) module                                                       */
8
9/*
10  This program is free software; you can redistribute it and/or modify
11  it under the terms of the GNU General Public License as published by
12  the Free Software Foundation; either version 2 of the License, or
13  (at your option) any later version.
14
15  This program is distributed in the hope that it will be useful,
16  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  GNU General Public License for more details.
19
20  You should have received a copy of the GNU General Public License with
21  the Debian GNU/Linux distribution in /usr/share/common-licenses/GPL;
22  if not, write to the Free Software Foundation, Inc., 59 Temple Place,
23  Suite 330, Boston, MA  02111-1307  USA
24*/
25
26#include <string.h>
27#include <stdio.h>
28
29#include "http_client.h"
30#include "url.h"
31#include "sock.h"
32
33
34static gboolean http_connected( gpointer data, int source, b_input_condition cond );
35static gboolean http_ssl_connected( gpointer data, int returncode, void *source, b_input_condition cond );
36static gboolean http_incoming_data( gpointer data, int source, b_input_condition cond );
37static void http_free( struct http_request *req );
38
39
40struct http_request *http_dorequest( char *host, int port, int ssl, char *request, http_input_function func, gpointer data )
41{
42        struct http_request *req;
43        int error = 0;
44       
45        req = g_new0( struct http_request, 1 );
46       
47        if( ssl )
48        {
49                req->ssl = ssl_connect( host, port, TRUE, http_ssl_connected, req );
50                if( req->ssl == NULL )
51                        error = 1;
52        }
53        else
54        {
55                req->fd = proxy_connect( host, port, http_connected, req );
56                if( req->fd < 0 )
57                        error = 1;
58        }
59       
60        if( error )
61        {
62                http_free( req );
63                return NULL;
64        }
65       
66        req->func = func;
67        req->data = data;
68        req->request = g_strdup( request );
69        req->request_length = strlen( request );
70        req->redir_ttl = 3;
71       
72        if( getenv( "BITLBEE_DEBUG" ) )
73                printf( "About to send HTTP request:\n%s\n", req->request );
74       
75        return( req );
76}
77
78struct http_request *http_dorequest_url( char *url_string, http_input_function func, gpointer data )
79{
80        url_t *url = g_new0( url_t, 1 );
81        char *request;
82        void *ret;
83       
84        if( !url_set( url, url_string ) )
85        {
86                g_free( url );
87                return NULL;
88        }
89       
90        if( url->proto != PROTO_HTTP && url->proto != PROTO_HTTPS )
91        {
92                g_free( url );
93                return NULL;
94        }
95       
96        request = g_strdup_printf( "GET %s HTTP/1.0\r\n"
97                                   "Host: %s\r\n"
98                                   "Connection: close\r\n"
99                                   "User-Agent: BitlBee " BITLBEE_VERSION " " ARCH "/" CPU "\r\n"
100                                   "\r\n", url->file, url->host );
101       
102        ret = http_dorequest( url->host, url->port,
103                              url->proto == PROTO_HTTPS, request, func, data );
104       
105        g_free( url );
106        g_free( request );
107        return ret;
108}
109
110/* This one is actually pretty simple... Might get more calls if we can't write
111   the whole request at once. */
112static gboolean http_connected( gpointer data, int source, b_input_condition cond )
113{
114        struct http_request *req = data;
115        int st;
116       
117        if( source < 0 )
118                goto error;
119       
120        if( req->inpa > 0 )
121                b_event_remove( req->inpa );
122       
123        sock_make_nonblocking( req->fd );
124       
125        if( req->ssl )
126        {
127                st = ssl_write( req->ssl, req->request + req->bytes_written,
128                                req->request_length - req->bytes_written );
129                if( st < 0 )
130                {
131                        if( ssl_errno != SSL_AGAIN )
132                        {
133                                ssl_disconnect( req->ssl );
134                                goto error;
135                        }
136                }
137        }
138        else
139        {
140                st = write( source, req->request + req->bytes_written,
141                                    req->request_length - req->bytes_written );
142                if( st < 0 )
143                {
144                        if( !sockerr_again() )
145                        {
146                                closesocket( req->fd );
147                                goto error;
148                        }
149                }
150        }
151       
152        if( st > 0 )
153                req->bytes_written += st;
154       
155        if( req->bytes_written < req->request_length )
156                req->inpa = b_input_add( source,
157                                         req->ssl ? ssl_getdirection( req->ssl ) : B_EV_IO_WRITE,
158                                         http_connected, req );
159        else
160                req->inpa = b_input_add( source, B_EV_IO_READ, http_incoming_data, req );
161       
162        return FALSE;
163       
164error:
165        if( req->status_string == NULL )
166                req->status_string = g_strdup( "Error while writing HTTP request" );
167       
168        req->func( req );
169        http_free( req );
170        return FALSE;
171}
172
173static gboolean http_ssl_connected( gpointer data, int returncode, void *source, b_input_condition cond )
174{
175        struct http_request *req = data;
176       
177        if( source == NULL )
178        {
179                if( returncode != 0 )
180                {
181                        char *err = ssl_verify_strerror( returncode );
182                        req->status_string = g_strdup_printf(
183                                "Certificate verification problem 0x%x: %s",
184                                returncode, err ? err : "Unknown" );
185                        g_free( err );
186                }
187                return http_connected( data, -1, cond );
188        }
189       
190        req->fd = ssl_getfd( source );
191       
192        return http_connected( data, req->fd, cond );
193}
194
195static gboolean http_incoming_data( gpointer data, int source, b_input_condition cond )
196{
197        struct http_request *req = data;
198        int evil_server = 0;
199        char buffer[2048];
200        char *end1, *end2;
201        int st;
202       
203        if( req->inpa > 0 )
204                b_event_remove( req->inpa );
205       
206        if( req->ssl )
207        {
208                st = ssl_read( req->ssl, buffer, sizeof( buffer ) );
209                if( st < 0 )
210                {
211                        if( ssl_errno != SSL_AGAIN )
212                        {
213                                /* goto cleanup; */
214                               
215                                /* YAY! We have to deal with crappy Microsoft
216                                   servers that LOVE to send invalid TLS
217                                   packets that abort connections! \o/ */
218                               
219                                goto got_reply;
220                        }
221                }
222                else if( st == 0 )
223                {
224                        goto got_reply;
225                }
226        }
227        else
228        {
229                st = read( req->fd, buffer, sizeof( buffer ) );
230                if( st < 0 )
231                {
232                        if( !sockerr_again() )
233                        {
234                                req->status_string = g_strdup( strerror( errno ) );
235                                goto cleanup;
236                        }
237                }
238                else if( st == 0 )
239                {
240                        goto got_reply;
241                }
242        }
243       
244        if( st > 0 )
245        {
246                req->reply_headers = g_realloc( req->reply_headers, req->bytes_read + st + 1 );
247                memcpy( req->reply_headers + req->bytes_read, buffer, st );
248                req->bytes_read += st;
249        }
250       
251        /* There will be more! */
252        req->inpa = b_input_add( req->fd,
253                                 req->ssl ? ssl_getdirection( req->ssl ) : B_EV_IO_READ,
254                                 http_incoming_data, req );
255       
256        if( ssl_pending( req->ssl ) )
257                return http_incoming_data( data, source, cond );
258        else
259                return FALSE;
260
261got_reply:
262        /* Maybe if the webserver is overloaded, or when there's bad SSL
263           support... */
264        if( req->bytes_read == 0 )
265        {
266                req->status_string = g_strdup( "Empty HTTP reply" );
267                goto cleanup;
268        }
269       
270        /* Zero termination is very convenient. */
271        req->reply_headers[req->bytes_read] = 0;
272       
273        /* Find the separation between headers and body, and keep stupid
274           webservers in mind. */
275        end1 = strstr( req->reply_headers, "\r\n\r\n" );
276        end2 = strstr( req->reply_headers, "\n\n" );
277       
278        if( end2 && end2 < end1 )
279        {
280                end1 = end2 + 1;
281                evil_server = 1;
282        }
283        else if( end1 )
284        {
285                end1 += 2;
286        }
287        else
288        {
289                req->status_string = g_strdup( "Malformed HTTP reply" );
290                goto cleanup;
291        }
292       
293        *end1 = 0;
294       
295        if( getenv( "BITLBEE_DEBUG" ) )
296                printf( "HTTP response headers:\n%s\n", req->reply_headers );
297       
298        if( evil_server )
299                req->reply_body = end1 + 1;
300        else
301                req->reply_body = end1 + 2;
302       
303        req->body_size = req->reply_headers + req->bytes_read - req->reply_body;
304       
305        if( ( end1 = strchr( req->reply_headers, ' ' ) ) != NULL )
306        {
307                if( sscanf( end1 + 1, "%d", &req->status_code ) != 1 )
308                {
309                        req->status_string = g_strdup( "Can't parse status code" );
310                        req->status_code = -1;
311                }
312                else
313                {
314                        char *eol;
315                       
316                        if( evil_server )
317                                eol = strchr( end1, '\n' );
318                        else
319                                eol = strchr( end1, '\r' );
320                       
321                        req->status_string = g_strndup( end1 + 1, eol - end1 - 1 );
322                       
323                        /* Just to be sure... */
324                        if( ( eol = strchr( req->status_string, '\r' ) ) )
325                                *eol = 0;
326                        if( ( eol = strchr( req->status_string, '\n' ) ) )
327                                *eol = 0;
328                }
329        }
330        else
331        {
332                req->status_string = g_strdup( "Can't locate status code" );
333                req->status_code = -1;
334        }
335       
336        if( ( ( req->status_code >= 301 && req->status_code <= 303 ) ||
337              req->status_code == 307 ) && req->redir_ttl-- > 0 )
338        {
339                char *loc, *new_request, *new_host;
340                int error = 0, new_port, new_proto;
341               
342                /* We might fill it again, so let's not leak any memory. */
343                g_free( req->status_string );
344                req->status_string = NULL;
345               
346                loc = strstr( req->reply_headers, "\nLocation: " );
347                if( loc == NULL ) /* We can't handle this redirect... */
348                {
349                        req->status_string = g_strdup( "Can't locate Location: header" );
350                        goto cleanup;
351                }
352               
353                loc += 11;
354                while( *loc == ' ' )
355                        loc ++;
356               
357                /* TODO/FIXME: Possibly have to handle relative redirections,
358                   and rewrite Host: headers. Not necessary for now, it's
359                   enough for passport authentication like this. */
360               
361                if( *loc == '/' )
362                {
363                        /* Just a different pathname... */
364                       
365                        /* Since we don't cache the servername, and since we
366                           don't need this yet anyway, I won't implement it. */
367                       
368                        req->status_string = g_strdup( "Can't handle recursive redirects" );
369                       
370                        goto cleanup;
371                }
372                else
373                {
374                        /* A whole URL */
375                        url_t *url;
376                        char *s;
377                        const char *new_method;
378                       
379                        s = strstr( loc, "\r\n" );
380                        if( s == NULL )
381                                goto cleanup;
382                       
383                        url = g_new0( url_t, 1 );
384                        *s = 0;
385                       
386                        if( !url_set( url, loc ) )
387                        {
388                                req->status_string = g_strdup( "Malformed redirect URL" );
389                                g_free( url );
390                                goto cleanup;
391                        }
392                       
393                        /* Find all headers and, if necessary, the POST request contents.
394                           Skip the old Host: header though. This crappy code here means
395                           anything using this http_client MUST put the Host: header at
396                           the top. */
397                        if( !( ( s = strstr( req->request, "\r\nHost: " ) ) &&
398                               ( s = strstr( s + strlen( "\r\nHost: " ), "\r\n" ) ) ) )
399                        {
400                                req->status_string = g_strdup( "Error while rebuilding request string" );
401                                g_free( url );
402                                goto cleanup;
403                        }
404                       
405                        /* More or less HTTP/1.0 compliant, from my reading of RFC 2616.
406                           Always perform a GET request unless we received a 301. 303 was
407                           meant for this but it's HTTP/1.1-only and we're specifically
408                           speaking HTTP/1.0. ...
409                           
410                           Well except someone at identi.ca's didn't bother reading any
411                           RFCs and just return HTTP/1.1-specific status codes to HTTP/1.0
412                           requests. Fuckers. So here we are, handle 301..303,307. */
413                        if( strncmp( req->request, "GET", 3 ) == 0 )
414                                /* GETs never become POSTs. */
415                                new_method = "GET";
416                        else if( req->status_code == 302 || req->status_code == 303 )
417                                /* 302 de-facto becomes GET, 303 as specified by RFC 2616#10.3.3 */
418                                new_method = "GET";
419                        else
420                                /* 301 de-facto should stay POST, 307 specifally RFC 2616#10.3.8 */
421                                new_method = "POST";
422                       
423                        /* Okay, this isn't fun! We have to rebuild the request... :-( */
424                        new_request = g_strdup_printf( "%s %s HTTP/1.0\r\nHost: %s%s",
425                                                       new_method, url->file, url->host, s );
426                       
427                        new_host = g_strdup( url->host );
428                        new_port = url->port;
429                        new_proto = url->proto;
430                       
431                        /* If we went from POST to GET, truncate the request content. */
432                        if( new_request[0] != req->request[0] && new_request[0] == 'G' &&
433                            ( s = strstr( new_request, "\r\n\r\n" ) ) )
434                                s[4] = '\0';
435                       
436                        g_free( url );
437                }
438               
439                if( req->ssl )
440                        ssl_disconnect( req->ssl );
441                else
442                        closesocket( req->fd );
443               
444                req->fd = -1;
445                req->ssl = NULL;
446               
447                if( getenv( "BITLBEE_DEBUG" ) )
448                        printf( "New headers for redirected HTTP request:\n%s\n", new_request );
449       
450                if( new_proto == PROTO_HTTPS )
451                {
452                        req->ssl = ssl_connect( new_host, new_port, TRUE, http_ssl_connected, req );
453                        if( req->ssl == NULL )
454                                error = 1;
455                }
456                else
457                {
458                        req->fd = proxy_connect( new_host, new_port, http_connected, req );
459                        if( req->fd < 0 )
460                                error = 1;
461                }
462                g_free( new_host );
463               
464                if( error )
465                {
466                        req->status_string = g_strdup( "Connection problem during redirect" );
467                        g_free( new_request );
468                        goto cleanup;
469                }
470               
471                g_free( req->request );
472                g_free( req->reply_headers );
473                req->request = new_request;
474                req->request_length = strlen( new_request );
475                req->bytes_read = req->bytes_written = req->inpa = 0;
476                req->reply_headers = req->reply_body = NULL;
477               
478                return FALSE;
479        }
480       
481        /* Assume that a closed connection means we're finished, this indeed
482           breaks with keep-alive connections and faulty connections. */
483        req->finished = 1;
484
485cleanup:
486        if( req->ssl )
487                ssl_disconnect( req->ssl );
488        else
489                closesocket( req->fd );
490       
491        if( getenv( "BITLBEE_DEBUG" ) && req )
492                printf( "Finishing HTTP request with status: %s\n",
493                        req->status_string ? req->status_string : "NULL" );
494       
495        req->func( req );
496        http_free( req );
497        return FALSE;
498}
499
500static void http_free( struct http_request *req )
501{
502        g_free( req->request );
503        g_free( req->reply_headers );
504        g_free( req->status_string );
505        g_free( req );
506}
507
Note: See TracBrowser for help on using the repository browser.