Changeset 9c77fbf


Ignore:
Timestamp:
2012-09-22T12:47:55Z (7 years ago)
Author:
Wilmer van der Gaast <wilmer@…>
Branches:
master
Children:
6bef211
Parents:
c6fc24a (diff), 11ec078 (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:

Merge mainline.

Files:
9 edited

Legend:

Unmodified
Added
Removed
  • lib/http_client.c

    rc6fc24a r9c77fbf  
    7373                printf( "About to send HTTP request:\n%s\n", req->request );
    7474       
    75         return( req );
     75        return req;
    7676}
    7777
     
    198198        int evil_server = 0;
    199199        char buffer[2048];
    200         char *end1, *end2;
     200        char *end1, *end2, *s;
     201        size_t content_length;
    201202        int st;
    202203       
     
    481482        /* Assume that a closed connection means we're finished, this indeed
    482483           breaks with keep-alive connections and faulty connections. */
    483         req->finished = 1;
     484        /* req->finished = 1; */
    484485
    485486cleanup:
     
    488489        else
    489490                closesocket( req->fd );
     491       
     492        if( ( s = get_rfc822_header( req->reply_headers, "Content-Length", 0 ) ) &&
     493            sscanf( s, "%zd", &content_length ) == 1 )
     494        {
     495                if( content_length < req->body_size )
     496                {
     497                        req->status_code = -1;
     498                        g_free( req->status_string );
     499                        req->status_string = g_strdup( "Response truncated" );
     500                }
     501        }
     502        g_free( s );
    490503       
    491504        if( getenv( "BITLBEE_DEBUG" ) && req )
  • lib/http_client.h

    rc6fc24a r9c77fbf  
    5959        char *reply_body;
    6060        int body_size;          /* The number of bytes in reply_body. */
    61         int finished;           /* Set to non-0 if the request was completed
     61        /* int finished;          Set to non-0 if the request was completed
    6262                                   successfully. */
    6363        int redir_ttl;          /* You can set it to 0 if you don't want
  • lib/misc.c

    rc6fc24a r9c77fbf  
    730730}
    731731
    732 char *get_rfc822_header( char *text, char *header, int len )
     732char *get_rfc822_header( const char *text, const char *header, int len )
    733733{
    734734        int hlen = strlen( header ), i;
    735         char *ret;
     735        const char *ret;
    736736       
    737737        if( text == NULL )
  • lib/misc.h

    rc6fc24a r9c77fbf  
    6868G_MODULE_EXPORT int md5_verify_password( char *password, char *hash );
    6969G_MODULE_EXPORT char **split_command_parts( char *command );
    70 G_MODULE_EXPORT char *get_rfc822_header( char *text, char *header, int len );
     70G_MODULE_EXPORT char *get_rfc822_header( const char *text, const char *header, int len );
    7171
    7272#endif
  • lib/xmltree.c

    rc6fc24a r9c77fbf  
    263263}
    264264
    265 struct xt_node *xt_from_string( const char *in )
     265struct xt_node *xt_from_string( const char *in, int len )
    266266{
    267267        struct xt_parser *parser;
    268268        struct xt_node *ret;
    269269       
     270        if( len == 0 )
     271                len = strlen( in );
     272       
    270273        parser = xt_new( NULL, NULL );
    271         xt_feed( parser, in, strlen( in ) );
     274        xt_feed( parser, in, len );
    272275        ret = parser->root;
    273276        parser->root = NULL;
  • lib/xmltree.h

    rc6fc24a r9c77fbf  
    8282int xt_handle( struct xt_parser *xt, struct xt_node *node, int depth );
    8383void xt_cleanup( struct xt_parser *xt, struct xt_node *node, int depth );
    84 struct xt_node *xt_from_string( const char *in );
     84struct xt_node *xt_from_string( const char *in, int text_len );
    8585char *xt_to_string( struct xt_node *node );
    8686void xt_print( struct xt_node *node );
  • protocols/msn/ns.c

    rc6fc24a r9c77fbf  
    740740                char *psm_text = NULL;
    741741               
    742                 ubx = xt_from_string( msg );
     742                ubx = xt_from_string( msg, msglen );
    743743                if( ubx && strcmp( ubx->name, "Data" ) == 0 &&
    744744                    ( psm = xt_find_node( ubx->children, "PSM" ) ) )
     
    752752                struct xt_node *adl, *d, *c;
    753753               
    754                 if( !( adl = xt_from_string( msg ) ) )
     754                if( !( adl = xt_from_string( msg, msglen ) ) )
    755755                        return 1;
    756756               
  • protocols/msn/soap.c

    rc6fc24a r9c77fbf  
    229229        if( payload )
    230230        {
    231                 struct xt_node *xt = xt_from_string( payload );
     231                struct xt_node *xt = xt_from_string( payload, 0 );
    232232                if( xt )
    233233                        xt_print( xt );
  • protocols/twitter/twitter_lib.c

    rc6fc24a r9c77fbf  
    168168{
    169169        static char *ret = NULL;
    170         struct xt_parser *xp = NULL;
    171         struct xt_node *node, *err;
     170        struct xt_node *root, *node, *err;
    172171
    173172        g_free(ret);
     
    175174
    176175        if (req->body_size > 0) {
    177                 xp = xt_new(NULL, NULL);
    178                 xt_feed(xp, req->reply_body, req->body_size);
     176                root = xt_from_string(req->reply_body, req->body_size);
    179177               
    180                 for (node = xp->root; node; node = node->next)
     178                for (node = root; node; node = node->next)
    181179                        if ((err = xt_find_node(node->children, "error")) && err->text_len > 0) {
    182180                                ret = g_strdup_printf("%s (%s)", req->status_string, err->text);
     
    184182                        }
    185183
    186                 xt_free(xp);
     184                xt_free_node(root);
    187185        }
    188186
     
    256254{
    257255        struct im_connection *ic;
    258         struct xt_parser *parser;
     256        struct xt_node *parsed;
    259257        struct twitter_xml_list *txl;
    260258        struct twitter_data *td;
     
    292290
    293291        // Parse the data.
    294         parser = xt_new(NULL, txl);
    295         xt_feed(parser, req->reply_body, req->body_size);
    296         twitter_xt_get_friends_id_list(parser->root, txl);
    297         xt_free(parser);
     292        parsed = xt_from_string(req->reply_body, req->body_size);
     293        twitter_xt_get_friends_id_list(parsed, txl);
     294        xt_free_node(parsed);
    298295
    299296        td->follow_ids = txl->list;
     
    352349        struct im_connection *ic = req->data;
    353350        struct twitter_data *td;
    354         struct xt_parser *parser;
     351        struct xt_node *parsed;
    355352        struct twitter_xml_list *txl;
    356353        GSList *l = NULL;
     
    377374
    378375        // Parse the data.
    379         parser = xt_new(NULL, txl);
    380         xt_feed(parser, req->reply_body, req->body_size);
     376        parsed = xt_from_string(req->reply_body, req->body_size);
    381377
    382378        // Get the user list from the parsed xml feed.
    383         twitter_xt_get_users(parser->root, txl);
    384         xt_free(parser);
     379        twitter_xt_get_users(parsed, txl);
     380        xt_free_node(parsed);
    385381
    386382        // Add the users as buddies.
     
    739735
    740736        if (td->flags & TWITTER_DOING_TIMELINE) {
    741                 return;
     737                if (++td->http_fails >= 5) {
     738                        imcb_error(ic, "Fetch timeout (%d)", td->flags);
     739                        imc_logout(ic, TRUE);
     740                }
    742741        }
    743742
     
    886885        struct im_connection *ic = req->data;
    887886        struct twitter_data *td;
    888         struct xt_parser *parser;
     887        struct xt_node *parsed;
    889888        struct twitter_xml_list *txl;
    890889
     
    913912
    914913        // Parse the data.
    915         parser = xt_new(NULL, txl);
    916         xt_feed(parser, req->reply_body, req->body_size);
     914        parsed = xt_from_string(req->reply_body, req->body_size);
    917915        // The root <statuses> node should hold the list of statuses <status>
    918         twitter_xt_get_status_list(ic, parser->root, txl);
    919         xt_free(parser);
     916        twitter_xt_get_status_list(ic, parsed, txl);
     917        xt_free_node(parsed);
    920918
    921919        td->home_timeline_obj = txl;
     
    934932        struct im_connection *ic = req->data;
    935933        struct twitter_data *td;
    936         struct xt_parser *parser;
     934        struct xt_node *parsed;
    937935        struct twitter_xml_list *txl;
    938936
     
    961959
    962960        // Parse the data.
    963         parser = xt_new(NULL, txl);
    964         xt_feed(parser, req->reply_body, req->body_size);
     961        parsed = xt_from_string(req->reply_body, req->body_size);
    965962        // The root <statuses> node should hold the list of statuses <status>
    966         twitter_xt_get_status_list(ic, parser->root, txl);
    967         xt_free(parser);
     963        twitter_xt_get_status_list(ic, parsed, txl);
     964        xt_free_node(parsed);
    968965
    969966        td->mentions_obj = txl;
     
    999996
    1000997        if (req->body_size > 0) {
    1001                 struct xt_parser *xp = NULL;
    1002                 struct xt_node *node;
    1003 
    1004                 xp = xt_new(NULL, NULL);
    1005                 xt_feed(xp, req->reply_body, req->body_size);
    1006 
    1007                 if ((node = xt_find_node(xp->root, "status")) &&
     998                struct xt_node *parsed, *node;
     999
     1000                parsed = xt_from_string(req->reply_body, req->body_size);
     1001
     1002                if ((node = xt_find_node(parsed, "status")) &&
    10081003                    (node = xt_find_node(node->children, "id")) && node->text)
    10091004                        td->last_status_id = g_ascii_strtoull(node->text, NULL, 10);
    10101005
    1011                 xt_free(xp);
     1006                xt_free_node(parsed);
    10121007        }
    10131008}
Note: See TracChangeset for help on using the changeset viewer.