Changeset 4ff0966


Ignore:
Timestamp:
2006-05-28T23:13:47Z (13 years ago)
Author:
Wilmer van der Gaast <wilmer@…>
Branches:
master
Children:
df417ca
Parents:
cdca30b (diff), 79b6213 (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 from main/jelmer.

Files:
11 edited

Legend:

Unmodified
Added
Removed
  • configure

    rcdca30b r4ff0966  
    169169fi
    170170
    171 GLIB=0
    172 
    173171if $PKG_CONFIG --version > /dev/null 2>/dev/null && $PKG_CONFIG glib-2.0; then
    174172        cat<<EOF>>Makefile.settings
     
    176174CFLAGS+=`$PKG_CONFIG --cflags glib-2.0 gmodule-2.0`
    177175EOF
    178         echo '#define GLIB2' >> config.h
    179         GLIB=2
    180 elif type glib-config > /dev/null 2> /dev/null; then
    181         cat<<EOF>>Makefile.settings
    182 EFLAGS+=`glib-config --libs`
    183 CFLAGS+=`glib-config --cflags`
    184 EOF
    185         echo '#define GLIB1' >> config.h
    186         GLIB=1
    187 else
    188         echo 'Cannot find glib development libraries, aborting. (Install libglib-dev?)'
     176else
     177        echo 'Cannot find glib2 development libraries, aborting. (Install libglib2-dev?)'
    189178        exit 1;
    190179fi
    191 
    192 if [ GLIB = 1 -o -r /usr/include/iconv.h ]; then
    193         :;
    194 elif [ -r /usr/local/include/iconv.h ]; then
    195         echo CFLAGS+=-I/usr/local/include >> Makefile.settings
    196 else
    197         echo
    198         echo 'Warning: Could not find iconv.h, you might have to install it and/or modify'
    199         echo 'Makefile.settings to tell where this file is.'
    200 fi
    201 
    202180
    203181if [ "$events" = "libevent" ]; then
     
    223201fi
    224202echo 'EVENT_HANDLER=events_'$events'.o' >> Makefile.settings
    225 
    226203
    227204detect_gnutls()
     
    420397;;
    421398*BSD )
    422         echo 'EFLAGS+=-liconv' >> Makefile.settings;
     399;;
     400Darwin )
     401;;
     402IRIX )
    423403;;
    424404SunOS )
    425405        echo 'EFLAGS+=-lresolv -lnsl -lsocket' >> Makefile.settings
    426406        echo 'STRIP=\# skip strip' >> Makefile.settings
    427         echo 'EFLAGS+=-liconv' >> Makefile.settings;
    428 ;;
    429 Darwin )
    430         echo 'EFLAGS+=-liconv' >> Makefile.settings;
    431 ;;
    432 IRIX )
    433407;;
    434408CYGWIN* )
  • doc/README

    rcdca30b r4ff0966  
    4747
    4848BitlBee's only real dependency is GLib. This is available on virtually every
    49 platform. Any recent version of GLib (including 1.x versions) will work.
     49platform. Any recent version of GLib (2.0 or higher) will work.
    5050
    5151These days, MSN Messenger clients have to connect to the MS Passport servers
  • irc_commands.c

    rcdca30b r4ff0966  
    321321{
    322322        user_t *u;
    323         char buff[IRC_MAX_LINE];
     323        char buff[IRC_MAX_LINE], *s;
    324324        int lenleft, i;
    325325       
     
    331331        for( i = 1; cmd[i]; i ++ )
    332332        {
    333                 if( ( u = user_find( irc, cmd[i] ) ) && u->online )
    334                 {
    335                         /* [SH] Make sure we don't use too much buffer space. */
    336                         lenleft -= strlen( u->nick ) + 1;
    337                        
    338                         if( lenleft < 0 )
     333                char *this, *next;
     334               
     335                this = cmd[i];
     336                while( *this )
     337                {
     338                        if( ( next = strchr( this, ' ' ) ) )
     339                                *next = 0;
     340                       
     341                        if( ( u = user_find( irc, this ) ) && u->online )
     342                        {
     343                                lenleft -= strlen( u->nick ) + 1;
     344                               
     345                                if( lenleft < 0 )
     346                                        break;
     347                               
     348                                strcat( buff, u->nick );
     349                                strcat( buff, " " );
     350                        }
     351                       
     352                        if( next )
     353                        {
     354                                *next = ' ';
     355                                this = next + 1;
     356                        }
     357                        else
    339358                        {
    340359                                break;
    341                         }
    342                        
    343                         /* [SH] Add the nick to the buffer. Note
    344                          * that an extra space is always added. Even
    345                          * if it's the last nick in the list. Who
    346                          * cares?
    347                          */
    348                        
    349                         strcat( buff, u->nick );
    350                         strcat( buff, " " );
    351                 }
    352         }
    353        
    354         /* [WvG] Well, maybe someone cares, so why not remove it? */
     360                        }   
     361                }
     362               
     363                /* *sigh* */
     364                if( lenleft < 0 )
     365                        break;
     366        }
     367       
    355368        if( strlen( buff ) > 0 )
    356369                buff[strlen(buff)-1] = '\0';
  • protocols/http_client.c

    rcdca30b r4ff0966  
    157157       
    158158error:
     159        req->status_string = g_strdup( "Error while writing HTTP request" );
     160       
    159161        req->func( req );
    160162       
     
    216218                        if( !sockerr_again() )
    217219                        {
     220                                req->status_string = g_strdup( strerror( errno ) );
    218221                                goto cleanup;
    219222                        }
     
    243246           support... */
    244247        if( req->bytes_read == 0 )
     248        {
     249                req->status_string = g_strdup( "Empty HTTP reply" );
    245250                goto cleanup;
     251        }
    246252       
    247253        /* Zero termination is very convenient. */
     
    264270        else
    265271        {
     272                req->status_string = g_strdup( "Malformed HTTP reply" );
    266273                goto cleanup;
    267274        }
     
    279286        {
    280287                if( sscanf( end1 + 1, "%d", &req->status_code ) != 1 )
     288                {
     289                        req->status_string = g_strdup( "Can't parse status code" );
    281290                        req->status_code = -1;
    282         }
    283         else
    284         {
     291                }
     292                else
     293                {
     294                        char *eol;
     295                       
     296                        if( evil_server )
     297                                eol = strchr( end1, '\n' );
     298                        else
     299                                eol = strchr( end1, '\r' );
     300                       
     301                        req->status_string = g_strndup( end1 + 1, eol - end1 - 1 );
     302                       
     303                        /* Just to be sure... */
     304                        if( ( eol = strchr( req->status_string, '\r' ) ) )
     305                                *eol = 0;
     306                        if( ( eol = strchr( req->status_string, '\n' ) ) )
     307                                *eol = 0;
     308                }
     309        }
     310        else
     311        {
     312                req->status_string = g_strdup( "Can't locate status code" );
    285313                req->status_code = -1;
    286314        }
     
    291319                int error = 0, new_port, new_proto;
    292320               
     321                /* We might fill it again, so let's not leak any memory. */
     322                g_free( req->status_string );
     323                req->status_string = NULL;
     324               
    293325                loc = strstr( req->reply_headers, "\nLocation: " );
    294326                if( loc == NULL ) /* We can't handle this redirect... */
     327                {
     328                        req->status_string = g_strdup( "Can't locate Location: header" );
    295329                        goto cleanup;
     330                }
    296331               
    297332                loc += 11;
     
    310345                           don't need this yet anyway, I won't implement it. */
    311346                       
     347                        req->status_string = g_strdup( "Can't handle recursive redirects" );
     348                       
    312349                        goto cleanup;
    313350                }
     
    327364                        if( !url_set( url, loc ) )
    328365                        {
     366                                req->status_string = g_strdup( "Malformed redirect URL" );
    329367                                g_free( url );
    330368                                goto cleanup;
     
    337375                           going to use strcat(), whether you like it or not. :-) */
    338376                       
    339                         /* First, find the GET/POST/whatever from the original request. */
    340                         s = strchr( req->request, ' ' );
     377                        sprintf( new_request, "GET %s HTTP/1.0", url->file );
     378                       
     379                        s = strstr( req->request, "\r\n" );
    341380                        if( s == NULL )
    342381                        {
     382                                req->status_string = g_strdup( "Error while rebuilding request string" );
    343383                                g_free( new_request );
    344384                                g_free( url );
     
    346386                        }
    347387                       
    348                         *s = 0;
    349                         sprintf( new_request, "%s %s HTTP/1.0\r\n", req->request, url->file );
    350                         *s = ' ';
    351                        
    352                         s = strstr( req->request, "\r\n" );
    353                         if( s == NULL )
    354                         {
    355                                 g_free( new_request );
    356                                 g_free( url );
    357                                 goto cleanup;
    358                         }
    359                        
    360                         strcat( new_request, s + 2 );
     388                        strcat( new_request, s );
    361389                        new_host = g_strdup( url->host );
    362390                        new_port = url->port;
     
    372400               
    373401                req->fd = -1;
    374                 req->ssl = 0;
     402                req->ssl = NULL;
    375403               
    376404                if( new_proto == PROTO_HTTPS )
     
    390418                if( error )
    391419                {
     420                        req->status_string = g_strdup( "Connection problem during redirect" );
    392421                        g_free( new_request );
    393422                        goto cleanup;
     
    418447        g_free( req->request );
    419448        g_free( req->reply_headers );
     449        g_free( req->status_string );
    420450        g_free( req );
    421451       
  • protocols/http_client.h

    rcdca30b r4ff0966  
    3737        int request_length;
    3838        int status_code;
     39        char *status_string;
    3940        char *reply_headers;
    4041        char *reply_body;
  • protocols/msn/ns.c

    rcdca30b r4ff0966  
    656656        if( key == NULL )
    657657        {
    658                 hide_login_progress( gc, "Error during Passport authentication" );
     658                char *err;
     659               
     660                err = g_strdup_printf( "Error during Passport authentication (%s)",
     661                                       rep->error_string ? rep->error_string : "Unknown error" );
     662               
     663                hide_login_progress( gc, err );
    659664                signoff( gc );
     665               
     666                g_free( err );
    660667        }
    661668        else
  • protocols/msn/passport.c

    rcdca30b r4ff0966  
    6969        }
    7070       
    71         reqs = g_malloc( strlen( header ) + strlen( dummy ) + 128 );
    72         sprintf( reqs, "GET %s HTTP/1.0\r\n%s\r\n\r\n", dummy, header );
     71        reqs = g_strdup_printf( "GET %s HTTP/1.0\r\n%s\r\n\r\n", dummy, header );
    7372       
    7473        *dummy = 0;
     
    8887        struct passport_reply *rep = req->data;
    8988       
    90         if( !g_slist_find( msn_connections, rep->data ) || !req->finished || !req->reply_headers )
     89        if( !g_slist_find( msn_connections, rep->data ) )
    9190        {
    9291                destroy_reply( rep );
     
    9493        }
    9594       
    96         if( req->status_code == 200 )
     95        if( req->finished && req->reply_headers && req->status_code == 200 )
    9796        {
    9897                char *dummy;
     
    109108                        rep->result = g_strdup( dummy );
    110109                }
     110                else
     111                {
     112                        rep->error_string = g_strdup( "Could not parse Passport server response" );
     113                }
     114        }
     115        else
     116        {
     117                rep->error_string = g_strdup_printf( "HTTP error: %s",
     118                                      req->status_string ? req->status_string : "Unknown error" );
    111119        }
    112120       
     
    145153}
    146154
    147 #define PPR_REQUEST "GET /rdr/pprdr.asp HTTP/1.0\r\n\r\n"
    148155static int passport_retrieve_dalogin( gpointer func, gpointer data, char *header )
    149156{
     
    155162        rep->header = header;
    156163       
    157         req = http_dorequest( "nexus.passport.com", 443, 1, PPR_REQUEST, passport_retrieve_dalogin_ready, rep );
     164        req = http_dorequest_url( "https://nexus.passport.com/rdr/pprdr.asp", passport_retrieve_dalogin_ready, rep );
    158165       
    159166        if( !req )
     
    169176        char *urlend;
    170177       
    171         if( !g_slist_find( msn_connections, rep->data ) || !req->finished || !req->reply_headers )
     178        if( !g_slist_find( msn_connections, rep->data ) )
    172179        {
    173180                destroy_reply( rep );
     
    175182        }
    176183       
     184        if( !req->finished || !req->reply_headers || req->status_code != 200 )
     185        {
     186                rep->error_string = g_strdup_printf( "HTTP error while fetching DALogin: %s",
     187                                        req->status_string ? req->status_string : "Unknown error" );
     188                goto failure;
     189        }
     190       
    177191        dalogin = strstr( req->reply_headers, "DALogin=" );     
    178192       
    179193        if( !dalogin )
     194        {
     195                rep->error_string = g_strdup( "Parse error while fetching DALogin" );
    180196                goto failure;
     197        }
    181198       
    182199        dalogin += strlen( "DALogin=" );
     
    208225        g_free( rep->result );
    209226        g_free( rep->header );
     227        g_free( rep->error_string );
    210228        g_free( rep );
    211229}
  • protocols/msn/passport.h

    rcdca30b r4ff0966  
    3939        char *result;
    4040        char *header;
     41        char *error_string;
    4142};
    4243
  • protocols/msn/sb.c

    rcdca30b r4ff0966  
    529529                {
    530530                        msn_sb_destroy( sb );
    531                         return( 0 );
    532                 }
    533                 if( err->flags & STATUS_FATAL )
     531                        return 0;
     532                }
     533                else if( err->flags & STATUS_FATAL )
    534534                {
    535535                        signoff( gc );
    536                         return( 0 );
    537                 }
    538                 if( err->flags & STATUS_SB_IM_SPARE )
     536                        return 0;
     537                }
     538                else if( err->flags & STATUS_SB_IM_SPARE )
    539539                {
    540540                        if( sb->who )
     
    559559                                sb->msgq = NULL;
    560560                        }
     561                       
     562                        /* Do NOT return 0 here, we want to keep this sb. */
    561563                }
    562564        }
  • protocols/msn/tables.c

    rcdca30b r4ff0966  
    127127       
    128128        { 910, "Server is busy",                                        STATUS_FATAL },
    129         { 911, "Authentication failed",                                 STATUS_FATAL },
     129        { 911, "Authentication failed",                                 STATUS_SB_FATAL | STATUS_FATAL },
    130130        { 912, "Server is busy",                                        STATUS_FATAL },
    131131        { 913, "Not allowed when hiding",                               0 },
  • util.c

    rcdca30b r4ff0966  
    3939#include <glib.h>
    4040#include <time.h>
    41 #ifdef GLIB2
    42 #define iconv_t GIConv
    43 #define iconv_open g_iconv_open
    44 #define iconv_close g_iconv_close
    45 #define iconv g_iconv
    46 #else
    47 #include <iconv.h>
    48 #endif
    4941
    5042void strip_linefeed(gchar *text)
     
    465457signed int do_iconv( char *from_cs, char *to_cs, char *src, char *dst, size_t size, size_t maxbuf )
    466458{
    467         iconv_t cd;
     459        GIConv cd;
    468460        size_t res;
    469461        size_t inbytesleft, outbytesleft;
     
    471463        char *outbuf = dst;
    472464       
    473         cd = iconv_open( to_cs, from_cs );
    474         if( cd == (iconv_t) -1 )
     465        cd = g_iconv_open( to_cs, from_cs );
     466        if( cd == (GIConv) -1 )
    475467                return( -1 );
    476468       
    477469        inbytesleft = size ? size : strlen( src );
    478470        outbytesleft = maxbuf - 1;
    479         res = iconv( cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft );
     471        res = g_iconv( cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft );
    480472        *outbuf = '\0';
    481         iconv_close( cd );
     473        g_iconv_close( cd );
    482474       
    483475        if( res == (size_t) -1 )
     
    489481char *set_eval_charset( irc_t *irc, set_t *set, char *value )
    490482{
    491         iconv_t cd;
     483        GIConv cd;
    492484
    493485        if ( g_strncasecmp( value, "none", 4 ) == 0 )
    494486                return( value );
    495487
    496         cd = iconv_open( "UTF-8", value );
    497         if( cd == (iconv_t) -1 )
     488        cd = g_iconv_open( "UTF-8", value );
     489        if( cd == (GIConv) -1 )
    498490                return( NULL );
    499491
    500         iconv_close( cd );
     492        g_iconv_close( cd );
    501493        return( value );
    502494}
Note: See TracChangeset for help on using the changeset viewer.