Changeset cc6fdf8 for lib

Timestamp:

2012-12-22T00:14:26Z (11 years ago)

Author:

Wilmer van der Gaast <wilmer@…>

Branches:

master

Children:

7d5afa6

Parents:

92d3044 (diff), 573e274 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merging JSON branch. It's very stable by now, and I want more testers.

Location:

lib

Files:

• Makefile (modified) (1 diff)
• http_client.c (modified) (16 diffs)
• http_client.h (modified) (7 diffs)
• json.c (added)
• json.h (added)
• json_util.c (added)
• json_util.h (added)
• oauth2.c (modified) (5 diffs)
• ssl_gnutls.c (modified) (8 diffs)

lib/Makefile

@@ -13 +13 @@
 
 # [SH] Program variables
-objects = arc.o base64.o $(EVENT_HANDLER) ftutil.o http_client.o ini.o md5.o misc.o oauth.o oauth2.o proxy.o sha1.o $(SSL_CLIENT) url.o xmltree.o
+objects = arc.o base64.o $(EVENT_HANDLER) ftutil.o http_client.o ini.o json.o json_util.o md5.o misc.o oauth.o oauth2.o proxy.o sha1.o $(SSL_CLIENT) url.o xmltree.o
 
 LFLAGS += -r

lib/http_client.c

@@ -193 +193 @@
 }
 
+static gboolean http_handle_headers( struct http_request *req );
+
 static gboolean http_incoming_data( gpointer data, int source, b_input_condition cond )
 {
         struct http_request *req = data;
-        int evil_server = 0;
-        char buffer[2048];
-        char *end1, *end2, *s;
+        char buffer[4096];
+        char *s;
         size_t content_length;
         int st;
@@ -218 +219 @@
                                    packets that abort connections! \o/ */
                                 
-                                goto got_reply;
+                                goto eof;
                         }
                 }
                 else if( st == 0 )
                 {
-                        goto got_reply;
+                        goto eof;
                 }
         }
@@ -239 +240 @@
                 else if( st == 0 )
                 {
-                        goto got_reply;
-                }
-        }
-        
-        if( st > 0 )
+                        goto eof;
+                }
+        }
+        
+        if( st > 0 && !req->sbuf )
         {
                 req->reply_headers = g_realloc( req->reply_headers, req->bytes_read + st + 1 );
                 memcpy( req->reply_headers + req->bytes_read, buffer, st );
                 req->bytes_read += st;
-        }
+                
+                st = 0;
+        }
+        
+        if( st >= 0 && ( req->flags & HTTPC_STREAMING ) )
+        {
+                if( !req->reply_body &&
+                    ( strstr( req->reply_headers, "\r\n\r\n" ) ||
+                      strstr( req->reply_headers, "\n\n" ) ) )
+                {
+                        size_t hlen;
+                        
+                        /* We've now received all headers, so process them once
+                           before we start feeding back data. */
+                        if( !http_handle_headers( req ) )
+                                return FALSE;
+                        
+                        hlen = req->reply_body - req->reply_headers;
+                        
+                        req->sblen = req->bytes_read - hlen;
+                        req->sbuf = g_memdup( req->reply_body, req->sblen + 1 );
+                        req->reply_headers = g_realloc( req->reply_headers, hlen + 1 );
+                        
+                        req->reply_body = req->sbuf;
+                }
+                
+                if( st > 0 )
+                {
+                        int pos = req->reply_body - req->sbuf;
+                        req->sbuf = g_realloc( req->sbuf, req->sblen + st + 1 );
+                        memcpy( req->sbuf + req->sblen, buffer, st );
+                        req->bytes_read += st;
+                        req->sblen += st;
+                        req->sbuf[req->sblen] = '\0';
+                        req->reply_body = req->sbuf + pos;
+                        req->body_size = req->sblen - pos;
+                }
+                
+                if( req->reply_body )
+                        req->func( req );
+        }
+        
+        if( ssl_pending( req->ssl ) )
+                return http_incoming_data( data, source, cond );
         
         /* There will be more! */
@@ -255 +299 @@
                                  http_incoming_data, req );
         
-        if( ssl_pending( req->ssl ) )
-                return http_incoming_data( data, source, cond );
-        else
-                return FALSE;
-
-got_reply:
+        return FALSE;
+
+eof:
+        req->flags |= HTTPC_EOF;
+        
         /* Maybe if the webserver is overloaded, or when there's bad SSL
            support... */
@@ -269 +312 @@
         }
         
+        if( !( req->flags & HTTPC_STREAMING ) )
+        {
+                /* Returns FALSE if we were redirected, in which case we should abort
+                   and not run any callback yet. */
+                if( !http_handle_headers( req ) )
+                        return FALSE;
+        }
+
+cleanup:
+        if( req->ssl )
+                ssl_disconnect( req->ssl );
+        else
+                closesocket( req->fd );
+        
+        if( ( s = get_rfc822_header( req->reply_headers, "Content-Length", 0 ) ) &&
+            sscanf( s, "%zd", &content_length ) == 1 )
+        {
+                if( content_length < req->body_size )
+                {
+                        req->status_code = -1;
+                        g_free( req->status_string );
+                        req->status_string = g_strdup( "Response truncated" );
+                }
+        }
+        g_free( s );
+        
+        if( getenv( "BITLBEE_DEBUG" ) && req )
+                printf( "Finishing HTTP request with status: %s\n",
+                        req->status_string ? req->status_string : "NULL" );
+        
+        req->func( req );
+        http_free( req );
+        return FALSE;
+}
+
+/* Splits headers and body. Checks result code, in case of 300s it'll handle
+   redirects. If this returns FALSE, don't call any callbacks! */
+static gboolean http_handle_headers( struct http_request *req )
+{
+        char *end1, *end2;
+        int evil_server = 0;
+        
         /* Zero termination is very convenient. */
-        req->reply_headers[req->bytes_read] = 0;
+        req->reply_headers[req->bytes_read] = '\0';
         
         /* Find the separation between headers and body, and keep stupid
@@ -289 +374 @@
         {
                 req->status_string = g_strdup( "Malformed HTTP reply" );
-                goto cleanup;
+                return TRUE;
         }
         
@@ -306 +391 @@
         if( ( end1 = strchr( req->reply_headers, ' ' ) ) != NULL )
         {
-                if( sscanf( end1 + 1, "%d", &req->status_code ) != 1 )
+                if( sscanf( end1 + 1, "%hd", &req->status_code ) != 1 )
                 {
                         req->status_string = g_strdup( "Can't parse status code" );
@@ -349 +434 @@
                 {
                         req->status_string = g_strdup( "Can't locate Location: header" );
-                        goto cleanup;
+                        return TRUE;
                 }
                 
@@ -369 +454 @@
                         req->status_string = g_strdup( "Can't handle recursive redirects" );
                         
-                        goto cleanup;
+                        return TRUE;
                 }
                 else
@@ -380 +465 @@
                         s = strstr( loc, "\r\n" );
                         if( s == NULL )
-                                goto cleanup;
+                                return TRUE;
                         
                         url = g_new0( url_t, 1 );
@@ -389 +474 @@
                                 req->status_string = g_strdup( "Malformed redirect URL" );
                                 g_free( url );
-                                goto cleanup;
+                                return TRUE;
                         }
                         
@@ -401 +486 @@
                                 req->status_string = g_strdup( "Error while rebuilding request string" );
                                 g_free( url );
-                                goto cleanup;
+                                return TRUE;
                         }
                         
@@ -467 +552 @@
                         req->status_string = g_strdup( "Connection problem during redirect" );
                         g_free( new_request );
-                        goto cleanup;
+                        return TRUE;
                 }
                 
@@ -480 +565 @@
         }
         
-        /* Assume that a closed connection means we're finished, this indeed
-           breaks with keep-alive connections and faulty connections. */
-        /* req->finished = 1; */
-
-cleanup:
+        return TRUE;
+}
+
+void http_flush_bytes( struct http_request *req, size_t len )
+{
+        if( len <= 0 || len > req->body_size || !( req->flags & HTTPC_STREAMING ) )
+                return;
+        
+        req->reply_body += len;
+        req->body_size -= len;
+        
+        if( req->reply_body - req->sbuf >= 512 )
+        {
+                printf( "Wasting %ld bytes, cleaning up stream buffer\n", req->reply_body - req->sbuf );
+                char *new = g_memdup( req->reply_body, req->body_size + 1 );
+                g_free( req->sbuf );
+                req->reply_body = req->sbuf = new;
+                req->sblen = req->body_size;
+        }
+}
+
+void http_close( struct http_request *req )
+{
+        if( !req )
+                return;
+        
+        if( req->inpa > 0 )
+                b_event_remove( req->inpa );
+        
         if( req->ssl )
                 ssl_disconnect( req->ssl );
@@ -490 +599 @@
                 closesocket( req->fd );
         
-        if( ( s = get_rfc822_header( req->reply_headers, "Content-Length", 0 ) ) &&
-            sscanf( s, "%zd", &content_length ) == 1 )
-        {
-                if( content_length < req->body_size )
-                {
-                        req->status_code = -1;
-                        g_free( req->status_string );
-                        req->status_string = g_strdup( "Response truncated" );
-                }
-        }
-        g_free( s );
-        
-        if( getenv( "BITLBEE_DEBUG" ) && req )
-                printf( "Finishing HTTP request with status: %s\n",
-                        req->status_string ? req->status_string : "NULL" );
-        
-        req->func( req );
         http_free( req );
-        return FALSE;
 }
 
@@ -516 +607 @@
         g_free( req->reply_headers );
         g_free( req->status_string );
+        g_free( req->sbuf );
         g_free( req );
 }
-

lib/http_client.h

@@ -26 +26 @@
 /* http_client allows you to talk (asynchronously, again) to HTTP servers.
    In the "background" it will send the whole query and wait for a complete
-   response to come back. Right now it's only used by the MSN Passport
-   authentication code, but it might be useful for other things too (for
-   example the AIM usericon patch uses this so icons can be stored on
-   webservers instead of the local filesystem).
+   response to come back. Initially written for MS Passport authentication,
+   but used for many other things now like OAuth and Twitter.
    
-   Didn't test this too much, but it seems to work well. Just don't look
-   at the code that handles HTTP 30x redirects. ;-) The function is
-   probably not very useful for downloading lots of data since it keeps 
-   everything in a memory buffer until the download is completed (and
-   can't pass any data or whatever before then). It's very useful for
-   doing quick requests without blocking the whole program, though. */
+   It's very useful for doing quick requests without blocking the whole
+   program. Unfortunately it doesn't support fancy stuff like HTTP keep-
+   alives. */
 
 #include <glib.h>
@@ -42 +37 @@
 
 struct http_request;
+
+typedef enum http_client_flags
+{
+        HTTPC_STREAMING = 1,
+        HTTPC_EOF = 2,
+        
+        /* Let's reserve 0x1000000+ for lib users. */
+} http_client_flags_t;
 
 /* Your callback function should look like this: */
@@ -53 +56 @@
         char *request;          /* The request to send to the server. */
         int request_length;     /* Its size. */
-        int status_code;        /* The numeric HTTP status code. (Or -1
+        short status_code;      /* The numeric HTTP status code. (Or -1
                                    if something really went wrong) */
         char *status_string;    /* The error text. */
@@ -59 +62 @@
         char *reply_body;
         int body_size;          /* The number of bytes in reply_body. */
-        /* int finished;           Set to non-0 if the request was completed
-                                   successfully. */
-        int redir_ttl;          /* You can set it to 0 if you don't want
+        short redir_ttl;        /* You can set it to 0 if you don't want
                                    http_client to follow them. */
+        
+        http_client_flags_t flags;
         
         http_input_function func;
@@ -68 +71 @@
         
         /* Please don't touch the things down here, you shouldn't need them. */
-        
         void *ssl;
         int fd;
@@ -75 +77 @@
         int bytes_written;
         int bytes_read;
+        
+        /* Used in streaming mode. Caller should read from reply_body. */
+        char *sbuf;
+        size_t sblen;
 };
 
@@ -83 +89 @@
 struct http_request *http_dorequest( char *host, int port, int ssl, char *request, http_input_function func, gpointer data );
 struct http_request *http_dorequest_url( char *url_string, http_input_function func, gpointer data );
+
+/* For streaming connections only; flushes len bytes at the start of the buffer. */
+void http_flush_bytes( struct http_request *req, size_t len );
+void http_close( struct http_request *req );

lib/oauth2.c

@@ -4 +4 @@
 *  Simple OAuth client (consumer) implementation.                           *
 *                                                                           *
-*  Copyright 2010-2011 Wilmer van der Gaast <wilmer@gaast.net>              *
+*  Copyright 2010-2012 Wilmer van der Gaast <wilmer@gaast.net>              *
 *                                                                           *
 *  This program is free software; you can redistribute it and/or modify     *
@@ -26 +26 @@
 #include "oauth2.h"
 #include "oauth.h"
+#include "json.h"
 #include "url.h"
 
@@ -44 +45 @@
 };
 
-static char *oauth2_json_dumb_get( const char *json, const char *key );
 static void oauth2_access_token_done( struct http_request *req );
 
@@ -115 +115 @@
         else if( content_type && strstr( content_type, "application/json" ) )
         {
-                atoken = oauth2_json_dumb_get( req->reply_body, "access_token" );
-                rtoken = oauth2_json_dumb_get( req->reply_body, "refresh_token" );
+                json_value *js = json_parse( req->reply_body );
+                if( js && js->type == json_object )
+                {
+                        int i;
+                        
+                        for( i = 0; i < js->u.object.length; i ++ )
+                        {
+                                if( js->u.object.values[i].value->type != json_string )
+                                        continue;
+                                if( strcmp( js->u.object.values[i].name, "access_token" ) == 0 )
+                                        atoken = g_strdup( js->u.object.values[i].value->u.string.ptr );
+                                if( strcmp( js->u.object.values[i].name, "refresh_token" ) == 0 )
+                                        rtoken = g_strdup( js->u.object.values[i].value->u.string.ptr );
+                        }
+                }
+                json_value_free( js );
         }
         else
@@ -137 +151 @@
         g_free( cb_data );
 }
-
-/* Super dumb. I absolutely refuse to use/add a complete json parser library
-   (adding a new dependency to BitlBee for the first time in.. 6 years?) just
-   to parse 100 bytes of data. So I have to do my own parsing because OAuth2
-   dropped support for XML. (GRRR!) This is very dumb and for example won't
-   work for integer values, nor will it strip/handle backslashes. */
-static char *oauth2_json_dumb_get( const char *json, const char *key )
-{
-        int is_key = 0; /* 1 == reading key, 0 == reading value */
-        int found_key = 0;
-                
-        while( json && *json )
-        {
-                /* Grab strings and see if they're what we're looking for. */
-                if( *json == '"' || *json == '\'' )
-                {
-                        char q = *json;
-                        const char *str_start;
-                        json ++;
-                        str_start = json;
-                        
-                        while( *json )
-                        {
-                                /* \' and \" are not string terminators. */
-                                if( *json == '\\' && json[1] == q )
-                                        json ++;
-                                /* But without a \ it is. */
-                                else if( *json == q )
-                                        break;
-                                json ++;
-                        }
-                        if( *json == '\0' )
-                                return NULL;
-                        
-                        if( is_key && strncmp( str_start, key, strlen( key ) ) == 0 )
-                        {
-                                found_key = 1;
-                        }
-                        else if( !is_key && found_key )
-                        {
-                                char *ret = g_memdup( str_start, json - str_start + 1 );
-                                ret[json-str_start] = '\0';
-                                return ret;
-                        }
-                        
-                }
-                else if( *json == '{' || *json == ',' )
-                {
-                        found_key = 0;
-                        is_key = 1;
-                }
-                else if( *json == ':' )
-                        is_key = 0;
-                
-                json ++;
-        }
-        
-        return NULL;
-}

lib/ssl_gnutls.c

@@ -38 +38 @@
 
 static gboolean initialized = FALSE;
-gnutls_certificate_credentials xcred;
+gnutls_certificate_credentials_t xcred;
 
 #include <limits.h>
@@ -60 +60 @@
         gboolean verify;
         
-        gnutls_session session;
+        gnutls_session_t session;
 };
 
@@ -134 +134 @@
         conn->data = data;
         conn->inpa = -1;
-        conn->hostname = hostname;
+        conn->hostname = g_strdup( hostname );
         
         /* For now, SSL verification is globally enabled by setting the cafile
@@ -171 +171 @@
         int verifyret = 0;
         gnutls_x509_crt_t cert;
-        const char *hostname;
-        
-        hostname = gnutls_session_get_ptr( session );
+        struct scd *conn;
+        
+        conn = gnutls_session_get_ptr( session );
 
         gnutlsret = gnutls_certificate_verify_peers2( session, &status );
@@ -211 +211 @@
                 return VERIFY_CERT_ERROR;
 
-        if( !gnutls_x509_crt_check_hostname( cert, hostname ) )
+        if( !gnutls_x509_crt_check_hostname( cert, conn->hostname ) )
         {
                 verifyret |= VERIFY_CERT_INVALID;
@@ -267 +267 @@
         
         gnutls_init( &conn->session, GNUTLS_CLIENT );
-        if( conn->verify )
-                gnutls_session_set_ptr( conn->session, (void *) conn->hostname );
+        gnutls_session_set_ptr( conn->session, (void *) conn );
 #if GNUTLS_VERSION_NUMBER < 0x020c00
         gnutls_transport_set_lowat( conn->session, 0 );
@@ -276 +275 @@
         
         sock_make_nonblocking( conn->fd );
-        gnutls_transport_set_ptr( conn->session, (gnutls_transport_ptr) GNUTLS_STUPID_CAST conn->fd );
+        gnutls_transport_set_ptr( conn->session, (gnutls_transport_ptr_t) GNUTLS_STUPID_CAST conn->fd );
         
         return ssl_handshake( data, source, cond );
@@ -402 +401 @@
         if( conn->session )
                 gnutls_deinit( conn->session );
+        g_free( conn->hostname );
         g_free( conn );
 }