Changeset 601e813


Ignore:
Timestamp:
2006-05-24T23:04:18Z (13 years ago)
Author:
Jelmer Vernooij <jelmer@…>
Branches:
master
Children:
80c1e4d
Parents:
46ad029 (diff), fc630f9 (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] Wilmer

Files:
1 added
43 edited

Legend:

Unmodified
Added
Removed
  • .bzrignore

    r46ad029 r601e813  
    1919decode
    2020encode
     21bitlbee.pc
     22.gdb_history
  • Makefile

    r46ad029 r601e813  
    1111# Program variables
    1212objects = account.o bitlbee.o crypting.o help.o ini.o ipc.o irc.o irc_commands.o nick.o query.o root_commands.o set.o storage.o storage_text.o url.o user.o util.o
     13headers = account.h bitlbee.h commands.h conf.h config.h crypting.h help.h ini.h ipc.h irc.h log.h nick.h query.h set.h sock.h storage.h url.h user.h protocols/http_client.h protocols/md5.h protocols/nogaim.h protocols/proxy.h protocols/sha.h protocols/ssl_client.h
    1314subdirs = protocols
    1415
     
    2627        $(MAKE) -C doc
    2728
    28 uninstall: uninstall-bin uninstall-doc
     29uninstall: uninstall-bin uninstall-doc 
    2930        @echo -e '\nmake uninstall does not remove files in '$(DESTDIR)$(ETCDIR)', you can use make uninstall-etc to do that.\n'
    3031
     
    6263uninstall-bin:
    6364        rm -f $(DESTDIR)$(BINDIR)/$(OUTFILE)
     65
     66install-dev:
     67        mkdir -p $(DESTDIR)$(INCLUDEDIR)
     68        install -m 0644 $(headers) $(DESTDIR)$(INCLUDEDIR)
     69        mkdir -p $(DESTDIR)$(PCDIR)
     70        install -m 0644 bitlbee.pc $(DESTDIR)$(PCDIR)
     71
     72uninstall-dev:
     73        rm -f $(foreach hdr,$(headers),$(DESTDIR)$(INCLUDEDIR)/$(hdr))
     74        -rmdir $(DESTDIR)$(INCLUDEDIR)
     75        rm -f $(DESTDIR)$(PCDIR)/bitlbee.pc
    6476
    6577install-etc:
  • account.c

    r46ad029 r601e813  
    5353{
    5454        account_t *a, *ret = NULL;
     55        char *handle, *s;
    5556        int nr;
     57       
     58        /* This checks if the id string ends with (...) */
     59        if( ( handle = strchr( id, '(' ) ) && ( s = strchr( handle, ')' ) ) && s[1] == 0 )
     60        {
     61                struct prpl *proto;
     62               
     63                *s = *handle = 0;
     64                handle ++;
     65               
     66                if( ( proto = find_protocol( id ) ) )
     67                {
     68                        for( a = irc->accounts; a; a = a->next )
     69                                if( a->prpl == proto &&
     70                                    a->prpl->cmp_buddynames( handle, a->user ) == 0 )
     71                                        ret = a;
     72                }
     73               
     74                /* Restore the string. */
     75                handle --;
     76                *handle = '(';
     77                *s = ')';
     78               
     79                if( ret )
     80                        return ret;
     81        }
    5682       
    5783        if( sscanf( id, "%d", &nr ) == 1 && nr < 1000 )
     
    141167void account_off( irc_t *irc, account_t *a )
    142168{
    143         account_offline( a->gc );
     169        a->gc->wants_to_die = TRUE;
     170        signoff( a->gc );
    144171        a->gc = NULL;
    145172        if( a->reconnect )
  • bitlbee.c

    r46ad029 r601e813  
    111111                   BitlBee process. So let's only close TTY-fds. */
    112112                if( isatty( 0 ) ) close( 0 );
    113                 if( isatty( 0 ) ) close( 1 );
    114                 if( isatty( 0 ) ) close( 2 );
     113                if( isatty( 1 ) ) close( 1 );
     114                if( isatty( 2 ) ) close( 2 );
    115115        }
    116116#endif
  • bitlbee.h

    r46ad029 r601e813  
    9999#include "storage.h"
    100100#include "set.h"
    101 #include "protocols/nogaim.h"
     101#include "nogaim.h"
    102102#include "commands.h"
    103103#include "account.h"
     
    108108#include "query.h"
    109109#include "sock.h"
     110#include "util.h"
    110111
    111112typedef struct global {
     
    130131void root_command( irc_t *irc, char *command[] );
    131132void bitlbee_shutdown( gpointer data );
    132 double gettime( void );
    133 G_MODULE_EXPORT void http_encode( char *s );
    134 G_MODULE_EXPORT void http_decode( char *s );
    135 G_MODULE_EXPORT char *strip_newlines(char *source);
    136133
    137134extern global_t global;
  • conf.c

    r46ad029 r601e813  
    9595                        conf->port = i;
    9696                }
    97                 else if( opt == 'p' )
     97                else if( opt == 'P' )
    9898                {
    9999                        g_free( conf->pidfile );
  • configure

    r46ad029 r601e813  
    1717ipcsocket='/var/run/bitlbee'
    1818plugindir='$prefix/lib/bitlbee'
     19pcdir='$prefix/lib/pkgconfig'
     20includedir='$prefix/include/bitlbee'
    1921
    2022msn=1
     
    8082pidfile=`eval echo "$pidfile" | sed 's/\/\{1,\}/\//g'`
    8183ipcsocket=`eval echo "$ipcsocket" | sed 's/\/\{1,\}/\//g'`
     84includedir=`eval echo "$includedir" | sed 's/\/\{1,\}/\//g'`
     85pcdir=`eval echo "$pcdir" | sed 's/\/\{1,\}/\//g'`
    8286
    8387cat<<EOF>Makefile.settings
     
    9195CONFIG=$config
    9296IPCSOCKET=$ipcsocket
     97INCLUDEDIR=$includedir
     98PCDIR=$pcdir
    9399
    94100ARCH=$arch
     
    300306
    301307echo
    302 if [ -z "$BITLBEE_VERSION" -a -d .bzr -a -x "`which bzr`" ]; then
     308if [ -z "$BITLBEE_VERSION" -a -d .bzr ] && type bzr > /dev/null 2> /dev/null; then
     309        nick=`bzr nick`
     310        if [ -n "$nick" -a "$nick" != "bitlbee" ]; then
     311                nick="-$nick"
     312        else
     313                nick=""
     314        fi
    303315        rev=`bzr revno`
    304316        echo 'Using bzr revision #'$rev' as version number'
    305         BITLBEE_VERSION=\"bzr-$rev\"
     317        BITLBEE_VERSION=\"bzr$nick-$rev\"
    306318fi
    307319
     
    313325fi
    314326
     327cat <<EOF>bitlbee.pc
     328prefix=$prefix
     329includedir=$includedir
     330
     331Name: bitlbee
     332Description: IRC to IM gateway
     333Requires: glib-2.0
     334Version: $BITLBEE_VERSION
     335Libs:
     336Cflags: -I\${includedir}
     337
     338EOF
     339
    315340protocols=''
    316341protoobjs=''
  • doc/bitlbee.8

    r46ad029 r601e813  
    116116.SH AUTHORS
    117117.PP
    118  Wilmer van der Gaast <lintux@lintux.cx>
     118 Wilmer van der Gaast <wilmer@gaast.net>
    119119.BR
    120120 Jelmer Vernooij <jelmer@vernstok.nl>
  • doc/bitlbee.xinetd

    r46ad029 r601e813  
    1414        server          = /usr/local/sbin/bitlbee
    1515       
    16         ## xinetd is fucking retarded, what's the use of this port flag if
    17         ## it HAS to be the same as in /etc/services ?
    18         # port          = 6667
     16        ## You might want to limit access to localhost only:
     17        # bind            = 127.0.0.1
     18       
     19        ## Thanks a lot to friedman@splode.com for telling us about the type
     20        ## argument, so now this file can be used without having to edit
     21        ## /etc/services too.
     22        type            = UNLISTED
     23        port            = 6667
    1924}
  • doc/example_plugin.c

    r46ad029 r601e813  
    33 * a shared library and place it in the plugin directory:
    44 *
    5  * gcc -o example.so -shared example.c
     5 * gcc -o example.so -shared example.c `pkg-config --cflags bitlbee`
    66 * cp example.so /usr/local/lib/bitlbee
    77 */
    88#include <stdio.h>
     9#include <bitlbee.h>
    910
    1011void init_plugin(void)
  • doc/user-guide/commands.xml

    r46ad029 r601e813  
    141141                <short-description>Add a buddy to your contact list</short-description>
    142142                <syntax>add &lt;connection&gt; &lt;handle&gt; [&lt;nick&gt;]</syntax>
     143                <syntax>add -tmp &lt;connection&gt; &lt;handle&gt; [&lt;nick&gt;]</syntax>
    143144
    144145                <description>
     
    149150                        <para>
    150151                                If you want, you can also tell BitlBee what nick to give the new contact. Of course you can also use the <emphasis>rename</emphasis> command for that, but sometimes this might be more convenient.
     152                        </para>
     153                       
     154                        <para>
     155                                Adding -tmp adds the buddy to the internal BitlBee structures only, not to the real contact list (like done by <emphasis>set handle_unknown add</emphasis>). This allows you to talk to people who are not in your contact list.
    151156                        </para>
    152157                </description>
     
    197202                <syntax>block &lt;nick&gt;</syntax>
    198203                <syntax>block &lt;connection&gt; &lt;handle&gt;</syntax>
     204                <syntax>block &lt;connection&gt;</syntax>
    199205
    200206                <description>
    201207                        <para>
    202208                                Puts the specified user on your ignore list. Either specify the user's nick when you have him/her in your contact list or a connection number and a user handle.
     209                        </para>
     210                       
     211                        <para>
     212                                When called with only a connection specification as an argument, the command displays the current block list for that connection.
    203213                        </para>
    204214                </description>
     
    214224                                Reverse of block. Unignores the specified user or user handle on specified connection.
    215225                        </para>
     226                       
     227                        <para>
     228                                When called with only a connection specification as an argument, the command displays the current allow list for that connection.
     229                        </para>
    216230                </description>
    217231        </bitlbee-command>
     
    607621
    608622                        <para>
    609                                 To identify yourself in later sessions, you can use the <emphasis>identify</emphasis> command.
     623                                To identify yourself in later sessions, you can use the <emphasis>identify</emphasis> command. To change your password later, you can use the <emphasis>set password</emphasis> command.
    610624                        </para>
    611625                </description>
  • help.c

    r46ad029 r601e813  
    116116                h = h->next;
    117117        }
    118         if( h )
     118        if( h && h->length > 0 )
    119119        {
    120120                char *s = g_new( char, h->length + 1 );
     
    123123                {
    124124                        g_free( h );
    125                         *help=NULL;
    126                         return( NULL );
     125                        *help = NULL;
     126                        return NULL;
    127127                }
    128128                mtime = stat->st_mtime;
    129129               
    130                 if( mtime > h->mtime ) {
    131                         return( NULL );
    132                         return( g_strdup( "Help file changed during this session. Please restart to get help back." ) );
    133                 }
     130                if( mtime > h->mtime )
     131                        return NULL;
     132               
    134133                s[h->length] = 0;
    135134                if( h->fd >= 0 )
     
    142141                        strncpy( s, h->offset.mem_offset, h->length );
    143142                }
    144                 return( s );
     143                return s;
    145144        }
    146145       
    147         return( NULL );
     146        return NULL;
    148147}
  • ipc.c

    r46ad029 r601e813  
    8484void ipc_master_cmd_restart( irc_t *data, char **cmd )
    8585{
    86         struct bitlbee_child *child = (void*) data;
    87        
    8886        if( global.conf->runmode != RUNMODE_FORKDAEMON )
    8987        {
     
    509507        }
    510508
    511         if (bind(serversock, &un_addr, sizeof(un_addr)) == -1) {
     509        if (bind(serversock, (struct sockaddr *)&un_addr, sizeof(un_addr)) == -1) {
    512510                log_message( LOGLVL_WARNING, "Unable to bind UNIX socket to %s: %s", IPCSOCKET, strerror(errno) );
    513511                return 0;
     
    573571        ipc_to_children_str( "OPERMSG :New BitlBee master process started (version " BITLBEE_VERSION ")\r\n" );
    574572       
     573        fclose( fp );
    575574        return 1;
    576575}
  • ipc.h

    r46ad029 r601e813  
    4747
    4848void ipc_to_master( char **cmd );
    49 void ipc_to_master_str( char *format, ... );
     49void ipc_to_master_str( char *format, ... ) G_GNUC_PRINTF( 1, 2 );
    5050void ipc_to_children( char **cmd );
    51 void ipc_to_children_str( char *format, ... );
     51void ipc_to_children_str( char *format, ... ) G_GNUC_PRINTF( 1, 2 );
    5252
    5353/* We need this function in inetd mode, so let's just make it non-static. */
  • irc.c

    r46ad029 r601e813  
    199199}
    200200
    201 static gboolean irc_free_userhash( gpointer key, gpointer value, gpointer data )
     201static gboolean irc_free_hashkey( gpointer key, gpointer value, gpointer data )
    202202{
    203203        g_free( key );
     
    232232        irc_connection_list = g_slist_remove( irc_connection_list, irc );
    233233       
    234         for (account = irc->accounts; account; account = account->next)
    235                 if (account->gc)
     234        for (account = irc->accounts; account; account = account->next) {
     235                if (account->gc) {
     236                        account->gc->wants_to_die = TRUE;
    236237                        signoff(account->gc);
     238                } else if (account->reconnect) {
     239                        cancel_auto_reconnect(account);
     240                }
     241        }
    237242       
    238243        g_free(irc->sendbuffer);
     
    282287        }
    283288       
    284         g_hash_table_foreach_remove(irc->userhash, irc_free_userhash, NULL);
     289        g_hash_table_foreach_remove(irc->userhash, irc_free_hashkey, NULL);
    285290        g_hash_table_destroy(irc->userhash);
    286291       
    287         g_hash_table_foreach_remove(irc->watches, irc_free_userhash, NULL);
     292        g_hash_table_foreach_remove(irc->watches, irc_free_hashkey, NULL);
    288293        g_hash_table_destroy(irc->watches);
    289294       
     
    343348void irc_process( irc_t *irc )
    344349{
    345         char **lines, *temp, **cmd;
     350        char **lines, *temp, **cmd, *cs;
    346351        int i;
    347352
     
    352357                for( i = 0; *lines[i] != '\0'; i ++ )
    353358                {
     359                        char conv[IRC_MAX_LINE+1];
     360                       
     361                        /* [WvG] Because irc_tokenize splits at every newline, the lines[] list
     362                            should end with an empty string. This is why this actually works.
     363                            Took me a while to figure out, Maurits. :-P */
    354364                        if( lines[i+1] == NULL )
    355365                        {
     
    359369                                i ++;
    360370                                break;
    361                         }                       
     371                        }
     372                       
     373                        if( ( cs = set_getstr( irc, "charset" ) ) && ( g_strcasecmp( cs, "utf-8" ) != 0 ) )
     374                        {
     375                                conv[IRC_MAX_LINE] = 0;
     376                                if( do_iconv( cs, "UTF-8", lines[i], conv, 0, IRC_MAX_LINE - 2 ) != -1 )
     377                                        lines[i] = conv;
     378                        }
    362379                       
    363380                        if( ( cmd = irc_parse_line( lines[i] ) ) == NULL )
     
    385402}
    386403
     404/* Splits a long string into separate lines. The array is NULL-terminated and, unless the string
     405   contains an incomplete line at the end, ends with an empty string. */
    387406char **irc_tokenize( char *buffer )
    388407{
     
    425444}
    426445
     446/* Split an IRC-style line into little parts/arguments. */
    427447char **irc_parse_line( char *line )
    428448{
     
    484504}
    485505
     506/* Converts such an array back into a command string. Mainly used for the IPC code right now. */
    486507char *irc_build_line( char **cmd )
    487508{
     
    536557       
    537558        u = user_find( irc, irc->mynick );
    538         if( u ) is_private = u->is_private;
     559        is_private = u->is_private;
    539560       
    540561        va_start( params, format );
     
    560581{
    561582        int size;
    562         char line[IRC_MAX_LINE];
    563        
     583        char line[IRC_MAX_LINE+1], *cs;
     584               
    564585        if( irc->quit )
    565586                return;
    566 
    567         g_vsnprintf( line, IRC_MAX_LINE - 3, format, params );
    568 
     587       
     588        line[IRC_MAX_LINE] = 0;
     589        g_vsnprintf( line, IRC_MAX_LINE - 2, format, params );
     590       
    569591        strip_newlines( line );
     592        if( ( cs = set_getstr( irc, "charset" ) ) && ( g_strcasecmp( cs, "utf-8" ) != 0 ) )
     593        {
     594                char conv[IRC_MAX_LINE+1];
     595               
     596                conv[IRC_MAX_LINE] = 0;
     597                if( do_iconv( "UTF-8", cs, line, conv, 0, IRC_MAX_LINE - 2 ) != -1 )
     598                        strcpy( line, conv );
     599        }
    570600        strcat( line, "\r\n" );
    571 
     601       
    572602        if( irc->sendbuffer != NULL ) {
    573603                size = strlen( irc->sendbuffer ) + strlen( line );
     
    800830                        irc_reply( irc, 332, "%s :BitlBee groupchat: \"%s\". Please keep in mind that root-commands won't work here. Have fun!", channel, c->title );
    801831                else
    802                         irc_reply( irc, 331, "%s :No topic for this channel" );
     832                        irc_reply( irc, 331, "%s :No topic for this channel", channel );
    803833        }
    804834}
     
    856886        if( g_hash_table_lookup( irc->watches, nick ) )
    857887        {
    858                 irc_reply( irc, 600, "%s %s %s %d :%s", u->nick, u->user, u->host, time( NULL ), "logged online" );
     888                irc_reply( irc, 600, "%s %s %s %d :%s", u->nick, u->user, u->host, (int) time( NULL ), "logged online" );
    859889        }
    860890        g_free( nick );
     
    881911        if( g_hash_table_lookup( irc->watches, nick ) )
    882912        {
    883                 irc_reply( irc, 601, "%s %s %s %d :%s", u->nick, u->user, u->host, time( NULL ), "logged offline" );
     913                irc_reply( irc, 601, "%s %s %s %d :%s", u->nick, u->user, u->host, (int) time( NULL ), "logged offline" );
    884914        }
    885915        g_free( nick );
     
    9811011        else if( c && c->gc && c->gc->prpl )
    9821012        {
    983                 return( serv_send_chat( irc, c->gc, c->id, s ) );
     1013                return( bim_chat_msg( c->gc, c->id, s ) );
    9841014        }
    9851015       
     
    9911021        user_t *u = data;
    9921022       
     1023        /* Shouldn't happen, but just to be sure. */
     1024        if( u->sendbuf_len < 2 )
     1025                return FALSE;
     1026       
    9931027        u->sendbuf[u->sendbuf_len-2] = 0; /* Cut off the last newline */
    994         serv_send_im( u->gc->irc, u, u->sendbuf, u->sendbuf_flags );
     1028        bim_buddy_msg( u->gc, u->handle, u->sendbuf, u->sendbuf_flags );
    9951029       
    9961030        g_free( u->sendbuf );
     
    10001034        u->sendbuf_flags = 0;
    10011035       
    1002         return( FALSE );
     1036        return FALSE;
    10031037}
    10041038
     
    10131047                if( u->sendbuf_len > 0 && u->sendbuf_flags != flags)
    10141048                {
    1015                         //Flush the buffer
     1049                        /* Flush the buffer */
    10161050                        g_source_remove( u->sendbuf_timer );
    10171051                        buddy_send_handler_delayed( u );
     
    10211055                {
    10221056                        u->sendbuf_len = strlen( msg ) + 2;
    1023                         u->sendbuf = g_new (char, u->sendbuf_len );
     1057                        u->sendbuf = g_new( char, u->sendbuf_len );
    10241058                        u->sendbuf[0] = 0;
    10251059                        u->sendbuf_flags = flags;
     
    10281062                {
    10291063                        u->sendbuf_len += strlen( msg ) + 1;
    1030                         u->sendbuf = g_renew ( char, u->sendbuf, u->sendbuf_len );
     1064                        u->sendbuf = g_renew( char, u->sendbuf, u->sendbuf_len );
    10311065                }
    10321066               
     
    10441078        else
    10451079        {
    1046                 serv_send_im( irc, u, msg, flags );
     1080                bim_buddy_msg( u->gc, u->handle, msg, flags );
    10471081        }
    10481082}
  • irc.h

    r46ad029 r601e813  
    3333#define IRC_PING_STRING "PinglBee"
    3434
    35 #define UMODES "iasw"
     35#define UMODES "abisw"
    3636#define UMODES_PRIV "Ro"
    3737#define CMODES "nt"
     
    105105
    106106irc_t *irc_new( int fd );
    107 void irc_abort( irc_t *irc, int immed, char *format, ... );
     107void irc_abort( irc_t *irc, int immed, char *format, ... ) G_GNUC_PRINTF( 3, 4 );
    108108void irc_free( irc_t *irc );
    109109
     
    114114
    115115void irc_vawrite( irc_t *irc, char *format, va_list params );
    116 void irc_write( irc_t *irc, char *format, ... );
    117 void irc_write_all( int now, char *format, ... );
    118 void irc_reply( irc_t *irc, int code, char *format, ... );
    119 G_MODULE_EXPORT int irc_usermsg( irc_t *irc, char *format, ... );
     116void irc_write( irc_t *irc, char *format, ... ) G_GNUC_PRINTF( 2, 3 );
     117void irc_write_all( int now, char *format, ... ) G_GNUC_PRINTF( 2, 3 );
     118void irc_reply( irc_t *irc, int code, char *format, ... ) G_GNUC_PRINTF( 3, 4 );
     119G_MODULE_EXPORT int irc_usermsg( irc_t *irc, char *format, ... ) G_GNUC_PRINTF( 2, 3 );
    120120char **irc_tokenize( char *buffer );
    121121
  • irc_commands.c

    r46ad029 r601e813  
    385385                       
    386386                        if( u && u->online )
    387                                 irc_reply( irc, 604, "%s %s %s %d :%s", u->nick, u->user, u->host, time( NULL ), "is online" );
     387                                irc_reply( irc, 604, "%s %s %s %d :%s", u->nick, u->user, u->host, (int) time( NULL ), "is online" );
    388388                        else
    389                                 irc_reply( irc, 605, "%s %s %s %d :%s", nick, "*", "*", time( NULL ), "is offline" );
     389                                irc_reply( irc, 605, "%s %s %s %d :%s", nick, "*", "*", (int) time( NULL ), "is offline" );
    390390                }
    391391                else if( cmd[i][0] == '-' )
     
    448448               
    449449                if( gc && gc->flags & OPT_LOGGED_IN )
    450                         proto_away( gc, u->away );
     450                        bim_set_away( gc, u->away );
    451451        }
    452452}
     
    509509        irc->last_pong = gettime();
    510510        irc->pinging = 0;
     511}
     512
     513static void irc_cmd_version( irc_t *irc, char **cmd )
     514{
     515        irc_reply( irc, 351, "bitlbee-%s. %s :%s/%s ", BITLBEE_VERSION, irc->myhost, ARCH, CPU );
    511516}
    512517
     
    568573        { "motd",        0, irc_cmd_motd,        IRC_CMD_LOGGED_IN },
    569574        { "pong",        0, irc_cmd_pong,        IRC_CMD_LOGGED_IN },
     575        { "version",     0, irc_cmd_version,     IRC_CMD_LOGGED_IN },
    570576        { "completions", 0, irc_cmd_completions, IRC_CMD_LOGGED_IN },
    571577        { "die",         0, NULL,                IRC_CMD_OPER_ONLY | IRC_CMD_TO_MASTER },
  • log.h

    r46ad029 r601e813  
    5454void log_init(void);
    5555void log_link(int level, int output);
    56 void log_message(int level, char *message, ...);
     56void log_message(int level, char *message, ...) G_GNUC_PRINTF( 2, 3 );
    5757void log_error(char *functionname);
    5858
  • protocols/http_client.c

    r46ad029 r601e813  
    6969       
    7070        return( req );
     71}
     72
     73void *http_dorequest_url( char *url_string, http_input_function func, gpointer data )
     74{
     75        url_t *url = g_new0( url_t, 1 );
     76        char *request;
     77        void *ret;
     78       
     79        if( !url_set( url, url_string ) )
     80        {
     81                g_free( url );
     82                return NULL;
     83        }
     84       
     85        if( url->proto != PROTO_HTTP && url->proto != PROTO_HTTPS )
     86        {
     87                g_free( url );
     88                return NULL;
     89        }
     90       
     91        request = g_strdup_printf( "GET %s HTTP/1.0\r\n"
     92                                   "Host: %s\r\n"
     93                                   "User-Agent: BitlBee " BITLBEE_VERSION " " ARCH "/" CPU "\r\n"
     94                                   "\r\n", url->file, url->host );
     95       
     96        ret = http_dorequest( url->host, url->port,
     97                              url->proto == PROTO_HTTPS, request, func, data );
     98       
     99        g_free( url );
     100        g_free( request );
     101        return ret;
    71102}
    72103
     
    222253                evil_server = 1;
    223254        }
    224         else
     255        else if( end1 )
    225256        {
    226257                end1 += 2;
    227258        }
    228        
    229         if( end1 )
    230         {
    231                 *end1 = 0;
    232                
    233                 if( evil_server )
    234                         req->reply_body = end1 + 1;
    235                 else
    236                         req->reply_body = end1 + 2;
    237         }
     259        else
     260        {
     261                goto cleanup;
     262        }
     263       
     264        *end1 = 0;
     265       
     266        if( evil_server )
     267                req->reply_body = end1 + 1;
     268        else
     269                req->reply_body = end1 + 2;
     270       
     271        req->body_size = req->reply_headers + req->bytes_read - req->reply_body;
    238272       
    239273        if( ( end1 = strchr( req->reply_headers, ' ' ) ) != NULL )
  • protocols/http_client.h

    r46ad029 r601e813  
    3939        char *reply_headers;
    4040        char *reply_body;
     41        int body_size;
    4142        int finished;
    4243       
     
    5354
    5455void *http_dorequest( char *host, int port, int ssl, char *request, http_input_function func, gpointer data );
     56void *http_dorequest_url( char *url_string, http_input_function func, gpointer data );
  • protocols/jabber/jabber.c

    r46ad029 r601e813  
    10451045         */
    10461046        if(find_buddy(GJ_GC(jap->gjc), jap->user) == NULL) {
    1047                 show_got_added(GJ_GC(jap->gjc), NULL, jap->user, NULL, NULL);
     1047                show_got_added(GJ_GC(jap->gjc), jap->user, NULL);
    10481048        }
    10491049        g_free(jap->user);
     
    12321232        }
    12331233
    1234         x = jutil_presnew(0, NULL, "Online");
    1235         gjab_send(gjc, x);
    1236         xmlnode_free(x);
     1234        account_online(GJ_GC(gjc));
    12371235}
    12381236
     
    12501248                } else {
    12511249                        gjab_reqroster(gjc);
    1252                         account_online(GJ_GC(gjc));
    12531250                       
    12541251                        ((struct jabber_data *)GJ_GC(gjc)->proto_data)->did_import = TRUE;
     
    15521549        if(jd->gjc != NULL) {
    15531550                gjab_delete(jd->gjc);
     1551                /* YAY for modules with their own memory pool managers!...
    15541552                g_free(jd->gjc->sid);
     1553                And a less sarcastic yay for valgrind. :-) */
    15551554                jd->gjc = NULL;
    15561555        }
     
    18881887}
    18891888
    1890 static void jabber_set_idle(struct gaim_connection *gc, int idle) {
    1891         struct jabber_data *jd = (struct jabber_data *)gc->proto_data;
    1892         jd->idle = idle ? time(NULL) - idle : idle;
    1893 }
    1894 
    18951889static void jabber_keepalive(struct gaim_connection *gc) {
    18961890        struct jabber_data *jd = (struct jabber_data *)gc->proto_data;
    18971891        gjab_send_raw(jd->gjc, "  \t  ");
    1898 }
    1899 
    1900 static void jabber_buddy_free(struct buddy *b)
    1901 {
    1902         while (b->proto_data) {
    1903                 g_free(((GSList *)b->proto_data)->data);
    1904                 b->proto_data = g_slist_remove(b->proto_data, ((GSList *)b->proto_data)->data);
    1905         }
    19061892}
    19071893
     
    23412327}
    23422328
    2343 
    2344 static GList *jabber_actions()
    2345 {
    2346         GList *m = NULL;
    2347 
    2348         m = g_list_append(m, _("Set User Info"));
    2349         /*
    2350         m = g_list_append(m, _("Set Dir Info"));
    2351         m = g_list_append(m, _("Change Password"));
    2352          */
    2353 
    2354         return m;
    2355 }
    2356 
    2357 
    23582329void jabber_init()
    23592330{
    23602331        struct prpl *ret = g_new0(struct prpl, 1);
    23612332
    2362         /* the NULL's aren't required but they're nice to have */
    23632333        ret->name = "jabber";
    23642334        ret->away_states = jabber_away_states;
    2365         ret->actions = jabber_actions;
    23662335        ret->login = jabber_login;
    23672336        ret->close = jabber_close;
     
    23712340        ret->set_away = jabber_set_away;
    23722341        ret->get_away = jabber_get_away_msg;
    2373         ret->set_idle = jabber_set_idle;
    23742342        ret->add_buddy = jabber_add_buddy;
    23752343        ret->remove_buddy = jabber_remove_buddy;
    2376         ret->add_permit = NULL;
    2377         ret->add_deny = NULL;
    2378         ret->rem_permit = NULL;
    2379         ret->rem_deny = NULL;
    2380         ret->set_permit_deny = NULL;
    23812344        ret->keepalive = jabber_keepalive;
    2382         ret->buddy_free = jabber_buddy_free;
    23832345        ret->alias_buddy = jabber_roster_update;
    23842346        ret->group_buddy = jabber_group_change;
  • protocols/jabber/xmlparse.c

    r46ad029 r601e813  
    14611461s = protocolEncodingName;
    14621462#endif
    1463     if ((ns ? XmlInitEncodingNS : XmlInitEncoding)(&initEncoding, &encoding, s))
     1463    if (ns ? XmlInitEncodingNS(&initEncoding, &encoding, s) : XmlInitEncoding(&initEncoding, &encoding, s))
    14641464        return XML_ERROR_NONE;
    14651465    return handleUnknownEncoding(parser, protocolEncodingName);
     
    14751475    int standalone = -1;
    14761476    if (!(ns
    1477             ? XmlParseXmlDeclNS
    1478             : XmlParseXmlDecl)(isGeneralTextEntity,
     1477            ? XmlParseXmlDeclNS(isGeneralTextEntity,
    14791478                               encoding,
    14801479                               s,
     
    14841483                               &encodingName,
    14851484                               &newEncoding,
    1486                                &standalone))
     1485                               &standalone)
     1486            : XmlParseXmlDecl(isGeneralTextEntity,
     1487                               encoding,
     1488                               s,
     1489                               next,
     1490                               &eventPtr,
     1491                               &version,
     1492                               &encodingName,
     1493                               &newEncoding,
     1494                               &standalone)))
    14871495        return XML_ERROR_SYNTAX;
    14881496    if (!isGeneralTextEntity && standalone == 1)
     
    15371545            }
    15381546            enc = (ns
    1539                    ? XmlInitUnknownEncodingNS
    1540                    : XmlInitUnknownEncoding)(unknownEncodingMem,
     1547                   ? XmlInitUnknownEncodingNS(unknownEncodingMem,
    15411548                                             info.map,
    15421549                                             info.convert,
    1543                                              info.data);
     1550                                             info.data)
     1551                   : XmlInitUnknownEncoding(unknownEncodingMem,
     1552                                             info.map,
     1553                                             info.convert,
     1554                                             info.data));
    15441555            if (enc) {
    15451556                unknownEncodingData = info.data;
  • protocols/msn/msn.h

    r46ad029 r601e813  
    6666        GSList *msgq;
    6767        GSList *switchboards;
     68        const struct msn_away_state *away_state;
     69       
    6870        int buddycount;
    69         const struct msn_away_state *away_state;
     71        int groupcount;
     72        char **grouplist;
    7073};
    7174
  • protocols/msn/msn_util.c

    r46ad029 r601e813  
    4646int msn_logged_in( struct gaim_connection *gc )
    4747{
    48         struct msn_data *md = gc->proto_data;
    49         char buf[1024];
    50        
    5148        account_online( gc );
    52        
    53         /* account_online() sets an away state if there is any, so only
    54            execute this code if we're not away. */
    55         if( md->away_state == msn_away_state_list )
    56         {
    57                 g_snprintf( buf, sizeof( buf ), "CHG %d %s %d\r\n", ++md->trId, md->away_state->code, 0 );
    58                 return( msn_write( gc, buf, strlen( buf ) ) );
    59         }
    6049       
    6150        return( 0 );
     
    141130{
    142131        msn_buddy_list_add( bla->gc, "AL", bla->handle, bla->realname );
     132       
     133        if( find_buddy( bla->gc, bla->handle ) == NULL )
     134                show_got_added( bla->gc, bla->handle, NULL );
    143135       
    144136        g_free( bla->handle );
  • protocols/msn/ns.c

    r46ad029 r601e813  
    257257                {
    258258                        md->buddycount = atoi( cmd[3] );
     259                        md->groupcount = atoi( cmd[4] );
     260                        if( md->groupcount > 0 )
     261                                md->grouplist = g_new0( char *, md->groupcount );
    259262                       
    260263                        if( !*cmd[3] || md->buddycount == 0 )
     
    269272                }
    270273        }
    271         else if( strcmp( cmd[0], "GTC" ) == 0 )
    272         {
    273         }
    274         else if( strcmp( cmd[0], "BLP" ) == 0 )
    275         {
    276         }
    277         else if( strcmp( cmd[0], "PRP" ) == 0 )
    278         {
    279         }
    280         else if( strcmp( cmd[0], "LSG" ) == 0 )
    281         {
    282         }
    283274        else if( strcmp( cmd[0], "LST" ) == 0 )
    284275        {
     
    297288                if( list & 1 ) /* FL */
    298289                {
    299                         add_buddy( gc, NULL, cmd[1], cmd[2] );
     290                        char *group = NULL;
     291                        int num;
     292                       
     293                        if( cmd[4] != NULL && sscanf( cmd[4], "%d", &num ) == 1 )
     294                                group = md->grouplist[num];
     295                       
     296                        add_buddy( gc, group, cmd[1], cmd[2] );
    300297                }
    301298                if( list & 2 ) /* AL */
     
    327324                }
    328325        }
    329         else if( strcmp( cmd[0], "BPR" ) == 0 )
    330         {
    331         }
    332         else if( strcmp( cmd[0], "CHG" ) == 0 )
    333         {
     326        else if( strcmp( cmd[0], "LSG" ) == 0 )
     327        {
     328                int num;
     329               
     330                if( num_parts != 4 )
     331                {
     332                        hide_login_progress_error( gc, "Syntax error" );
     333                        signoff( gc );
     334                        return( 0 );
     335                }
     336               
     337                http_decode( cmd[2] );
     338                num = atoi( cmd[1] );
     339               
     340                if( num < md->groupcount )
     341                        md->grouplist[num] = g_strdup( cmd[2] );
    334342        }
    335343        else if( strcmp( cmd[0], "CHL" ) == 0 )
     
    357365                return( msn_write( gc, buf, strlen( buf ) ) );
    358366        }
    359         else if( strcmp( cmd[0], "QRY" ) == 0 )
    360         {
    361         }
    362         else if( strcmp( cmd[0], "QNG" ) == 0 )
    363         {
    364         }
    365367        else if( strcmp( cmd[0], "ILN" ) == 0 )
    366368        {
     
    478480                        msn_buddy_ask( gc, cmd[4], cmd[5] );
    479481                }
    480         }
    481         else if( strcmp( cmd[0], "REM" ) == 0 )
    482         {
    483482        }
    484483        else if( strcmp( cmd[0], "OUT" ) == 0 )
  • protocols/msn/sb.c

    r46ad029 r601e813  
    202202        debug( "Destroying switchboard: %s", sb->who ? sb->who : sb->key ? sb->key : "" );
    203203       
    204         if( sb->key ) g_free( sb->key );
    205         if( sb->who ) g_free( sb->who );
    206        
    207204        if( sb->msgq )
    208205        {
     
    222219                serv_got_crap( gc, "Warning: Closing down MSN switchboard connection with "
    223220                                   "unsent message to %s, you'll have to resend it.",
    224                                    m->who ? m->who : "(unknown)" );
    225         }
     221                                   sb->who ? sb->who : "(unknown)" );
     222        }
     223       
     224        if( sb->key ) g_free( sb->key );
     225        if( sb->who ) g_free( sb->who );
    226226       
    227227        if( sb->chat )
  • protocols/nogaim.c

    r46ad029 r601e813  
    1414 * (except for the function names).
    1515 *
    16  * Copyright 2002-2004 Wilmer van der Gaast <lintux@lintux.cx>
     16 * Copyright 2002-2006 Wilmer van der Gaast <wilmer@gaast.net> and others
    1717 */
    1818
     
    3737#include "nogaim.h"
    3838#include <ctype.h>
    39 #include <iconv.h>
    40 
    41 static char *proto_away_alias[7][5] =
    42 {
    43         { "Away from computer", "Away", "Extended away", NULL },
    44         { "NA", "N/A", "Not available", NULL },
    45         { "Busy", "Do not disturb", "DND", "Occupied", NULL },
    46         { "Be right back", "BRB", NULL },
    47         { "On the phone", "Phone", "On phone", NULL },
    48         { "Out to lunch", "Lunch", "Food", NULL },
    49         { NULL }
    50 };
    51 static char *proto_away_alias_find( GList *gcm, char *away );
    5239
    5340static int remove_chat_buddy_silent( struct conversation *b, char *handle );
     
    158145GSList *get_connections() { return connections; }
    159146
    160 int proto_away( struct gaim_connection *gc, char *away )
    161 {
    162         GList *m, *ms;
    163         char *s;
    164        
    165         if( !away ) away = "";
    166         ms = m = gc->prpl->away_states( gc );
    167        
    168         while( m )
    169         {
    170                 if( *away )
    171                 {
    172                         if( g_strncasecmp( m->data, away, strlen( m->data ) ) == 0 )
    173                                 break;
    174                 }
    175                 else
    176                 {
    177                         if( g_strcasecmp( m->data, "Available" ) == 0 )
    178                                 break;
    179                         if( g_strcasecmp( m->data, "Online" ) == 0 )
    180                                 break;
    181                 }
    182                 m = m->next;
    183         }
    184        
    185         if( m )
    186         {
    187                 gc->prpl->set_away( gc, m->data, *away ? away : NULL );
    188         }
    189         else
    190         {
    191                 s = proto_away_alias_find( ms, away );
    192                 if( s )
    193                 {
    194                         gc->prpl->set_away( gc, s, away );
    195                         if( set_getint( gc->irc, "debug" ) )
    196                                 serv_got_crap( gc, "Setting away state to %s", s );
    197                 }
    198                 else
    199                         gc->prpl->set_away( gc, GAIM_AWAY_CUSTOM, away );
    200         }
    201        
    202         g_list_free( ms );
    203        
    204         return( 1 );
    205 }
    206 
    207 static char *proto_away_alias_find( GList *gcm, char *away )
    208 {
    209         GList *m;
    210         int i, j;
    211        
    212         for( i = 0; *proto_away_alias[i]; i ++ )
    213         {
    214                 for( j = 0; proto_away_alias[i][j]; j ++ )
    215                         if( g_strncasecmp( away, proto_away_alias[i][j], strlen( proto_away_alias[i][j] ) ) == 0 )
    216                                 break;
    217                
    218                 if( !proto_away_alias[i][j] )   /* If we reach the end, this row */
    219                         continue;               /* is not what we want. Next!    */
    220                
    221                 /* Now find an entry in this row which exists in gcm */
    222                 for( j = 0; proto_away_alias[i][j]; j ++ )
    223                 {
    224                         m = gcm;
    225                         while( m )
    226                         {
    227                                 if( g_strcasecmp( proto_away_alias[i][j], m->data ) == 0 )
    228                                         return( proto_away_alias[i][j] );
    229                                 m = m->next;
    230                         }
    231                 }
    232         }
    233        
    234         return( NULL );
    235 }
    236 
    237147/* multi.c */
    238148
     
    305215{
    306216        va_list params;
    307         char text[1024], buf[1024], acc_id[33];
    308         char *msg;
     217        char *text;
    309218        account_t *a;
    310219       
    311220        va_start( params, format );
    312         g_vsnprintf( text, sizeof( text ), format, params );
     221        text = g_strdup_vprintf( format, params );
    313222        va_end( params );
    314223
    315         if( g_strncasecmp( set_getstr( gc->irc, "charset" ), "none", 4 ) != 0 &&
    316             do_iconv( "UTF8", set_getstr( gc->irc, "charset" ), text, buf, 0, 1024 ) != -1 )
    317                 msg = buf;
    318         else
    319                 msg = text;
    320        
    321224        if( ( g_strcasecmp( set_getstr( gc->irc, "strip_html" ), "always" ) == 0 ) ||
    322225            ( ( gc->flags & OPT_CONN_HTML ) && set_getint( gc->irc, "strip_html" ) ) )
    323                 strip_html( msg );
     226                strip_html( text );
    324227       
    325228        /* Try to find a different connection on the same protocol. */
     
    328231                        break;
    329232       
    330         /* If we found one, add the screenname to the acc_id. */
     233        /* If we found one, include the screenname in the message. */
    331234        if( a )
    332                 g_snprintf( acc_id, 32, "%s(%s)", gc->prpl->name, gc->username );
     235                irc_usermsg( gc->irc, "%s(%s) - %s", gc->prpl->name, gc->username, text );
    333236        else
    334                 g_snprintf( acc_id, 32, "%s", gc->prpl->name );
    335        
    336         irc_usermsg( gc->irc, "%s - %s", acc_id, msg );
     237                irc_usermsg( gc->irc, "%s - %s", gc->prpl->name, text );
     238       
     239        g_free( text );
    337240}
    338241
     
    352255       
    353256        /* MSN servers sometimes redirect you to a different server and do
    354            the whole login sequence again, so subsequent calls to this
     257           the whole login sequence again, so these "late" calls to this
    355258           function should be handled correctly. (IOW, ignored) */
    356259        if( gc->flags & OPT_LOGGED_IN )
     
    364267        gc->flags |= OPT_LOGGED_IN;
    365268       
    366         if( u && u->away ) proto_away( gc, u->away );
    367        
    368         if( !strcmp(gc->prpl->name, "icq") )
    369         {
    370                 for( u = gc->irc->users; u; u = u->next )
    371                         if( u->gc == gc )
    372                                 break;
    373                
    374                 if( u == NULL )
    375                         serv_got_crap( gc, "\x02""***\x02"" BitlBee now supports ICQ server-side contact lists. "
    376                                               "See \x02""help import_buddies\x02"" for more information." );
    377         }
     269        /* Also necessary when we're not away, at least for some of the
     270           protocols. */
     271        bim_set_away( gc, u->away );
    378272}
    379273
     
    392286        while( g_source_remove_by_user_data( (gpointer) a ) );
    393287        a->reconnect = 0;
    394 }
    395 
    396 void account_offline( struct gaim_connection *gc )
    397 {
    398         gc->wants_to_die = TRUE;
    399         signoff( gc );
    400288}
    401289
     
    470358/* list.c */
    471359
    472 int bud_list_cache_exists( struct gaim_connection *gc )
    473 {
    474         return( 0 );
    475 }
    476 
    477 void do_import( struct gaim_connection *gc, void *null )
    478 {
    479         return;
    480 }
    481 
    482360void add_buddy( struct gaim_connection *gc, char *group, char *handle, char *realname )
    483361{
     
    515393        else if( gc->user->proto_opt[0] && *gc->user->proto_opt[0] )
    516394        {
    517                 u->host = g_strdup( gc->user->proto_opt[0] );
     395                char *colon;
     396               
     397                if( ( colon = strchr( gc->user->proto_opt[0], ':' ) ) )
     398                        u->host = g_strndup( gc->user->proto_opt[0],
     399                                             colon - gc->user->proto_opt[0] );
     400                else
     401                        u->host = g_strdup( gc->user->proto_opt[0] );
     402               
    518403                u->user = g_strdup( handle );
    519404               
     
    531416        u->gc = gc;
    532417        u->handle = g_strdup( handle );
     418        if( group ) u->group = g_strdup( group );
    533419        u->send_handler = buddy_send_handler;
    534420        u->last_typing_notice = 0;
     
    554440}
    555441
    556 void do_export( struct gaim_connection *gc )
    557 {
    558         return;
    559 }
    560 
    561442void signoff_blocked( struct gaim_connection *gc )
    562443{
     
    568449{
    569450        user_t *u = user_findhandle( gc, handle );
    570         char *name, buf[1024];
    571451       
    572452        if( !u ) return;
    573453       
    574         /* Convert all UTF-8 */
    575         if( g_strncasecmp( set_getstr( gc->irc, "charset" ), "none", 4 ) != 0 &&
    576             do_iconv( "UTF-8", set_getstr( gc->irc, "charset" ), realname, buf, 0, sizeof( buf ) ) != -1 )
    577                 name = buf;
    578         else
    579                 name = realname;
    580        
    581         if( g_strcasecmp( u->realname, name ) != 0 )
     454        if( g_strcasecmp( u->realname, realname ) != 0 )
    582455        {
    583456                if( u->realname != u->nick ) g_free( u->realname );
    584457               
    585                 u->realname = g_strdup( name );
     458                u->realname = g_strdup( realname );
    586459               
    587460                if( ( gc->flags & OPT_LOGGED_IN ) && set_getint( gc->irc, "display_namechanges" ) )
     
    593466/* prpl.c */
    594467
    595 void show_got_added( struct gaim_connection *gc, char *id, char *handle, const char *realname, const char *msg )
    596 {
    597         return;
     468struct show_got_added_data
     469{
     470        struct gaim_connection *gc;
     471        char *handle;
     472};
     473
     474void show_got_added_no( gpointer w, struct show_got_added_data *data )
     475{
     476        g_free( data->handle );
     477        g_free( data );
     478}
     479
     480void show_got_added_yes( gpointer w, struct show_got_added_data *data )
     481{
     482        data->gc->prpl->add_buddy( data->gc, data->handle );
     483        add_buddy( data->gc, NULL, data->handle, data->handle );
     484       
     485        return show_got_added_no( w, data );
     486}
     487
     488void show_got_added( struct gaim_connection *gc, char *handle, const char *realname )
     489{
     490        struct show_got_added_data *data = g_new0( struct show_got_added_data, 1 );
     491        char *s;
     492       
     493        /* TODO: Make a setting for this! */
     494        if( user_findhandle( gc, handle ) != NULL )
     495                return;
     496       
     497        s = g_strdup_printf( "The user %s is not in your buddy list yet. Do you want to add him/her now?", handle );
     498       
     499        data->gc = gc;
     500        data->handle = g_strdup( handle );
     501        query_add( gc->irc, gc, s, show_got_added_yes, show_got_added_no, data );
    598502}
    599503
     
    625529                        return;
    626530                }
    627                 return;
     531                /* Why did we have this here....
     532                return; */
    628533        }
    629534       
     
    689594        irc_t *irc = gc->irc;
    690595        user_t *u;
    691         char buf[8192];
    692596       
    693597        u = user_findhandle( gc, handle );
     
    731635                strip_html( msg );
    732636
    733         if( g_strncasecmp( set_getstr( irc, "charset" ), "none", 4 ) != 0 &&
    734             do_iconv( "UTF-8", set_getstr( irc, "charset" ), msg, buf, 0, 8192 ) != -1 )
    735                 msg = buf;
    736        
    737637        while( strlen( msg ) > 425 )
    738638        {
     
    831731        struct conversation *c;
    832732        user_t *u;
    833         char buf[8192];
    834733       
    835734        /* Gaim sends own messages through this too. IRC doesn't want this, so kill them */
     
    843742            ( ( gc->flags & OPT_CONN_HTML ) && set_getint( gc->irc, "strip_html" ) ) )
    844743                strip_html( msg );
    845        
    846         if( g_strncasecmp( set_getstr( gc->irc, "charset" ), "none", 4 ) != 0 &&
    847             do_iconv( "UTF-8", set_getstr( gc->irc, "charset" ), msg, buf, 0, 8192 ) != -1 )
    848                 msg = buf;
    849744       
    850745        if( c && u )
     
    884779}
    885780
    886 void serv_finish_login( struct gaim_connection *gc )
    887 {
    888         return;
    889 }
    890 
    891781
    892782/* buddy_chat.c */
     
    970860       
    971861        return( 0 );
    972 }
    973 
    974 
    975 /* prefs.c */
    976 
    977 /* Necessary? */
    978 void build_block_list()
    979 {
    980         return;
    981 }
    982 
    983 void build_allow_list()
    984 {
    985         return;
    986862}
    987863
     
    1065941}
    1066942
    1067 int serv_send_im( irc_t *irc, user_t *u, char *msg, int flags )
    1068 {
    1069         char buf[8192];
    1070        
    1071         if( g_strncasecmp( set_getstr( irc, "charset" ), "none", 4 ) != 0 &&
    1072             do_iconv( set_getstr( irc, "charset" ), "UTF-8", msg, buf, 0, 8192 ) != -1 )
     943
     944
     945
     946/* The plan is to not allow straight calls to prpl functions anymore, but do
     947   them all from some wrappers. We'll start to define some down here: */
     948
     949int bim_buddy_msg( struct gaim_connection *gc, char *handle, char *msg, int flags )
     950{
     951        char *buf = NULL;
     952        int st;
     953       
     954        if( ( gc->flags & OPT_CONN_HTML ) && ( g_strncasecmp( msg, "<html>", 6 ) != 0 ) )
     955        {
     956                buf = escape_html( msg );
    1073957                msg = buf;
    1074 
    1075         if( ( u->gc->flags & OPT_CONN_HTML ) && ( g_strncasecmp( msg, "<html>", 6 ) != 0 ) )
    1076         {
    1077                 char *html;
    1078                
    1079                 html = escape_html( msg );
    1080                 strncpy( buf, html, 8192 );
    1081                 g_free( html );
    1082                
     958        }
     959       
     960        st = gc->prpl->send_im( gc, handle, msg, strlen( msg ), flags );
     961        g_free( buf );
     962       
     963        return st;
     964}
     965
     966int bim_chat_msg( struct gaim_connection *gc, int id, char *msg )
     967{
     968        char *buf = NULL;
     969        int st;
     970       
     971        if( ( gc->flags & OPT_CONN_HTML ) && ( g_strncasecmp( msg, "<html>", 6 ) != 0 ) )
     972        {
     973                buf = escape_html( msg );
    1083974                msg = buf;
    1084975        }
    1085976       
    1086         return( ((struct gaim_connection *)u->gc)->prpl->send_im( u->gc, u->handle, msg, strlen( msg ), flags ) );
    1087 }
    1088 
    1089 int serv_send_chat( irc_t *irc, struct gaim_connection *gc, int id, char *msg )
    1090 {
    1091         char buf[8192];
    1092        
    1093         if( g_strncasecmp( set_getstr( irc, "charset" ), "none", 4 ) != 0 &&
    1094             do_iconv( set_getstr( irc, "charset" ), "UTF-8", msg, buf, 0, 8192 ) != -1 )
    1095                 msg = buf;
    1096 
    1097         if( gc->flags & OPT_CONN_HTML) {
    1098                 char * html = escape_html(msg);
    1099                 strncpy(buf, html, 8192);
    1100                 g_free(html);
    1101         }
    1102        
    1103         return( gc->prpl->chat_send( gc, id, msg ) );
    1104 }
    1105 
    1106 /* Convert from one charset to another.
    1107    
    1108    from_cs, to_cs: Source and destination charsets
    1109    src, dst: Source and destination strings
    1110    size: Size if src. 0 == use strlen(). strlen() is not reliable for UNICODE/UTF16 strings though.
    1111    maxbuf: Maximum number of bytes to write to dst
    1112    
    1113    Returns the number of bytes written to maxbuf or -1 on an error.
    1114 */
    1115 signed int do_iconv( char *from_cs, char *to_cs, char *src, char *dst, size_t size, size_t maxbuf )
    1116 {
    1117         iconv_t cd;
    1118         size_t res;
    1119         size_t inbytesleft, outbytesleft;
    1120         char *inbuf = src;
    1121         char *outbuf = dst;
    1122        
    1123         cd = iconv_open( to_cs, from_cs );
    1124         if( cd == (iconv_t) -1 )
    1125                 return( -1 );
    1126        
    1127         inbytesleft = size ? size : strlen( src );
    1128         outbytesleft = maxbuf - 1;
    1129         res = iconv( cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft );
    1130         *outbuf = '\0';
    1131         iconv_close( cd );
    1132        
    1133         if( res == (size_t) -1 )
    1134                 return( -1 );
     977        st = gc->prpl->chat_send( gc, id, msg );
     978        g_free( buf );
     979       
     980        return st;
     981}
     982
     983static char *bim_away_alias_find( GList *gcm, char *away );
     984
     985int bim_set_away( struct gaim_connection *gc, char *away )
     986{
     987        GList *m, *ms;
     988        char *s;
     989       
     990        if( !away ) away = "";
     991        ms = m = gc->prpl->away_states( gc );
     992       
     993        while( m )
     994        {
     995                if( *away )
     996                {
     997                        if( g_strncasecmp( m->data, away, strlen( m->data ) ) == 0 )
     998                                break;
     999                }
     1000                else
     1001                {
     1002                        if( g_strcasecmp( m->data, "Available" ) == 0 )
     1003                                break;
     1004                        if( g_strcasecmp( m->data, "Online" ) == 0 )
     1005                                break;
     1006                }
     1007                m = m->next;
     1008        }
     1009       
     1010        if( m )
     1011        {
     1012                gc->prpl->set_away( gc, m->data, *away ? away : NULL );
     1013        }
    11351014        else
    1136                 return( outbuf - dst );
    1137 }
    1138 
    1139 char *set_eval_charset( irc_t *irc, set_t *set, char *value )
    1140 {
    1141         iconv_t cd;
    1142 
    1143         if ( g_strncasecmp( value, "none", 4 ) == 0 )
    1144                 return( value );
    1145 
    1146         cd = iconv_open( "UTF-8", value );
    1147         if( cd == (iconv_t) -1 )
    1148                 return( NULL );
    1149 
    1150         iconv_close( cd );
    1151         return( value );
    1152 }
     1015        {
     1016                s = bim_away_alias_find( ms, away );
     1017                if( s )
     1018                {
     1019                        gc->prpl->set_away( gc, s, away );
     1020                        if( set_getint( gc->irc, "debug" ) )
     1021                                serv_got_crap( gc, "Setting away state to %s", s );
     1022                }
     1023                else
     1024                        gc->prpl->set_away( gc, GAIM_AWAY_CUSTOM, away );
     1025        }
     1026       
     1027        g_list_free( ms );
     1028       
     1029        return( 1 );
     1030}
     1031
     1032static char *bim_away_alias_list[8][5] =
     1033{
     1034        { "Away from computer", "Away", "Extended away", NULL },
     1035        { "NA", "N/A", "Not available", NULL },
     1036        { "Busy", "Do not disturb", "DND", "Occupied", NULL },
     1037        { "Be right back", "BRB", NULL },
     1038        { "On the phone", "Phone", "On phone", NULL },
     1039        { "Out to lunch", "Lunch", "Food", NULL },
     1040        { "Invisible", "Hidden" },
     1041        { NULL }
     1042};
     1043
     1044static char *bim_away_alias_find( GList *gcm, char *away )
     1045{
     1046        GList *m;
     1047        int i, j;
     1048       
     1049        for( i = 0; *bim_away_alias_list[i]; i ++ )
     1050        {
     1051                for( j = 0; bim_away_alias_list[i][j]; j ++ )
     1052                        if( g_strncasecmp( away, bim_away_alias_list[i][j], strlen( bim_away_alias_list[i][j] ) ) == 0 )
     1053                                break;
     1054               
     1055                if( !bim_away_alias_list[i][j] )        /* If we reach the end, this row */
     1056                        continue;                       /* is not what we want. Next!    */
     1057               
     1058                /* Now find an entry in this row which exists in gcm */
     1059                for( j = 0; bim_away_alias_list[i][j]; j ++ )
     1060                {
     1061                        m = gcm;
     1062                        while( m )
     1063                        {
     1064                                if( g_strcasecmp( bim_away_alias_list[i][j], m->data ) == 0 )
     1065                                        return( bim_away_alias_list[i][j] );
     1066                                m = m->next;
     1067                        }
     1068                }
     1069        }
     1070       
     1071        return( NULL );
     1072}
     1073
     1074void bim_add_allow( struct gaim_connection *gc, char *handle )
     1075{
     1076        if( g_slist_find_custom( gc->permit, handle, (GCompareFunc) gc->prpl->cmp_buddynames ) == NULL )
     1077        {
     1078                gc->permit = g_slist_prepend( gc->permit, g_strdup( handle ) );
     1079        }
     1080       
     1081        gc->prpl->add_permit( gc, handle );
     1082}
     1083
     1084void bim_rem_allow( struct gaim_connection *gc, char *handle )
     1085{
     1086        GSList *l;
     1087       
     1088        if( ( l = g_slist_find_custom( gc->permit, handle, (GCompareFunc) gc->prpl->cmp_buddynames ) ) )
     1089        {
     1090                g_free( l->data );
     1091                gc->permit = g_slist_delete_link( gc->permit, l );
     1092        }
     1093       
     1094        gc->prpl->rem_permit( gc, handle );
     1095}
     1096
     1097void bim_add_block( struct gaim_connection *gc, char *handle )
     1098{
     1099        if( g_slist_find_custom( gc->deny, handle, (GCompareFunc) gc->prpl->cmp_buddynames ) == NULL )
     1100        {
     1101                gc->deny = g_slist_prepend( gc->deny, g_strdup( handle ) );
     1102        }
     1103       
     1104        gc->prpl->add_deny( gc, handle );
     1105}
     1106
     1107void bim_rem_block( struct gaim_connection *gc, char *handle )
     1108{
     1109        GSList *l;
     1110       
     1111        if( ( l = g_slist_find_custom( gc->deny, handle, (GCompareFunc) gc->prpl->cmp_buddynames ) ) )
     1112        {
     1113                g_free( l->data );
     1114                gc->deny = g_slist_delete_link( gc->deny, l );
     1115        }
     1116       
     1117        gc->prpl->rem_deny( gc, handle );
     1118}
  • protocols/nogaim.h

    r46ad029 r601e813  
    1515 * Copyright (C) 1998-1999, Mark Spencer <markster@marko.net>
    1616 *                          (and possibly other members of the Gaim team)
    17  * Copyright 2002-2004 Wilmer van der Gaast <lintux@lintux.cx>
     17 * Copyright 2002-2004 Wilmer van der Gaast <wilmer@gaast.net>
    1818 */
    1919
     
    5252#define BUDDY_ALIAS_MAXLEN 388   /* because MSN names can be 387 characters */
    5353
    54 #define PERMIT_ALL      1
    55 #define PERMIT_NONE     2
    56 #define PERMIT_SOME     3
    57 #define DENY_SOME       4
    58 
    5954#define WEBSITE "http://www.bitlee.org/"
    6055#define IM_FLAG_AWAY 0x0020
     
    6358#define GAIM_AWAY_CUSTOM "Custom"
    6459
    65 #define GAIM_LOGO       0
    66 #define GAIM_ERROR      1
    67 #define GAIM_WARNING    2
    68 #define GAIM_INFO       3
    69 
    7060/* ok. now the fun begins. first we create a connection structure */
    71 struct gaim_connection {
    72         /* we need to do either oscar or TOC */
    73         /* we make this as an int in case if we want to add more protocols later */
     61struct gaim_connection
     62{
    7463        struct prpl *prpl;
    7564        guint32 flags;
    7665       
     66        /* each connection then can have its own protocol-specific data */
     67        void *proto_data;
     68       
    7769        /* all connections need an input watcher */
    7870        int inpa;
     71        guint keepalive;
    7972       
    8073        /* buddy list stuff. there is still a global groups for the buddy list, but
     
    8477        int permdeny;
    8578       
    86         /* all connections need a list of chats, even if they don't have chat */
    87         GSList *buddy_chats;
    88        
    89         /* each connection then can have its own protocol-specific data */
    90         void *proto_data;
    91        
    9279        struct aim_user *user;
    9380       
     
    9582        char displayname[128];
    9683        char password[32];
    97         guint keepalive;
    98         /* stuff needed for per-connection idle times */
    99         guint idle_timer;
    100         time_t login_time;
    101         time_t lastsent;
    102         int is_idle;
    10384       
    10485        char *away;
    105         int is_auto_away;
    10686       
    10787        int evil;
     
    11090        /* BitlBee */
    11191        irc_t *irc;
    112         int lstitems;  /* added for msnP8 */
    11392       
    11493        struct conversation *conversations;
     
    183162        const char *name;
    184163
    185         /* for ICQ and Yahoo, who have off/on per-conversation options */
    186         /* char *checkbox; this should be per-connection */
    187 
    188         GList *(* away_states)(struct gaim_connection *gc);
    189         GList *(* actions)();
    190         void   (* do_action)(struct gaim_connection *, char *);
    191         /* user_opts returns a GList* of g_malloc'd struct proto_user_opts */
    192         GList *(* user_opts)();
    193         GList *(* chat_info)(struct gaim_connection *);
    194 
    195         /* all the server-related functions */
    196 
    197         /* a lot of these (like get_dir) are protocol-dependent and should be removed. ones like
    198          * set_dir (which is also protocol-dependent) can stay though because there's a dialog
    199          * (i.e. the prpl says you can set your dir info, the ui shows a dialog and needs to call
    200          * set_dir in order to set it) */
    201 
    202164        void (* login)          (struct aim_user *);
     165        void (* keepalive)      (struct gaim_connection *);
    203166        void (* close)          (struct gaim_connection *);
     167       
    204168        int  (* send_im)        (struct gaim_connection *, char *who, char *message, int len, int away);
    205         int  (* send_typing)    (struct gaim_connection *, char *who, int typing);
    206         void (* set_info)       (struct gaim_connection *, char *info);
    207         void (* get_info)       (struct gaim_connection *, char *who);
    208169        void (* set_away)       (struct gaim_connection *, char *state, char *message);
    209170        void (* get_away)       (struct gaim_connection *, char *who);
    210         void (* set_idle)       (struct gaim_connection *, int idletime);
     171        int  (* send_typing)    (struct gaim_connection *, char *who, int typing);
     172       
    211173        void (* add_buddy)      (struct gaim_connection *, char *name);
     174        void (* group_buddy)    (struct gaim_connection *, char *who, char *old_group, char *new_group);
    212175        void (* remove_buddy)   (struct gaim_connection *, char *name, char *group);
    213176        void (* add_permit)     (struct gaim_connection *, char *name);
     
    216179        void (* rem_deny)       (struct gaim_connection *, char *name);
    217180        void (* set_permit_deny)(struct gaim_connection *);
     181       
     182        void (* set_info)       (struct gaim_connection *, char *info);
     183        void (* get_info)       (struct gaim_connection *, char *who);
     184        void (* alias_buddy)    (struct gaim_connection *, char *who);  /* save/store buddy's alias on server list/roster */
     185       
     186        /* Group chat stuff. */
    218187        void (* join_chat)      (struct gaim_connection *, GList *data);
    219188        void (* chat_invite)    (struct gaim_connection *, int id, char *who, char *message);
    220189        void (* chat_leave)     (struct gaim_connection *, int id);
    221         void (* chat_whisper)   (struct gaim_connection *, int id, char *who, char *message);
    222190        int  (* chat_send)      (struct gaim_connection *, int id, char *message);
    223191        int  (* chat_open)      (struct gaim_connection *, char *who);
    224         void (* keepalive)      (struct gaim_connection *);
    225 
    226         /* get "chat buddy" info and away message */
    227         void (* get_cb_info)    (struct gaim_connection *, int, char *who);
    228         void (* get_cb_away)    (struct gaim_connection *, int, char *who);
    229 
    230         /* save/store buddy's alias on server list/roster */
    231         void (* alias_buddy)    (struct gaim_connection *, char *who);
    232 
    233         /* change a buddy's group on a server list/roster */
    234         void (* group_buddy)    (struct gaim_connection *, char *who, char *old_group, char *new_group);
    235 
    236         /* file transfers */
    237         struct ft_send_req *(* req_send_file) (struct gaim_connection *, const char *file);
    238         void (* send_file_part) (struct gaim_connection *, struct ft*, void *data, size_t length);
    239         void (* accept_recv_file) (struct gaim_connection *, struct ft*, ft_recv_handler);
    240 
    241         void (* buddy_free)     (struct buddy *);
    242 
     192       
     193        /* DIE! */
    243194        char *(* get_status_string) (struct gaim_connection *gc, int stat);
    244 
     195       
     196        GList *(* away_states)(struct gaim_connection *gc);
     197       
     198        /* Mainly for AOL, since they think "Bung hole" == "Bu ngho le". *sigh* */
    245199        int (* cmp_buddynames) (const char *who1, const char *who2);
    246200};
     
    259213
    260214/* nogaim.c */
    261 int serv_send_im(irc_t *irc, user_t *u, char *msg, int flags);
    262 int serv_send_chat(irc_t *irc, struct gaim_connection *gc, int id, char *msg );
    263 
    264 G_MODULE_EXPORT signed int do_iconv( char *from_cs, char *to_cs, char *src, char *dst, size_t size, size_t maxbuf );
    265 char *set_eval_charset( irc_t *irc, set_t *set, char *value );
     215int bim_set_away( struct gaim_connection *gc, char *away );
     216int bim_buddy_msg( struct gaim_connection *gc, char *handle, char *msg, int flags );
     217int bim_chat_msg( struct gaim_connection *gc, int id, char *msg );
     218
     219void bim_add_allow( struct gaim_connection *gc, char *handle );
     220void bim_rem_allow( struct gaim_connection *gc, char *handle );
     221void bim_add_block( struct gaim_connection *gc, char *handle );
     222void bim_rem_block( struct gaim_connection *gc, char *handle );
    266223
    267224void nogaim_init();
    268 int proto_away( struct gaim_connection *gc, char *away );
    269225char *set_eval_away_devoice( irc_t *irc, set_t *set, char *value );
    270226
     
    278234G_MODULE_EXPORT void hide_login_progress( struct gaim_connection *gc, char *msg );
    279235G_MODULE_EXPORT void hide_login_progress_error( struct gaim_connection *gc, char *msg );
    280 G_MODULE_EXPORT void serv_got_crap( struct gaim_connection *gc, char *format, ... );
     236G_MODULE_EXPORT void serv_got_crap( struct gaim_connection *gc, char *format, ... ) G_GNUC_PRINTF( 2, 3 );
    281237G_MODULE_EXPORT void account_online( struct gaim_connection *gc );
    282 G_MODULE_EXPORT void account_offline( struct gaim_connection *gc );
    283238G_MODULE_EXPORT void signoff( struct gaim_connection *gc );
    284239
     
    288243
    289244/* list.c */
    290 G_MODULE_EXPORT int bud_list_cache_exists( struct gaim_connection *gc );
    291 G_MODULE_EXPORT void do_import( struct gaim_connection *gc, void *null );
    292245G_MODULE_EXPORT void add_buddy( struct gaim_connection *gc, char *group, char *handle, char *realname );
    293246G_MODULE_EXPORT struct buddy *find_buddy( struct gaim_connection *gc, char *handle );
    294 G_MODULE_EXPORT void do_export( struct gaim_connection *gc );
    295247G_MODULE_EXPORT void signoff_blocked( struct gaim_connection *gc );
    296248
     
    302254
    303255/* prpl.c */
    304 G_MODULE_EXPORT void show_got_added( struct gaim_connection *gc, char *id, char *handle, const char *realname, const char *msg );
     256G_MODULE_EXPORT void show_got_added( struct gaim_connection *gc, char *handle, const char *realname );
    305257
    306258/* server.c */                   
     
    313265G_MODULE_EXPORT void serv_got_chat_left( struct gaim_connection *gc, int id );
    314266
    315 /* util.c */
    316 G_MODULE_EXPORT void strip_linefeed( gchar *text );
    317 G_MODULE_EXPORT char *add_cr( char *text );
    318 G_MODULE_EXPORT char *tobase64( const char *text );
    319 G_MODULE_EXPORT char *normalize( const char *s );
    320 G_MODULE_EXPORT time_t get_time( int year, int month, int day, int hour, int min, int sec );
    321 G_MODULE_EXPORT void strip_html( char *msg );
    322 G_MODULE_EXPORT char *escape_html( const char *html );
    323 G_MODULE_EXPORT void info_string_append(GString *str, char *newline, char *name, char *value);
    324 G_MODULE_EXPORT char *ipv6_wrap( char *src );
    325 G_MODULE_EXPORT char *ipv6_unwrap( char *src );
    326 
    327 /* prefs.c */
    328 G_MODULE_EXPORT void build_block_list();
    329 G_MODULE_EXPORT void build_allow_list();
    330 
    331267struct conversation *conv_findchannel( char *channel );
    332268
    333 
    334269#endif
  • protocols/oscar/aim.h

    r46ad029 r601e813  
    728728};
    729729
    730 #define AIM_CHATFLAGS_NOREFLECT 0x0001
    731 #define AIM_CHATFLAGS_AWAY      0x0002
     730#define AIM_CHATFLAGS_NOREFLECT         0x0001
     731#define AIM_CHATFLAGS_AWAY              0x0002
     732#define AIM_CHATFLAGS_UNICODE           0x0004
     733#define AIM_CHATFLAGS_ISO_8859_1        0x0008
     734
    732735int aim_chat_send_im(aim_session_t *sess, aim_conn_t *conn, guint16 flags, const char *msg, int msglen);
    733736int aim_chat_join(aim_session_t *sess, aim_conn_t *conn, guint16 exchange, const char *roomname, guint16 instance);
  • protocols/oscar/chat.c

    r46ad029 r601e813  
    159159        if (flags & AIM_CHATFLAGS_AWAY)
    160160                aim_addtlvtochain_noval(&otl, 0x0007);
    161 
     161       
     162        /* [WvG] This wasn't there originally, but we really should send
     163                 the right charset flags, as we also do with normal
     164                 messages. Hope this will work. :-) */
     165        if (flags & AIM_CHATFLAGS_UNICODE)
     166                aimbs_put16(&fr->data, 0x0002);
     167        else if (flags & AIM_CHATFLAGS_ISO_8859_1)
     168                aimbs_put16(&fr->data, 0x0003);
     169        else
     170                aimbs_put16(&fr->data, 0x0000);
     171       
     172        aimbs_put16(&fr->data, 0x0000);
     173       
    162174        /*
    163175         * SubTLV: Type 1: Message
  • protocols/oscar/oscar.c

    r46ad029 r601e813  
    22 * gaim
    33 *
     4 * Some code copyright (C) 2002-2006, Jelmer Vernooij <jelmer@samba.org>
     5 *                                    and the BitlBee team.
    46 * Some code copyright (C) 1998-1999, Mark Spencer <markster@marko.net>
    57 * libfaim code copyright 1998, 1999 Adam Fritzler <afritz@auk.cx>
     
    356358        if (isdigit(*user->username)) {
    357359                odata->icq = TRUE;
    358                 /* this is odd but it's necessary for a proper do_import and do_export */
     360                /* This is odd but it's necessary for a proper do_import and do_export.
     361                   We don't do those anymore, but let's stick with it, just in case
     362                   it accidentally fixes something else too... */
    359363                gc->password[8] = 0;
    360364        } else {
     
    381385        if (g_strcasecmp(user->proto_opt[USEROPT_AUTH], "login.icq.com") != 0 &&
    382386            g_strcasecmp(user->proto_opt[USEROPT_AUTH], "login.oscar.aol.com") != 0) {
    383                 serv_got_crap(gc, "Warning: Unknown OSCAR server: `%s'. Please review your configuration if the connection fails.");
     387                serv_got_crap(gc, "Warning: Unknown OSCAR server: `%s'. Please review your configuration if the connection fails.",user->proto_opt[USEROPT_AUTH]);
    384388        }
    385389       
     
    11171121        aim_ssi_auth_reply(od->sess, od->conn, uin, 1, "");
    11181122        // aim_send_im_ch4(od->sess, uin, AIM_ICQMSG_AUTHGRANTED, &message);
    1119         show_got_added(data->gc, NULL, uin, NULL, NULL);
     1123        if(find_buddy(data->gc, uin) == NULL)
     1124                show_got_added(data->gc, uin, NULL);
    11201125       
    11211126        g_free(uin);
     
    11481153                reason = msg + 6;
    11491154       
    1150         dialog_msg = g_strdup_printf("The user %u wants to add you to their buddy list for the following reason:\n\n%s", uin, reason ? reason : "No reason given.");
     1155        dialog_msg = g_strdup_printf("The user %u wants to add you to their buddy list for the following reason: %s", uin, reason ? reason : "No reason given.");
    11511156        data->gc = gc;
    11521157        data->uin = uin;
     
    17371742        odata->rights.maxdenies = (guint)maxdenies;
    17381743
    1739 //      serv_finish_login(gc);
    1740 
    1741         if (bud_list_cache_exists(gc))
    1742                 do_import(gc, NULL);
    1743 
    17441744        aim_clientready(sess, fr->conn);
    17451745
     
    20602060                                                name = g_strdup(normalize(curitem->name));
    20612061                                                gc->permit = g_slist_append(gc->permit, name);
    2062                                                 build_allow_list();
    20632062                                                tmp++;
    20642063                                        }
     
    20742073                                                name = g_strdup(normalize(curitem->name));
    20752074                                                gc->deny = g_slist_append(gc->deny, name);
    2076                                                 build_block_list();
    20772075                                                tmp++;
    20782076                                        }
     
    20962094        } /* End of for loop */
    20972095
    2098         if (tmp)
    2099                 do_export(gc);
    21002096        aim_ssi_enable(sess, fr->conn);
    21012097       
     
    22822278                tm.tm_mday = (int)info->birthday;
    22832279                tm.tm_mon = (int)info->birthmonth-1;
    2284                 tm.tm_year = (int)info->birthyear-1900;
     2280                tm.tm_year = (int)info->birthyear%100;
    22852281                strftime(date, sizeof(date), "%Y-%m-%d", &tm);
    22862282                info_string_append(str, "\n", _("Birthday"), date);
     
    25062502        int ret;
    25072503        guint8 len = strlen(message);
     2504        guint16 flags;
    25082505        char *s;
    25092506       
     
    25142511                if (*s & 128)
    25152512                        break;
    2516                
     2513       
     2514        flags = AIM_CHATFLAGS_NOREFLECT;
     2515       
    25172516        /* Message contains high ASCII chars, time for some translation! */
    25182517        if (*s) {
     
    25212520                   If we can't, fall back to UTF16. */
    25222521                if ((ret = do_iconv("UTF-8", "ISO8859-1", message, s, len, BUF_LONG)) >= 0) {
     2522                        flags |= AIM_CHATFLAGS_ISO_8859_1;
    25232523                        len = ret;
    25242524                } else if ((ret = do_iconv("UTF-8", "UNICODEBIG", message, s, len, BUF_LONG)) >= 0) {
     2525                        flags |= AIM_CHATFLAGS_UNICODE;
    25252526                        len = ret;
    25262527                } else {
     
    25332534        }
    25342535               
    2535         ret = aim_chat_send_im(od->sess, ccon->conn, AIM_CHATFLAGS_NOREFLECT, s, len);
     2536        ret = aim_chat_send_im(od->sess, ccon->conn, flags, s, len);
    25362537               
    25372538        if (s != message) {     
  • protocols/oscar/oscar_util.c

    r46ad029 r601e813  
    109109
    110110        curPtr = sn;
    111         while ( (*curPtr) != (char) NULL) {
     111        while ( (*curPtr) != (char) '\0') {
    112112                if ((*curPtr) != ' ')
    113113                i++;
     
    140140        curPtr1 = sn1;
    141141        curPtr2 = sn2;
    142         while ( (*curPtr1 != (char) NULL) && (*curPtr2 != (char) NULL) ) {
     142        while ( (*curPtr1 != (char) '\0') && (*curPtr2 != (char) '\0') ) {
    143143                if ( (*curPtr1 == ' ') || (*curPtr2 == ' ') ) {
    144144                        if (*curPtr1 == ' ')
  • protocols/oscar/service.c

    r46ad029 r601e813  
    733733        int tlvlen;
    734734
    735         data = AIM_ICQ_STATE_WEBAWARE | AIM_ICQ_STATE_HIDEIP | status; /* yay for error checking ;^) */
     735        data = AIM_ICQ_STATE_HIDEIP | status; /* yay for error checking ;^) */
    736736
    737737        tlvlen = aim_addtlvtochain32(&tl, 0x0006, data);
     
    881881#endif
    882882
     883/* len can't be 0 here anyway...
    883884                } else if ((offset == 0x00001000) && (len == 0x00000000)) {
    884885
     
    887888                        aimbs_put32(&fr->data, 0xe9800998);
    888889                        aimbs_put32(&fr->data, 0xecf8427e);
    889 
     890*/
    890891                } else
    891892                        do_error_dialog(sess->aux_data, "WARNING: unknown hash request", "Gaim");
  • protocols/ssl_nss.c

    r46ad029 r601e813  
    122122        if( source == -1 )
    123123                goto ssl_connected_failure;
    124 
    125124       
    126 
    127 
     125        /* Until we find out how to handle non-blocking I/O with NSS... */
     126        sock_make_blocking( conn->fd );
     127       
    128128        conn->prfd = SSL_ImportFD(NULL, PR_ImportTCPSocket(source));
    129129        SSL_OptionSet(conn->prfd, SSL_SECURITY, PR_TRUE);
     
    181181        return( ((struct scd*)conn)->fd );
    182182}
     183
     184GaimInputCondition ssl_getdirection( void *conn )
     185{
     186        /* Just in case someone calls us, let's return the most likely case: */
     187        return GAIM_INPUT_READ;
     188}
  • protocols/ssl_openssl.c

    r46ad029 r601e813  
    55  \********************************************************************/
    66
    7 /* SSL module - OpenTLS version                                          */
     7/* SSL module - OpenSSL version                                         */
    88
    99/*
     
    4141struct scd
    4242{
    43         SslInputFunction func;
     43        ssl_input_function func;
    4444        gpointer data;
    4545        int fd;
    4646        gboolean established;
    4747       
     48        int inpa;
     49        int lasterr;            /* Necessary for SSL_get_error */
    4850        SSL *ssl;
    4951        SSL_CTX *ssl_ctx;
     
    5456
    5557
    56 void *ssl_connect( char *host, int port, SslInputFunction func, gpointer data )
     58void *ssl_connect( char *host, int port, ssl_input_function func, gpointer data )
    5759{
    5860        struct scd *conn = g_new0( struct scd, 1 );
     
    9395}
    9496
     97static void ssl_handshake( gpointer data, gint source, GaimInputCondition cond );
     98
    9599static void ssl_connected( gpointer data, gint source, GaimInputCondition cond )
    96100{
     
    98102       
    99103        if( source == -1 )
    100                 goto ssl_connected_failure;
    101        
     104                return ssl_handshake( data, -1, cond );
     105       
     106        /* Make it non-blocking at least during the handshake... */
     107        sock_make_nonblocking( conn->fd );
    102108        SSL_set_fd( conn->ssl, conn->fd );
    103109       
    104         if( SSL_connect( conn->ssl ) < 0 )
    105                 goto ssl_connected_failure;
     110        return ssl_handshake( data, source, cond );
     111}       
     112
     113static void ssl_handshake( gpointer data, gint source, GaimInputCondition cond )
     114{
     115        struct scd *conn = data;
     116        int st;
     117       
     118        if( conn->inpa != -1 )
     119        {
     120                gaim_input_remove( conn->inpa );
     121                conn->inpa = -1;
     122        }
     123       
     124        if( ( st = SSL_connect( conn->ssl ) ) < 0 )
     125        {
     126                conn->lasterr = SSL_get_error( conn->ssl, st );
     127                if( conn->lasterr != SSL_ERROR_WANT_READ && conn->lasterr != SSL_ERROR_WANT_WRITE )
     128                        goto ssl_connected_failure;
     129               
     130                conn->inpa = gaim_input_add( conn->fd, ssl_getdirection( conn ), ssl_handshake, data );
     131                return;
     132        }
    106133       
    107134        conn->established = TRUE;
     135        sock_make_blocking( conn->fd );         /* For now... */
    108136        conn->func( conn->data, conn, cond );
    109137        return;
     
    127155int ssl_read( void *conn, char *buf, int len )
    128156{
     157        int st;
     158       
    129159        if( !((struct scd*)conn)->established )
    130                 return( 0 );
    131        
    132         return( SSL_read( ((struct scd*)conn)->ssl, buf, len ) );
     160        {
     161                ssl_errno = SSL_NOHANDSHAKE;
     162                return -1;
     163        }
     164       
     165        st = SSL_read( ((struct scd*)conn)->ssl, buf, len );
     166       
     167        ssl_errno = SSL_OK;
     168        if( st <= 0 )
     169        {
     170                ((struct scd*)conn)->lasterr = SSL_get_error( ((struct scd*)conn)->ssl, st );
     171                if( ((struct scd*)conn)->lasterr == SSL_ERROR_WANT_READ || ((struct scd*)conn)->lasterr == SSL_ERROR_WANT_WRITE )
     172                        ssl_errno = SSL_AGAIN;
     173        }
     174       
     175        return st;
    133176}
    134177
    135178int ssl_write( void *conn, const char *buf, int len )
    136179{
     180        int st;
     181       
    137182        if( !((struct scd*)conn)->established )
    138                 return( 0 );
    139        
    140         return( SSL_write( ((struct scd*)conn)->ssl, buf, len ) );
     183        {
     184                ssl_errno = SSL_NOHANDSHAKE;
     185                return -1;
     186        }
     187       
     188        st = SSL_write( ((struct scd*)conn)->ssl, buf, len );
     189       
     190        ssl_errno = SSL_OK;
     191        if( st <= 0 )
     192        {
     193                ((struct scd*)conn)->lasterr = SSL_get_error( ((struct scd*)conn)->ssl, st );
     194                if( ((struct scd*)conn)->lasterr == SSL_ERROR_WANT_READ || ((struct scd*)conn)->lasterr == SSL_ERROR_WANT_WRITE )
     195                        ssl_errno = SSL_AGAIN;
     196        }
     197       
     198        return st;
    141199}
    142200
     
    144202{
    145203        struct scd *conn = conn_;
     204       
     205        if( conn->inpa != -1 )
     206                gaim_input_remove( conn->inpa );
    146207       
    147208        if( conn->established )
     
    159220        return( ((struct scd*)conn)->fd );
    160221}
     222
     223GaimInputCondition ssl_getdirection( void *conn )
     224{
     225        return( ((struct scd*)conn)->lasterr == SSL_ERROR_WANT_WRITE ? GAIM_INPUT_WRITE : GAIM_INPUT_READ );
     226}
  • protocols/yahoo/yahoo.c

    r46ad029 r601e813  
    227227                else if( g_strcasecmp( state, GAIM_AWAY_CUSTOM ) == 0 )
    228228                {
    229                         if (gc->is_idle)
    230                                 yd->current_status = YAHOO_STATUS_IDLE;
    231                         else
    232                                 yd->current_status = YAHOO_STATUS_AVAILABLE;
     229                        yd->current_status = YAHOO_STATUS_AVAILABLE;
    233230                       
    234231                        gc->away = NULL;
    235232                }
    236233        }
    237         else if( gc->is_idle )
    238                 yd->current_status = YAHOO_STATUS_IDLE;
    239234        else
    240235                yd->current_status = YAHOO_STATUS_AVAILABLE;
     
    615610        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
    616611       
    617         serv_got_update( gc, who, stat != YAHOO_STATUS_OFFLINE, 0, 0, 0,
     612        serv_got_update( gc, who, stat != YAHOO_STATUS_OFFLINE, 0, 0,
     613                         ( stat == YAHOO_STATUS_IDLE ) ? away : 0,
    618614                         ( stat != YAHOO_STATUS_AVAILABLE ) | ( stat << 1 ), 0 );
    619615}
  • query.c

    r46ad029 r601e813  
    3939        q->no = no;
    4040        q->data = data;
     41       
     42        if( strchr( irc->umode, 'b' ) != NULL )
     43        {
     44                char *s;
     45               
     46                /* At least for the machine-parseable version, get rid of
     47                   newlines to make "parsing" easier. */
     48                for( s = q->question; *s; s ++ )
     49                        if( *s == '\r' || *s == '\n' )
     50                                *s = ' ';
     51        }
    4152       
    4253        if( irc->queries )
     
    127138                disp = 1;
    128139        }
    129         //Using irc_usermsg instead of serv_got_crap because \x02A is a char too, so a SPACE is needed.
    130140        if( ans )
    131141        {
     142                serv_got_crap( q->gc, "Accepted: %s", q->question );
    132143                q->yes( NULL, q->data );
    133                 serv_got_crap( q->gc, "Accepted: %s", q->question );
    134144        }
    135145        else
    136146        {
     147                serv_got_crap( q->gc, "Rejected: %s", q->question );
    137148                q->no( NULL, q->data );
    138                 serv_got_crap( q->gc, "Rejected: %s", q->question );
    139149        }
    140150        q->data = NULL;
  • root_commands.c

    r46ad029 r601e813  
    5757                                s --;
    5858                        }
     59                        else
     60                        {
     61                                break;
     62                        }
     63                }
     64                else if( *s == '\\' && ( ( !q && s[1] ) || ( q && q == s[1] ) ) )
     65                {
     66                        char *cpy;
     67                       
     68                        for( cpy = s; *cpy; cpy ++ )
     69                                cpy[0] = cpy[1];
    5970                }
    6071                else if( *s == q )
     
    245256                int i = 0;
    246257               
     258                if( strchr( irc->umode, 'b' ) )
     259                        irc_usermsg( irc, "Account list:" );
     260               
    247261                for( a = irc->accounts; a; a = a->next )
    248262                {
     
    347361{
    348362        account_t *a;
     363        int add_for_real = 1;
     364       
     365        if( g_strcasecmp( cmd[1], "-tmp" ) == 0 )
     366        {
     367                add_for_real = 0;
     368                cmd ++;         /* So evil... :-D */
     369        }
    349370       
    350371        if( !( a = account_get( irc, cmd[1] ) ) )
     
    376397                }
    377398        }
    378         a->gc->prpl->add_buddy( a->gc, cmd[2] );
     399       
     400        /* By making this optional, you can talk to people without having to
     401           add them to your *real* (server-side) contact list. */
     402        if( add_for_real )
     403                a->gc->prpl->add_buddy( a->gc, cmd[2] );
     404               
    379405        add_buddy( a->gc, NULL, cmd[2], cmd[2] );
    380406       
     
    484510        account_t *a;
    485511       
    486         if( !cmd[2] )
     512        if( !cmd[2] && ( a = account_get( irc, cmd[1] ) ) && a->gc )
     513        {
     514                char *format;
     515                GSList *l;
     516               
     517                if( strchr( irc->umode, 'b' ) != NULL )
     518                        format = "%s\t%s";
     519                else
     520                        format = "%-32.32s  %-16.16s";
     521               
     522                irc_usermsg( irc, format, "Handle", "Nickname" );
     523                for( l = a->gc->deny; l; l = l->next )
     524                {
     525                        user_t *u = user_findhandle( a->gc, l->data );
     526                        irc_usermsg( irc, format, l->data, u ? u->nick : "(none)" );
     527                }
     528                irc_usermsg( irc, "End of list." );
     529               
     530                return;
     531        }
     532        else if( !cmd[2] )
    487533        {
    488534                user_t *u = user_find( irc, cmd[1] );
     
    512558        else
    513559        {
    514                 gc->prpl->rem_permit( gc, cmd[2] );
    515                 gc->prpl->add_deny( gc, cmd[2] );
    516                 irc_usermsg( irc, "Buddy `%s' moved from your permit- to your deny-list", cmd[2] );
     560                bim_rem_allow( gc, cmd[2] );
     561                bim_add_block( gc, cmd[2] );
     562                irc_usermsg( irc, "Buddy `%s' moved from your allow- to your block-list", cmd[2] );
    517563        }
    518564}
     
    523569        account_t *a;
    524570       
    525         if( !cmd[2] )
     571        if( !cmd[2] && ( a = account_get( irc, cmd[1] ) ) && a->gc )
     572        {
     573                char *format;
     574                GSList *l;
     575               
     576                if( strchr( irc->umode, 'b' ) != NULL )
     577                        format = "%s\t%s";
     578                else
     579                        format = "%-32.32s  %-16.16s";
     580               
     581                irc_usermsg( irc, format, "Handle", "Nickname" );
     582                for( l = a->gc->deny; l; l = l->next )
     583                {
     584                        user_t *u = user_findhandle( a->gc, l->data );
     585                        irc_usermsg( irc, format, l->data, u ? u->nick : "(none)" );
     586                }
     587                irc_usermsg( irc, "End of list." );
     588               
     589                return;
     590        }
     591        else if( !cmd[2] )
    526592        {
    527593                user_t *u = user_find( irc, cmd[1] );
     
    551617        else
    552618        {
    553                 gc->prpl->rem_deny( gc, cmd[2] );
    554                 gc->prpl->add_permit( gc, cmd[2] );
    555                
    556                 irc_usermsg( irc, "Buddy `%s' moved from your deny- to your permit-list", cmd[2] );
     619                bim_rem_block( gc, cmd[2] );
     620                bim_add_allow( gc, cmd[2] );
     621               
     622                irc_usermsg( irc, "Buddy `%s' moved from your block- to your allow-list", cmd[2] );
    557623        }
    558624}
     
    635701        int online = 0, away = 0, offline = 0;
    636702        user_t *u;
    637         char s[64];
     703        char s[256];
     704        char *format;
    638705        int n_online = 0, n_away = 0, n_offline = 0;
    639706       
     
    649716                online =  away = 1;
    650717       
    651         irc_usermsg( irc, "%-16.16s  %-40.40s  %s", "Nick", "User/Host/Network", "Status" );
    652        
    653         if( online == 1 ) for( u = irc->users; u; u = u->next ) if( u->gc && u->online && !u->away )
    654         {
    655                 g_snprintf( s, 63, "%s@%s (%s)", u->user, u->host, u->gc->user->prpl->name );
    656                 irc_usermsg( irc, "%-16.16s  %-40.40s  %s", u->nick, s, "Online" );
     718        if( strchr( irc->umode, 'b' ) != NULL )
     719                format = "%s\t%s\t%s";
     720        else
     721                format = "%-16.16s  %-40.40s  %s";
     722       
     723        irc_usermsg( irc, format, "Nick", "User/Host/Network", "Status" );
     724       
     725        for( u = irc->users; u; u = u->next ) if( u->gc && u->online && !u->away )
     726        {
     727                if( online == 1 )
     728                {
     729                        g_snprintf( s, sizeof( s ) - 1, "%s@%s (%s)", u->user, u->host, u->gc->user->prpl->name );
     730                        irc_usermsg( irc, format, u->nick, s, "Online" );
     731                }
     732               
    657733                n_online ++;
    658734        }
    659735
    660         if( away == 1 ) for( u = irc->users; u; u = u->next ) if( u->gc && u->online && u->away )
    661         {
    662                 g_snprintf( s, 63, "%s@%s (%s)", u->user, u->host, u->gc->user->prpl->name );
    663                 irc_usermsg( irc, "%-16.16s  %-40.40s  %s", u->nick, s, u->away );
     736        for( u = irc->users; u; u = u->next ) if( u->gc && u->online && u->away )
     737        {
     738                if( away == 1 )
     739                {
     740                        g_snprintf( s, sizeof( s ) - 1, "%s@%s (%s)", u->user, u->host, u->gc->user->prpl->name );
     741                        irc_usermsg( irc, format, u->nick, s, u->away );
     742                }
    664743                n_away ++;
    665744        }
    666745       
    667         if( offline == 1 ) for( u = irc->users; u; u = u->next ) if( u->gc && !u->online )
    668         {
    669                 g_snprintf( s, 63, "%s@%s (%s)", u->user, u->host, u->gc->user->prpl->name );
    670                 irc_usermsg( irc, "%-16.16s  %-40.40s  %s", u->nick, s, "Offline" );
     746        for( u = irc->users; u; u = u->next ) if( u->gc && !u->online )
     747        {
     748                if( offline == 1 )
     749                {
     750                        g_snprintf( s, sizeof( s ) - 1, "%s@%s (%s)", u->user, u->host, u->gc->user->prpl->name );
     751                        irc_usermsg( irc, format, u->nick, s, "Offline" );
     752                }
    671753                n_offline ++;
    672754        }
     
    697779        else
    698780        {
    699                 char utf8[1024];
    700                
    701781                irc_usermsg( irc, "Setting your name to `%s'", cmd[2] );
    702782               
    703                 if( g_strncasecmp( set_getstr( irc, "charset" ), "none", 4 ) != 0 &&
    704                     do_iconv( set_getstr( irc, "charset" ), "UTF-8", cmd[2], utf8, 0, 1024 ) != -1 )
    705                         a->gc->prpl->set_info( a->gc, utf8 );
    706                 else
    707                         a->gc->prpl->set_info( a->gc, cmd[2] );
     783                a->gc->prpl->set_info( a->gc, cmd[2] );
    708784        }
    709785}
  • set.c

    r46ad029 r601e813  
    150150        if( s )
    151151        {
    152                 t->next = s->next;
     152                if( t )
     153                        t->next = s->next;
     154                else
     155                        irc->set = s->next;
     156               
    153157                g_free( s->key );
    154158                if( s->value ) g_free( s->value );
  • user.c

    r46ad029 r601e813  
    168168        u->nick = g_strdup( newnick );
    169169        if( !u->user ) u->user = u->nick;
    170         if( !u->host ) u->user = u->host;
    171         if( !u->realname ) u->user = u->realname;
     170        if( !u->host ) u->host = u->nick;
     171        if( !u->realname ) u->realname = u->nick;
    172172       
    173173        /* Remove the old reference to this user from the hash and create a
  • user.h

    r46ad029 r601e813  
    3737       
    3838        char *handle;
     39        char *group;
    3940        struct gaim_connection *gc;
    4041
  • util.c

    r46ad029 r601e813  
    3939#include <glib.h>
    4040#include <time.h>
     41#include <iconv.h>
    4142
    4243void strip_linefeed(gchar *text)
     
    445446}
    446447#endif
     448
     449/* Convert from one charset to another.
     450   
     451   from_cs, to_cs: Source and destination charsets
     452   src, dst: Source and destination strings
     453   size: Size if src. 0 == use strlen(). strlen() is not reliable for UNICODE/UTF16 strings though.
     454   maxbuf: Maximum number of bytes to write to dst
     455   
     456   Returns the number of bytes written to maxbuf or -1 on an error.
     457*/
     458signed int do_iconv( char *from_cs, char *to_cs, char *src, char *dst, size_t size, size_t maxbuf )
     459{
     460        iconv_t cd;
     461        size_t res;
     462        size_t inbytesleft, outbytesleft;
     463        char *inbuf = src;
     464        char *outbuf = dst;
     465       
     466        cd = iconv_open( to_cs, from_cs );
     467        if( cd == (iconv_t) -1 )
     468                return( -1 );
     469       
     470        inbytesleft = size ? size : strlen( src );
     471        outbytesleft = maxbuf - 1;
     472        res = iconv( cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft );
     473        *outbuf = '\0';
     474        iconv_close( cd );
     475       
     476        if( res == (size_t) -1 )
     477                return( -1 );
     478        else
     479                return( outbuf - dst );
     480}
     481
     482char *set_eval_charset( irc_t *irc, set_t *set, char *value )
     483{
     484        iconv_t cd;
     485
     486        if ( g_strncasecmp( value, "none", 4 ) == 0 )
     487                return( value );
     488
     489        cd = iconv_open( "UTF-8", value );
     490        if( cd == (iconv_t) -1 )
     491                return( NULL );
     492
     493        iconv_close( cd );
     494        return( value );
     495}
  • utils/bitlbeed.c

    r46ad029 r601e813  
    66*  (without access to /etc/inetd.conf or whatever)               *
    77*                                                                *
    8 *  Copyright 2002-2004 Wilmer van der Gaast <lintux@debian.org>  *
     8*  Copyright 2002-2004 Wilmer van der Gaast <wilmer@gaast.net>   *
    99*                                                                *
    1010*  Licensed under the GNU General Public License                 *
Note: See TracChangeset for help on using the changeset viewer.