Changes in / [ab19567:41a94dd]

Files:

• lib/http_client.c (modified) (18 diffs)
• lib/http_client.h (modified) (2 diffs)
• lib/oauth.c (modified) (1 diff)
• lib/oauth2.c (modified) (1 diff)
• lib/proxy.c (modified) (1 diff)
• protocols/twitter/twitter.c (modified) (2 diffs)
• protocols/twitter/twitter_http.c (modified) (1 diff)

lib/http_client.c

@@ -2 +2 @@
   * BitlBee -- An IRC to other IM-networks gateway                     *
   *                                                                    *
-  * Copyright 2002-2013 Wilmer van der Gaast and others                *
+  * Copyright 2002-2012 Wilmer van der Gaast and others                *
   \********************************************************************/
 
@@ -69 +69 @@
         req->request_length = strlen( request );
         req->redir_ttl = 3;
-        req->content_length = -1;
         
         if( getenv( "BITLBEE_DEBUG" ) )
@@ -97 +96 @@
         request = g_strdup_printf( "GET %s HTTP/1.0\r\n"
                                    "Host: %s\r\n"
+                                   "Connection: close\r\n"
                                    "User-Agent: BitlBee " BITLBEE_VERSION " " ARCH "/" CPU "\r\n"
                                    "\r\n", url->file, url->host );
@@ -193 +193 @@
 }
 
-typedef enum {
-        CR_OK,
-        CR_EOF,
-        CR_ERROR,
-        CR_ABORT,
-} http_ret_t;
-
 static gboolean http_handle_headers( struct http_request *req );
-static http_ret_t http_process_chunked_data( struct http_request *req, const char *buffer, int len );
-static http_ret_t http_process_data( struct http_request *req, const char *buffer, int len );
 
 static gboolean http_incoming_data( gpointer data, int source, b_input_condition cond )
@@ -208 +199 @@
         struct http_request *req = data;
         char buffer[4096];
+        char *s;
+        size_t content_length;
         int st;
         
@@ -251 +244 @@
         }
         
-        if( st > 0 )
-        {
-                http_ret_t c;
-                
-                if( req->flags & HTTPC_CHUNKED )
-                        c = http_process_chunked_data( req, buffer, st );
-                else
-                        c = http_process_data( req, buffer, st );
-                
-                if( c == CR_EOF )
-                        goto eof;
-                else if( c == CR_ERROR || c == CR_ABORT )
-                        return FALSE;
-        }
-        
-        if( req->content_length != -1 &&
-            req->body_size >= req->content_length )
-                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 ) )
@@ -290 +311 @@
                 goto cleanup;
         }
+        
+        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:
@@ -297 +326 @@
                 closesocket( req->fd );
         
-        if( req->body_size < req->content_length )
-        {
-                req->status_code = -1;
-                g_free( req->status_string );
-                req->status_string = g_strdup( "Response truncated" );
-        }
+        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 )
@@ -313 +347 @@
 }
 
-static http_ret_t http_process_chunked_data( struct http_request *req, const char *buffer, int len )
-{
-        char *chunk, *eos, *s;
-        
-        if( len < 0 )
-                return TRUE;
-        
-        if( len > 0 )
-        {
-                req->cbuf = g_realloc( req->cbuf, req->cblen + len + 1 );
-                memcpy( req->cbuf + req->cblen, buffer, len );
-                req->cblen += len;
-                req->cbuf[req->cblen] = '\0';
-        }
-        
-        /* Turns out writing a proper chunked-encoding state machine is not
-           that simple. :-( I've tested this one feeding it byte by byte so
-           I hope it's solid now. */
-        chunk = req->cbuf;
-        eos = req->cbuf + req->cblen;
-        while( TRUE )
-        {
-                int clen = 0;
-                
-                /* Might be a \r\n from the last chunk. */
-                s = chunk;
-                while( isspace( *s ) )
-                        s ++;
-                /* Chunk length. Might be incomplete. */
-                if( s < eos && sscanf( s, "%x", &clen ) != 1 )
-                        return CR_ERROR;
-                while( isxdigit( *s ) )
-                        s ++;
-                
-                /* If we read anything here, it *must* be \r\n. */
-                if( strncmp( s, "\r\n", MIN( 2, eos - s ) ) != 0 )
-                        return CR_ERROR;
-                s += 2;
-                
-                if( s >= eos )
-                        break;
-                
-                /* 0-length chunk means end of response. */     
-                if( clen == 0 )
-                        return CR_EOF;
-                
-                /* Wait for the whole chunk to arrive. */
-                if( s + clen > eos )
-                        break;
-                if( http_process_data( req, s, clen ) != CR_OK )
-                        return CR_ABORT;
-                
-                chunk = s + clen;
-        }
-        
-        if( chunk != req->cbuf )
-        {
-                req->cblen = eos - chunk;
-                s = g_memdup( chunk, req->cblen + 1 );
-                g_free( req->cbuf );
-                req->cbuf = s;
-        }
-        
-        return CR_OK;
-}
-
-static http_ret_t http_process_data( struct http_request *req, const char *buffer, int len )
-{
-        if( len <= 0 )
-                return CR_OK;
-        
-        if( !req->reply_body )
-        {
-                req->reply_headers = g_realloc( req->reply_headers, req->bytes_read + len + 1 );
-                memcpy( req->reply_headers + req->bytes_read, buffer, len );
-                req->bytes_read += len;
-                req->reply_headers[req->bytes_read] = '\0';
-                
-                if( strstr( req->reply_headers, "\r\n\r\n" ) ||
-                    strstr( req->reply_headers, "\n\n" ) )
-                {
-                        /* We've now received all headers. Look for something
-                           interesting. */
-                        if( !http_handle_headers( req ) )
-                                return CR_ABORT;
-                        
-                        /* Start parsing the body as chunked if required. */
-                        if( req->flags & HTTPC_CHUNKED )
-                                return http_process_chunked_data( req, NULL, 0 );
-                }
-        }
-        else
-        {
-                int pos = req->reply_body - req->sbuf;
-                req->sbuf = g_realloc( req->sbuf, req->sblen + len + 1 );
-                memcpy( req->sbuf + req->sblen, buffer, len );
-                req->bytes_read += len;
-                req->sblen += len;
-                req->sbuf[req->sblen] = '\0';
-                req->reply_body = req->sbuf + pos;
-                req->body_size = req->sblen - pos;
-        }
-        
-        if( ( req->flags & HTTPC_STREAMING ) && req->reply_body )
-                req->func( req );
-        
-        return CR_OK;
-}
-
 /* 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, *s;
+        char *end1, *end2;
         int evil_server = 0;
         
@@ -452 +377 @@
         }
         
-        *end1 = '\0';
+        *end1 = 0;
         
         if( getenv( "BITLBEE_DEBUG" ) )
@@ -462 +387 @@
                 req->reply_body = end1 + 2;
         
-        /* Separately allocated space for headers and body. */
-        req->sblen = req->body_size = req->reply_headers + req->bytes_read - req->reply_body;
-        req->sbuf = req->reply_body = g_memdup( req->reply_body, req->body_size + 1 );
-        req->reply_headers = g_realloc( req->reply_headers, end1 - req->reply_headers + 1 );
+        req->body_size = req->reply_headers + req->bytes_read - req->reply_body;
         
         if( ( end1 = strchr( req->reply_headers, ' ' ) ) != NULL )
@@ -530 +452 @@
                            don't need this yet anyway, I won't implement it. */
                         
-                        req->status_string = g_strdup( "Can't handle relative redirects" );
+                        req->status_string = g_strdup( "Can't handle recursive redirects" );
                         
                         return TRUE;
@@ -538 +460 @@
                         /* A whole URL */
                         url_t *url;
-                        char *s, *version, *headers;
+                        char *s;
                         const char *new_method;
                         
@@ -566 +488 @@
                                 return TRUE;
                         }
-                        headers = s;
                         
                         /* More or less HTTP/1.0 compliant, from my reading of RFC 2616.
@@ -586 +507 @@
                                 new_method = "POST";
                         
-                        if( ( version = strstr( req->request, " HTTP/" ) ) &&
-                            ( s = strstr( version, "\r\n" ) ) )
-                        {
-                                version ++;
-                                version = g_strndup( version, s - version );
-                        }
-                        else
-                                version = g_strdup( "HTTP/1.0" );
-                        
                         /* Okay, this isn't fun! We have to rebuild the request... :-( */
-                        new_request = g_strdup_printf( "%s %s %s\r\nHost: %s%s",
-                                                       new_method, url->file, version,
-                                                       url->host, headers );
+                        new_request = g_strdup_printf( "%s %s HTTP/1.0\r\nHost: %s%s",
+                                                       new_method, url->file, url->host, s );
                         
                         new_host = g_strdup( url->host );
@@ -610 +521 @@
                         
                         g_free( url );
-                        g_free( version );
                 }
                 
@@ -647 +557 @@
                 g_free( req->request );
                 g_free( req->reply_headers );
-                g_free( req->sbuf );
                 req->request = new_request;
                 req->request_length = strlen( new_request );
                 req->bytes_read = req->bytes_written = req->inpa = 0;
                 req->reply_headers = req->reply_body = NULL;
-                req->sbuf = req->cbuf = NULL;
-                req->sblen = req->cblen = 0;
                 
                 return FALSE;
-        }
-
-        if( ( s = get_rfc822_header( req->reply_headers, "Content-Length", 0 ) ) &&
-            sscanf( s, "%d", &req->content_length ) != 1 )
-                req->content_length = -1;
-        g_free( s );
-        
-        if( ( s = get_rfc822_header( req->reply_headers, "Transfer-Encoding", 0 ) ) )
-        {
-                if( strcasestr( s, "chunked" ) )
-                {
-                        req->flags |= HTTPC_CHUNKED;
-                        req->cbuf = req->sbuf;
-                        req->cblen = req->sblen;
-                        
-                        req->reply_body = req->sbuf = g_strdup( "" );
-                        req->body_size = req->sblen = 0;
-                }
-                g_free( s );
         }
         
@@ -719 +607 @@
         g_free( req->status_string );
         g_free( req->sbuf );
-        g_free( req->cbuf );
         g_free( req );
 }

lib/http_client.h

@@ -42 +42 @@
         HTTPC_STREAMING = 1,
         HTTPC_EOF = 2,
-        HTTPC_CHUNKED = 4,
         
         /* Let's reserve 0x1000000+ for lib users. */
@@ -78 +77 @@
         int bytes_written;
         int bytes_read;
-        int content_length;     /* "Content-Length:" header or -1 */
         
         /* Used in streaming mode. Caller should read from reply_body. */
         char *sbuf;
         size_t sblen;
-        
-        /* Chunked encoding only. Raw chunked stream is decoded from here. */
-        char *cbuf;
-        size_t cblen;
 };
 

lib/oauth.c

@@ -262 +262 @@
                              "Content-Type: application/x-www-form-urlencoded\r\n"
                              "Content-Length: %zd\r\n"
+                             "Connection: close\r\n"
                              "\r\n"
                              "%s", url_p.file, url_p.host, strlen( post ), post );

lib/oauth2.c

@@ -96 +96 @@
                              "Content-Type: application/x-www-form-urlencoded\r\n"
                              "Content-Length: %zd\r\n"
+                             "Connection: close\r\n"
                              "\r\n"
                              "%s", url_p.file, url_p.host, strlen( args_s ), args_s );

lib/proxy.c

@@ -158 +158 @@
                 }
 
-                event_debug("proxy_connect_none( \"%s\", %d ) = %d\n", host, port_, fd);
+                event_debug("proxy_connect_none( \"%s\", %d ) = %d\n", host, port, fd);
         
                 if (connect(fd, phb->gai_cur->ai_addr, phb->gai_cur->ai_addrlen) < 0 && !sockerr_again()) {

protocols/twitter/twitter.c

@@ -289 +289 @@
         char *def_url;
         char *def_tul;
-        char *def_mentions;
 
         if (strcmp(acc->prpl->name, "twitter") == 0) {
                 def_url = TWITTER_API_URL;
                 def_tul = "20";
-                def_mentions = "true";
         } else {                /* if( strcmp( acc->prpl->name, "identica" ) == 0 ) */
                 def_url = IDENTICA_API_URL;
                 def_tul = "0";
-                def_mentions = "false";
         }
 
@@ -311 +308 @@
         s->flags |= ACC_SET_OFFLINE_ONLY;
 
-        s = set_add(&acc->set, "fetch_mentions", def_mentions, set_eval_bool, acc);
+        s = set_add(&acc->set, "fetch_mentions", "true", set_eval_bool, acc);
 
         s = set_add(&acc->set, "message_length", "140", set_eval_int, acc);

protocols/twitter/twitter_http.c

@@ -78 +78 @@
         
         // Make the request.
-        g_string_printf(request, "%s %s%s%s%s HTTP/1.1\r\n"
+        g_string_printf(request, "%s %s%s%s%s HTTP/1.0\r\n"
                         "Host: %s\r\n"
                         "User-Agent: BitlBee " BITLBEE_VERSION " " ARCH "/" CPU "\r\n",