Changeset 6e9ae72 for lib

Timestamp:

2011-12-17T13:50:01Z (13 years ago)

Author:

Wilmer van der Gaast <wilmer@…>

Branches:

master

Children:

18c6d36

Parents:

87dddee (diff), 17f057d (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:

Mainline merge.

Location:

lib

Files:

• http_client.c (modified) (9 diffs)
• ssl_client.h (modified) (1 diff)
• ssl_gnutls.c (modified) (6 diffs)
• ssl_nss.c (modified) (1 diff)
• ssl_openssl.c (modified) (1 diff)
• xmltree.c (modified) (10 diffs)

lib/http_client.c

@@ -2 +2 @@
   * BitlBee -- An IRC to other IM-networks gateway                     *
   *                                                                    *
-  * Copyright 2002-2005 Wilmer van der Gaast and others                *
+  * Copyright 2002-2011 Wilmer van der Gaast and others                *
   \********************************************************************/
 
@@ -69 +69 @@
         req->request_length = strlen( request );
         req->redir_ttl = 3;
+        
+        if( getenv( "BITLBEE_DEBUG" ) )
+                printf( "About to send HTTP request:\n%s\n", req->request );
         
         return( req );
@@ -240 +243 @@
                                  http_incoming_data, req );
         
-        return FALSE;
+        if( ssl_pending( req->ssl ) )
+                return http_incoming_data( data, source, cond );
+        else
+                return FALSE;
 
 got_reply:
@@ -275 +281 @@
         
         *end1 = 0;
+        
+        if( getenv( "BITLBEE_DEBUG" ) )
+                printf( "HTTP response headers:\n%s\n", req->reply_headers );
         
         if( evil_server )
@@ -314 +323 @@
         }
         
-        if( ( req->status_code == 301 || req->status_code == 302 ) && req->redir_ttl-- > 0 )
+        if( ( ( req->status_code >= 301 && req->status_code <= 303 ) ||
+              req->status_code == 307 ) && req->redir_ttl-- > 0 )
         {
                 char *loc, *new_request, *new_host;
@@ -354 +364 @@
                         url_t *url;
                         char *s;
+                        const char *new_method;
                         
                         s = strstr( loc, "\r\n" );
@@ -369 +380 @@
                         }
                         
-                        /* Okay, this isn't fun! We have to rebuild the request... :-( */
-                        new_request = g_malloc( req->request_length + strlen( url->file ) );
-                        
-                        /* So, now I just allocated enough memory, so I'm
-                           going to use strcat(), whether you like it or not. :-) */
-                        
-                        sprintf( new_request, "GET %s HTTP/1.0", url->file );
-                        
-                        s = strstr( req->request, "\r\n" );
-                        if( s == NULL )
+                        /* Find all headers and, if necessary, the POST request contents.
+                           Skip the old Host: header though. This crappy code here means
+                           anything using this http_client MUST put the Host: header at
+                           the top. */
+                        if( !( ( s = strstr( req->request, "\r\nHost: " ) ) &&
+                               ( s = strstr( s + strlen( "\r\nHost: " ), "\r\n" ) ) ) )
                         {
                                 req->status_string = g_strdup( "Error while rebuilding request string" );
-                                g_free( new_request );
                                 g_free( url );
                                 goto cleanup;
                         }
                         
-                        strcat( new_request, s );
+                        /* More or less HTTP/1.0 compliant, from my reading of RFC 2616.
+                           Always perform a GET request unless we received a 301. 303 was
+                           meant for this but it's HTTP/1.1-only and we're specifically
+                           speaking HTTP/1.0. ...
+                           
+                           Well except someone at identi.ca's didn't bother reading any
+                           RFCs and just return HTTP/1.1-specific status codes to HTTP/1.0
+                           requests. Fuckers. So here we are, handle 301..303,307. */
+                        if( strncmp( req->request, "GET", 3 ) == 0 )
+                                /* GETs never become POSTs. */
+                                new_method = "GET";
+                        else if( req->status_code == 302 || req->status_code == 303 )
+                                /* 302 de-facto becomes GET, 303 as specified by RFC 2616#10.3.3 */
+                                new_method = "GET";
+                        else
+                                /* 301 de-facto should stay POST, 307 specifally RFC 2616#10.3.8 */
+                                new_method = "POST";
+                        
+                        /* Okay, this isn't fun! We have to rebuild the request... :-( */
+                        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 );
                         new_port = url->port;
                         new_proto = url->proto;
+                        
+                        /* If we went from POST to GET, truncate the request content. */
+                        if( new_request[0] != req->request[0] && new_request[0] == 'G' &&
+                            ( s = strstr( new_request, "\r\n\r\n" ) ) )
+                                s[4] = '\0';
                         
                         g_free( url );
@@ -402 +434 @@
                 req->ssl = NULL;
                 
+                if( getenv( "BITLBEE_DEBUG" ) )
+                        printf( "New headers for redirected HTTP request:\n%s\n", new_request );
+        
                 if( new_proto == PROTO_HTTPS )
                 {
@@ -443 +478 @@
                 closesocket( req->fd );
         
+        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 );

lib/ssl_client.h

@@ -63 +63 @@
 G_MODULE_EXPORT int ssl_write( void *conn, const char *buf, int len );
 
-/* See ssl_openssl.c for an explanation. */
+/* Now needed by most SSL libs. See for more info:
+   http://www.gnu.org/software/gnutls/manual/gnutls.html#index-gnutls_005frecord_005fcheck_005fpending-209
+   http://www.openssl.org/docs/ssl/SSL_pending.html
+   
+   Required because OpenSSL empties the TCP buffer completely but doesn't
+   necessarily give us all the unencrypted data. Or maybe you didn't ask
+   for all of it because your buffer is too small.
+   
+   Returns 0 if there's nothing left, 1 if there's more data. */
 G_MODULE_EXPORT int ssl_pending( void *conn );
 

lib/ssl_gnutls.c

@@ -45 +45 @@
 #endif
 
+#define SSLDEBUG 0
+
 struct scd
 {
@@ -135 +137 @@
         gnutls_certificate_allocate_credentials( &conn->xcred );
         gnutls_init( &conn->session, GNUTLS_CLIENT );
-        gnutls_transport_set_lowat( conn->session, 1 ); 
+#if GNUTLS_VERSION_NUMBER < 0x020c00
+        gnutls_transport_set_lowat( conn->session, 0 );
+#endif
         gnutls_set_default_priority( conn->session );
         gnutls_credentials_set( conn->session, GNUTLS_CRD_CERTIFICATE, conn->xcred );
@@ -187 +191 @@
         {
                 ssl_errno = SSL_NOHANDSHAKE;
-                return( -1 );
+                return -1;
         }
         
@@ -196 +200 @@
                 ssl_errno = SSL_AGAIN;
         
-        if( 0 && getenv( "BITLBEE_DEBUG" ) && st > 0 ) len = write( 1, buf, st );
+        if( SSLDEBUG && getenv( "BITLBEE_DEBUG" ) && st > 0 ) len = write( 2, buf, st );
         
         return st;
@@ -208 +212 @@
         {
                 ssl_errno = SSL_NOHANDSHAKE;
-                return( -1 );
+                return -1;
         }
         
@@ -217 +221 @@
                 ssl_errno = SSL_AGAIN;
         
-        if( 0 && getenv( "BITLBEE_DEBUG" ) && st > 0 ) len = write( 1, buf, st );
+        if( SSLDEBUG && getenv( "BITLBEE_DEBUG" ) && st > 0 ) len = write( 2, buf, st );
         
         return st;
 }
 
-/* See ssl_openssl.c for an explanation. */
 int ssl_pending( void *conn )
 {
-        return 0;
+        if( conn == NULL )
+                return 0;
+        
+        if( !((struct scd*)conn)->established )
+        {
+                ssl_errno = SSL_NOHANDSHAKE;
+                return 0;
+        }
+        
+        return gnutls_record_check_pending( ((struct scd*)conn)->session ) != 0;
 }
 

lib/ssl_nss.c

@@ -207 +207 @@
 }
 
-/* See ssl_openssl.c for an explanation. */
 int ssl_pending( void *conn )
 {

lib/ssl_openssl.c

@@ -241 +241 @@
 }
 
-/* Only OpenSSL *really* needs this (and well, maybe NSS). See for more info:
-   http://www.gnu.org/software/gnutls/manual/gnutls.html#index-gnutls_005frecord_005fcheck_005fpending-209
-   http://www.openssl.org/docs/ssl/SSL_pending.html
-   
-   Required because OpenSSL empties the TCP buffer completely but doesn't
-   necessarily give us all the unencrypted data.
-   
-   Returns 0 if there's nothing left or if we don't have to care (GnuTLS),
-   1 if there's more data. */
 int ssl_pending( void *conn )
 {

lib/xmltree.c

@@ -323 +323 @@
 }
 
-#ifdef DEBUG
 void xt_print( struct xt_node *node )
 {
@@ -331 +330 @@
         /* Indentation */
         for( c = node; c->parent; c = c->parent )
-                printf( "    " );
+                fprintf( stderr, "    " );
         
         /* Start the tag */
-        printf( "<%s", node->name );
+        fprintf( stderr, "<%s", node->name );
         
         /* Print the attributes */
@@ -340 +339 @@
         {
                 char *v = g_markup_escape_text( node->attr[i].value, -1 );
-                printf( " %s=\"%s\"", node->attr[i].key, v );
+                fprintf( stderr, " %s=\"%s\"", node->attr[i].key, v );
                 g_free( v );
         }
@@ -349 +348 @@
         if( node->text == NULL && node->children == NULL )
         {
-                printf( "/>\n" );
+                fprintf( stderr, "/>\n" );
                 return;
                 /* Then we're finished! */
@@ -355 +354 @@
         
         /* Otherwise... */
-        printf( ">" );
+        fprintf( stderr, ">" );
         
         /* Only print the text if it contains more than whitespace (TEST). */
@@ -364 +363 @@
                 {
                         char *v = g_markup_escape_text( node->text, -1 );
-                        printf( "%s", v );
+                        fprintf( stderr, "%s", v );
                         g_free( v );
                 }
@@ -370 +369 @@
         
         if( node->children )
-                printf( "\n" );
+                fprintf( stderr, "\n" );
         
         for( c = node->children; c; c = c->next )
@@ -377 +376 @@
         if( node->children )
                 for( c = node; c->parent; c = c->parent )
-                        printf( "    " );
+                        fprintf( stderr, "    " );
         
         /* Non-empty tag is now finished. */
-        printf( "</%s>\n", node->name );
-}
-#endif
+        fprintf( stderr, "</%s>\n", node->name );
+}
 
 struct xt_node *xt_dup( struct xt_node *node )
@@ -557 +555 @@
 }
 
+/* Strip a few non-printable characters that aren't allowed in XML streams
+   (and upset some XMPP servers for example). */
+void xt_strip_text( char *in )
+{
+        char *out = in;
+        static const char nonprint[32] = {
+                0, 0, 0, 0, 0, 0, 0, 0, /* 0..7 */
+                0, 1, 1, 0, 0, 1, 0, 0, /* 9 (tab), 10 (\n), 13 (\r) */
+        };
+        
+        if( !in )
+                return;
+
+        while( *in )
+        {
+                if( (unsigned int) *in >= ' ' || nonprint[(unsigned int) *in] )
+                        *out ++ = *in;
+                in ++;
+        }
+        *out = *in;
+}
+
 struct xt_node *xt_new_node( char *name, const char *text, struct xt_node *children )
 {
@@ -568 +588 @@
         if( text )
         {
-                node->text_len = strlen( text );
-                node->text = g_memdup( text, node->text_len + 1 );
+                node->text = g_strdup( text );
+                xt_strip_text( node->text );
+                node->text_len = strlen( node->text );
         }