Changes in / [2af3e23:8e9e2b7]


Ignore:
Files:
2 added
30 edited

Legend:

Unmodified
Added
Removed
  • Makefile

    r2af3e23 r8e9e2b7  
    1010
    1111# Program variables
    12 objects = bitlbee.o dcc.o help.o ipc.o irc.o irc_im.o irc_channel.o irc_commands.o irc_send.o irc_user.o irc_util.o nick.o query.o root_commands.o set.o storage.o $(STORAGE_OBJS)
     12objects = bitlbee.o dcc.o help.o ipc.o irc.o irc_im.o irc_channel.o irc_commands.o irc_send.o irc_user.o irc_util.o nick.o $(OTR_BI) query.o root_commands.o set.o storage.o $(STORAGE_OBJS)
    1313headers = bitlbee.h commands.h conf.h config.h help.h ipc.h irc.h log.h nick.h query.h set.h sock.h storage.h lib/events.h lib/ftutil.h lib/http_client.h lib/ini.h lib/md5.h lib/misc.h lib/proxy.h lib/sha1.h lib/ssl_client.h lib/url.h protocols/account.h protocols/bee.h protocols/ft.h protocols/nogaim.h
    1414subdirs = lib protocols
     
    2727subdirobjs = $(foreach dir,$(subdirs),$(dir)/$(dir).o)
    2828
    29 all: $(OUTFILE)
     29all: $(OUTFILE) $(OTR_PI)
    3030        $(MAKE) -C doc
    3131
     
    3333        @echo -e '\nmake uninstall does not remove files in '$(DESTDIR)$(ETCDIR)', you can use make uninstall-etc to do that.\n'
    3434
    35 install: install-bin install-doc
     35install: install-bin install-doc install-plugins
    3636        @if ! [ -d $(DESTDIR)$(CONFIG) ]; then echo -e '\nThe configuration directory $(DESTDIR)$(CONFIG) does not exist yet, don'\''t forget to create it!'; fi
    3737        @if ! [ -e $(DESTDIR)$(ETCDIR)/bitlbee.conf ]; then echo -e '\nNo files are installed in '$(DESTDIR)$(ETCDIR)' by make install. Run make install-etc to do that.'; fi
    3838        @echo
    3939
    40 .PHONY:   install   install-bin   install-etc   install-doc \
     40.PHONY:   install   install-bin   install-etc   install-doc install-plugins \
    4141        uninstall uninstall-bin uninstall-etc uninstall-doc \
    4242        all clean distclean tar $(subdirs)
     
    104104        -rmdir $(DESTDIR)$(ETCDIR)
    105105
     106install-plugins:
     107ifdef OTR_PI
     108        mkdir -p $(DESTDIR)$(PLUGINDIR)
     109        install -m 0755 otr.so $(DESTDIR)$(PLUGINDIR)
     110endif
     111
    106112tar:
    107113        fakeroot debian/rules clean || make distclean
     
    112118$(subdirs):
    113119        @$(MAKE) -C $@ $(MAKECMDGOALS)
     120
     121$(OTR_PI): %.so: $(SRCDIR)%.c
     122        @echo '*' Building plugin $@
     123        @$(CC) $(CFLAGS) $(OTRFLAGS) -fPIC -shared $< -o $@
    114124
    115125$(objects): %.o: $(SRCDIR)%.c
  • bitlbee.h

    r2af3e23 r8e9e2b7  
    162162void root_command_string( irc_t *irc, char *command );
    163163void root_command( irc_t *irc, char *command[] );
     164gboolean root_command_add( const char *command, int params, void (*func)(irc_t *, char **args), int flags );
    164165gboolean cmd_identify_finish( gpointer data, gint fd, b_input_condition cond );
    165166gboolean bitlbee_shutdown( gpointer data, gint fd, b_input_condition cond );
  • commands.h

    r2af3e23 r8e9e2b7  
    3737} command_t;
    3838
    39 extern const command_t commands[];
     39extern command_t root_commands[];
    4040
    4141#define IRC_CMD_PRE_LOGIN       1
  • configure

    r2af3e23 r8e9e2b7  
    3434gcov=0
    3535plugins=1
     36otr=auto
    3637
    3738events=glib
     
    7778--gcov=0/1      Disable/enable test coverage reporting  $gcov
    7879--plugins=0/1   Disable/enable plugins support          $plugins
     80--otr=0/1       Disable/enable OTR encryption support   $otr
    7981
    8082--events=...    Event handler (glib, libevent)          $events
     
    489491fi
    490492
     493otrprefix=""
     494for i in / /usr /usr/local; do
     495        if [ -f ${i}/lib/libotr.a ]; then
     496                otrprefix=${i}
     497                break
     498        fi
     499done
     500if [ "$otr" = "auto" ]; then
     501        if [ -n "$otrprefix" ]; then
     502                otr=1
     503        else
     504                otr=0
     505        fi
     506fi
     507if [ "$otr" = 1 ]; then
     508        # BI == built-in
     509        echo '#define OTR_BI' >> config.h
     510        echo "EFLAGS+=-L${otrprefix}/lib -lotr" >> Makefile.settings
     511        echo "CFLAGS+=-I${otrprefix}/include" >> Makefile.settings
     512        echo 'OTR_BI=otr.o' >> Makefile.settings
     513elif [ "$otr" = "plugin" ]; then
     514        echo '#define OTR_PI' >> config.h
     515        echo "OTRFLAGS=-L${otrprefix}/lib -lotr" >> Makefile.settings
     516        echo "CFLAGS+=-I${otrprefix}/include" >> Makefile.settings
     517        echo 'OTR_PI=otr.so' >> Makefile.settings
     518fi
     519
    491520if [ ! -e doc/user-guide/help.txt ] && ! type xmlto > /dev/null 2> /dev/null; then
    492521        echo
     
    683712fi
    684713
     714if [ "$otr" = "1" ]; then
     715        echo '  Off-the-Record (OTR) Messaging enabled.'
     716elif [ "$otr" = "plugin" ]; then
     717        echo '  Off-the-Record (OTR) Messaging enabled (as a plugin).'
     718else
     719        echo '  Off-the-Record (OTR) Messaging disabled.'
     720fi
     721
    685722echo '  Using event handler: '$events
    686723echo '  Using SSL library: '$ssl
  • doc/README

    r2af3e23 r8e9e2b7  
    6666BitlBee's only real dependency is GLib. This is available on virtually every
    6767platform. Any recent version of GLib (2.4 or higher) will work.
     68
     69Off-the-Record encryption support will be included by default if the
     70configure script finds libotr in one of the usual places. You can pass
     71--otr=1 or --otr=0 to force it on or off, respectively.
    6872
    6973These days, many IM protocols use SSL/TLS connections (for authentication
     
    145149
    146150
    147 A NOTE ON ENCRYPTION
    148 ====================
     151A NOTE ON PASSWORD ENCRYPTION
     152=============================
    149153
    150154There used to be a note here about the simple obfuscation method used to
  • doc/user-guide/commands.xml

    r2af3e23 r8e9e2b7  
    367367                </description>
    368368        </bitlbee-command>
     369       
     370        <bitlbee-command name="otr">
     371                <short-description>Off-the-Record encryption control</short-description>
     372                <syntax>otr &lt;subcommand&gt; [&lt;arguments&gt;]</syntax>
     373
     374                <description>
     375
     376                        <para>
     377                                Available subcommands: connect, disconnect, smp, smpq, trust, info, keygen, and forget. See <emphasis>help otr &lt;subcommand&gt;</emphasis> for more information.
     378                        </para>
     379
     380                </description>
     381               
     382                <bitlbee-command name="connect">
     383                        <syntax>otr connect &lt;nick&gt;</syntax>
     384                       
     385                        <description>
     386                       
     387                                <para>
     388                                        Attempts to establish an encrypted connection with the specified user by sending a magic string.
     389                                </para>
     390                               
     391                        </description>
     392               
     393                </bitlbee-command>
     394               
     395                <bitlbee-command name="disconnect">
     396                        <syntax>otr disconnect &lt;nick&gt;</syntax>
     397                       
     398                        <description>
     399                       
     400                                <para>
     401                                        Resets the connection with the specified user to cleartext.
     402                                </para>
     403                               
     404                        </description>
     405               
     406                </bitlbee-command>
     407               
     408                <bitlbee-command name="smp">
     409                        <syntax>otr smp &lt;nick&gt; &lt;secret&gt;</syntax>
     410                       
     411                        <description>
     412                       
     413                                <para>
     414                                        Attempts to authenticate the given user's active fingerprint via the Socialist Millionaires' Protocol.
     415                                </para>
     416                               
     417                                <para>
     418                                        If an SMP challenge has already been received from the given user, responds with the specified secret. Otherwise, a challenge for the secret will be sent. If the protocol succeeds (i.e. both parties gave the same secret), the fingerprint will be trusted.
     419                                </para>
     420                               
     421                        </description>
     422               
     423                </bitlbee-command>
     424               
     425                <bitlbee-command name="smpq">
     426                        <syntax>otr smpq &lt;nick&gt; &lt;question&gt; &lt;answer&gt;</syntax>
     427                       
     428                        <description>
     429                       
     430                                <para>
     431                                        Attempts to authenticate the given user's active fingerprint via the Socialist Millionaires' Protocol, Q&amp;A style.
     432                                </para>
     433
     434                                <para>
     435                                        When initiating SMP, this is an alternative to the 'otr smp' command. The shared secret is provided as the answer to a specific question. The question is transmitted with the initial SMP packet and used to prompt the other party. If the protocol succeeds (i.e. they give the correct answer), the fingerprint will be trusted.
     436                                </para>
     437                               
     438                        </description>
     439               
     440                </bitlbee-command>
     441               
     442                <bitlbee-command name="trust">
     443                        <syntax>otr trust &lt;nick&gt; &lt;fp1&gt; &lt;fp2&gt; &lt;fp3&gt; &lt;fp4&gt; &lt;fp5&gt;</syntax>
     444                       
     445                        <description>
     446                       
     447                                <para>
     448                                        Manually affirms trust in the specified fingerprint, given as five blocks of precisely eight (hexadecimal) digits each.
     449                                </para>
     450                               
     451                        </description>
     452               
     453                </bitlbee-command>
     454               
     455                <bitlbee-command name="info">
     456                        <syntax>otr info</syntax>
     457                        <syntax>otr info &lt;nick&gt;</syntax>
     458                       
     459                        <description>
     460                       
     461                                <para>
     462                                        Shows information about the OTR state. The first form lists our private keys and current OTR contexts. The second form displays information about the connection with a given user, including the list of their known fingerprints.
     463                                </para>
     464                               
     465                        </description>
     466               
     467                </bitlbee-command>
     468               
     469                <bitlbee-command name="keygen">
     470                        <syntax>otr keygen &lt;account-no&gt;</syntax>
     471                       
     472                        <description>
     473                       
     474                                <para>
     475                                        Generates a new OTR private key for the given account.
     476                                </para>
     477                               
     478                        </description>
     479               
     480                </bitlbee-command>
     481               
     482                <bitlbee-command name="forget">
     483                        <syntax>otr forget &lt;thing&gt; &lt;arguments&gt;</syntax>
     484                       
     485                        <description>
     486                       
     487                                <para>
     488                                        Forgets some part of our OTR userstate. Available things: fingerprint, context, and key. See <emphasis>help otr forget &lt;thing&gt;</emphasis> for more information.
     489                                </para>
     490                       
     491                        </description>
     492                       
     493                        <bitlbee-command name="fingerprint">
     494                                <syntax>otr forget fingerprint &lt;nick&gt; &lt;fingerprint&gt;</syntax>
     495                               
     496                                <description>
     497                               
     498                                        <para>
     499                                                Drops the specified fingerprint from the given user's OTR connection context. It is allowed to specify only a (unique) prefix of the desired fingerprint.
     500                                        </para>
     501                                       
     502                                </description>
     503                               
     504                        </bitlbee-command>
     505                               
     506                        <bitlbee-command name="context">
     507                                <syntax>otr forget context &lt;nick&gt;</syntax>
     508                               
     509                                <description>
     510                               
     511                                        <para>
     512                                                Forgets the entire OTR context associated with the given user. This includes current message and protocol states, as well as any fingerprints for that user.
     513                                        </para>
     514                                       
     515                                </description>
     516                               
     517                        </bitlbee-command>
     518
     519                        <bitlbee-command name="key">
     520                                <syntax>otr forget key &lt;fingerprint&gt;</syntax>
     521                               
     522                                <description>
     523                               
     524                                        <para>
     525                                                Forgets an OTR private key matching the specified fingerprint. It is allowed to specify only a (unique) prefix of the fingerprint.
     526                                        </para>
     527                                       
     528                                </description>
     529                               
     530                        </bitlbee-command>
     531               
     532                </bitlbee-command>
     533               
     534        </bitlbee-command>
    369535
    370536        <bitlbee-command name="set">
     
    589755                </description>
    590756
     757        </bitlbee-setting>
     758
     759        <bitlbee-setting name="color_encrypted" type="boolean" scope="global">
     760                <default>true</default>
     761
     762                <description>
     763                        <para>
     764                                If set to true, BitlBee will color incoming encrypted messages according to their fingerprint trust level: untrusted=red, trusted=green.
     765                        </para>
     766                </description>
    591767        </bitlbee-setting>
    592768
     
    9311107        </bitlbee-setting>
    9321108
     1109        <bitlbee-setting name="otr_policy" type="string" scope="global">
     1110                <default>opportunistic</default>
     1111                <possible-values>never, opportunistic, manual, always</possible-values>
     1112
     1113                <description>
     1114                        <para>
     1115                                This setting controls the policy for establishing Off-the-Record connections.
     1116                        </para>
     1117                        <para>
     1118                                A value of "never" effectively disables the OTR subsystem. In "opportunistic" mode, a magic whitespace pattern will be appended to the first message sent to any user. If the peer is also running opportunistic OTR, an encrypted connection will be set up automatically. On "manual", on the other hand, OTR connections must be established explicitly using <emphasis>otr connect</emphasis>. Finally, the setting "always" enforces encrypted communication by causing BitlBee to refuse to send any cleartext messages at all.
     1119                        </para>
     1120                </description>
     1121        </bitlbee-setting>
     1122
    9331123        <bitlbee-setting name="password" type="string" scope="both">
    9341124                <description>
  • irc.c

    r2af3e23 r8e9e2b7  
    2929
    3030GSList *irc_connection_list;
     31GSList *irc_plugins;
    3132
    3233static gboolean irc_userping( gpointer _irc, gint fd, b_input_condition cond );
     
    4243        char *host = NULL, *myhost = NULL;
    4344        irc_user_t *iu;
     45        GSList *l;
    4446        set_t *s;
    4547        bee_t *b;
     
    165167        nogaim_init();
    166168       
     169        for( l = irc_plugins; l; l = l->next )
     170        {
     171                irc_plugin_t *p = l->data;
     172                if( p->irc_new )
     173                        p->irc_new( irc );
     174        }
     175       
    167176        return irc;
    168177}
     
    208217void irc_free( irc_t * irc )
    209218{
     219        GSList *l;
     220       
    210221        irc->status |= USTATUS_SHUTDOWN;
    211222       
     
    215226                if( storage_save( irc, NULL, TRUE ) != STORAGE_OK )
    216227                        log_message( LOGLVL_WARNING, "Error while saving settings for user %s", irc->user->nick );
     228       
     229        for( l = irc_plugins; l; l = l->next )
     230        {
     231                irc_plugin_t *p = l->data;
     232                if( p->irc_free )
     233                        p->irc_free( irc );
     234        }
    217235       
    218236        irc_connection_list = g_slist_remove( irc_connection_list, irc );
     
    933951        return SET_INVALID;
    934952}
     953
     954void register_irc_plugin( const struct irc_plugin *p )
     955{
     956        irc_plugins = g_slist_prepend( irc_plugins, (gpointer) p );
     957}
  • irc.h

    r2af3e23 r8e9e2b7  
    2828
    2929#define IRC_MAX_LINE 512
    30 #define IRC_MAX_ARGS 8
     30#define IRC_MAX_ARGS 16
    3131
    3232#define IRC_LOGIN_TIMEOUT 60
     
    8686        gint login_source_id; /* To slightly delay some events at login time. */
    8787       
     88        struct otr *otr; /* OTR state and book keeping, used by the OTR plugin.
     89                            TODO: Some mechanism for plugindata. */
     90       
    8891        struct bee *b;
    8992} irc_t;
     
    9396        /* Replaced with iu->last_channel IRC_USER_PRIVATE = 1, */
    9497        IRC_USER_AWAY = 2,
     98       
     99        IRC_USER_OTR_ENCRYPTED = 0x10000,
     100        IRC_USER_OTR_TRUSTED   = 0x20000,
    95101} irc_user_flags_t;
    96102
     
    214220} irc_channel_del_user_type_t;
    215221
     222/* These are a glued a little bit to the core/bee layer and a little bit to
     223   IRC. The first user is OTR, and I guess at some point we'll get to shape
     224   this a little bit more as other uses come up. */
     225typedef struct irc_plugin
     226{
     227        /* Called at the end of irc_new(). Can be used to add settings, etc. */
     228        gboolean (*irc_new)( irc_t *irc );
     229        /* At the end of irc_free(). */
     230        void (*irc_free)( irc_t *irc );
     231       
     232        /* Problem with the following two functions is ordering if multiple
     233           plugins are handling them. Let's keep fixing that problem for
     234           whenever it becomes important. */
     235       
     236        /* Called by bee_irc_user_privmsg_cb(). Return NULL if you want to
     237           abort sending the msg. */
     238        char* (*filter_msg_out)( irc_user_t *iu, char *msg, int flags );
     239        /* Called by bee_irc_user_msg(). Return NULL if you swallowed the
     240           message and don't want anything to go to the user. */
     241        char* (*filter_msg_in)( irc_user_t *iu, char *msg, int flags );
     242       
     243        /* From storage.c functions. Ideally these should not be used
     244           and instead data should be stored in settings which will get
     245           saved automatically. Consider these deprecated! */
     246        void (*storage_load)( irc_t *irc );
     247        void (*storage_save)( irc_t *irc );
     248        void (*storage_remove)( const char *nick );
     249} irc_plugin_t;
     250
     251extern GSList *irc_plugins; /* struct irc_plugin */
     252
    216253/* irc.c */
    217254extern GSList *irc_connection_list;
     
    238275
    239276void irc_umode_set( irc_t *irc, const char *s, gboolean allow_priv );
     277
     278void register_irc_plugin( const struct irc_plugin *p );
    240279
    241280/* irc_channel.c */
  • irc_commands.c

    r2af3e23 r8e9e2b7  
    635635        irc_send_msg_raw( irc->root, "NOTICE", irc->user->nick, "COMPLETIONS OK" );
    636636       
    637         for( i = 0; commands[i].command; i ++ )
    638                 irc_send_msg_f( irc->root, "NOTICE", irc->user->nick, "COMPLETIONS %s", commands[i].command );
     637        for( i = 0; root_commands[i].command; i ++ )
     638                irc_send_msg_f( irc->root, "NOTICE", irc->user->nick, "COMPLETIONS %s", root_commands[i].command );
    639639       
    640640        for( h = global.help; h; h = h->next )
  • irc_im.c

    r2af3e23 r8e9e2b7  
    192192}
    193193
    194 static gboolean bee_irc_user_msg( bee_t *bee, bee_user_t *bu, const char *msg, time_t sent_at )
     194static gboolean bee_irc_user_msg( bee_t *bee, bee_user_t *bu, const char *msg_, time_t sent_at )
    195195{
    196196        irc_t *irc = bee->ui_data;
     
    199199        char *wrapped, *ts = NULL;
    200200        irc_channel_t *ic = NULL;
     201        char *msg = g_strdup( msg_ );
     202        GSList *l;
    201203       
    202204        if( sent_at > 0 && set_getbool( &irc->b->set, "display_timestamps" ) )
     
    224226        }
    225227       
     228        for( l = irc_plugins; l; l = l->next )
     229        {
     230                irc_plugin_t *p = l->data;
     231                if( p->filter_msg_in )
     232                {
     233                        char *s = p->filter_msg_in( iu, msg, 0 );
     234                        if( s )
     235                        {
     236                                if( s != msg )
     237                                        g_free( msg );
     238                                msg = s;
     239                        }
     240                        else
     241                        {
     242                                /* Modules can swallow messages. */
     243                                return TRUE;
     244                        }
     245                }
     246        }
     247       
     248        if( ( g_strcasecmp( set_getstr( &bee->set, "strip_html" ), "always" ) == 0 ) ||
     249            ( ( bu->ic->flags & OPT_DOES_HTML ) && set_getbool( &bee->set, "strip_html" ) ) )
     250        {
     251                char *s = g_strdup( msg );
     252                strip_html( s );
     253                g_free( msg );
     254                msg = s;
     255        }
     256       
    226257        wrapped = word_wrap( msg, 425 );
    227258        irc_send_msg( iu, "PRIVMSG", dst, wrapped, prefix );
     
    229260        g_free( wrapped );
    230261        g_free( prefix );
     262        g_free( msg );
    231263        g_free( ts );
    232264       
     
    349381        }
    350382       
     383        if( iu->pastebuf == NULL )
     384                iu->pastebuf = g_string_new( msg );
     385        else
     386        {
     387                b_event_remove( iu->pastebuf_timer );
     388                g_string_append_printf( iu->pastebuf, "\n%s", msg );
     389        }
     390       
    351391        if( set_getbool( &iu->irc->b->set, "paste_buffer" ) )
    352392        {
    353393                int delay;
    354                
    355                 if( iu->pastebuf == NULL )
    356                         iu->pastebuf = g_string_new( msg );
    357                 else
    358                 {
    359                         b_event_remove( iu->pastebuf_timer );
    360                         g_string_append_printf( iu->pastebuf, "\n%s", msg );
    361                 }
    362394               
    363395                if( ( delay = set_getint( &iu->irc->b->set, "paste_buffer_delay" ) ) <= 5 )
     
    369401        }
    370402        else
    371                 return bee_user_msg( iu->irc->b, iu->bu, msg, 0 );
     403        {
     404                bee_irc_user_privmsg_cb( iu, 0, 0 );
     405               
     406                return TRUE;
     407        }
    372408}
    373409
     
    375411{
    376412        irc_user_t *iu = data;
    377        
    378         bee_user_msg( iu->irc->b, iu->bu, iu->pastebuf->str, 0 );
    379        
    380         g_string_free( iu->pastebuf, TRUE );
    381         iu->pastebuf = 0;
     413        char *msg = g_string_free( iu->pastebuf, FALSE );
     414        GSList *l;
     415       
     416        for( l = irc_plugins; l; l = l->next )
     417        {
     418                irc_plugin_t *p = l->data;
     419                if( p->filter_msg_out )
     420                {
     421                        char *s = p->filter_msg_out( iu, msg, 0 );
     422                        if( s )
     423                        {
     424                                if( s != msg )
     425                                        g_free( msg );
     426                                msg = s;
     427                        }
     428                        else
     429                        {
     430                                /* Modules can swallow messages. */
     431                                iu->pastebuf = NULL;
     432                                g_free( msg );
     433                                return FALSE;
     434                        }
     435                }
     436        }
     437       
     438        bee_user_msg( iu->irc->b, iu->bu, msg, 0 );
     439       
     440        g_free( msg );
     441        iu->pastebuf = NULL;
    382442        iu->pastebuf_timer = 0;
    383443       
  • lib/misc.c

    r2af3e23 r8e9e2b7  
    157157        char *s = out, *cs;
    158158        int i, matched;
     159        int taglen;
    159160       
    160161        memset( out, 0, sizeof( out ) );
     
    173174                                in ++;
    174175                       
     176                        taglen = in - cs - 1;   /* not <0 because the above loop runs at least once */
    175177                        if( *in )
    176178                        {
    177                                 if( g_strncasecmp( cs+1, "br", 2) == 0 )
     179                                if( g_strncasecmp( cs+1, "b", taglen) == 0 )
     180                                        *(s++) = '\x02';
     181                                else if( g_strncasecmp( cs+1, "/b", taglen) == 0 )
     182                                        *(s++) = '\x02';
     183                                else if( g_strncasecmp( cs+1, "i", taglen) == 0 )
     184                                        *(s++) = '\x1f';
     185                                else if( g_strncasecmp( cs+1, "/i", taglen) == 0 )
     186                                        *(s++) = '\x1f';
     187                                else if( g_strncasecmp( cs+1, "br", taglen) == 0 )
    178188                                        *(s++) = '\n';
    179189                                in ++;
  • lib/ssl_bogus.c

    r2af3e23 r8e9e2b7  
    2727
    2828int ssl_errno;
     29
     30void ssl_init( void )
     31{
     32}
    2933
    3034void *ssl_connect( char *host, int port, ssl_input_function func, gpointer data )
     
    6670        return 0;
    6771}
     72
     73int ssl_pending( void *conn )
     74{
     75        return 0;
     76}
  • lib/ssl_client.h

    r2af3e23 r8e9e2b7  
    4747
    4848
     49/* Perform any global initialization the SSL library might need. */
     50G_MODULE_EXPORT void ssl_init( void );
     51
    4952/* Connect to host:port, call the given function when the connection is
    5053   ready to be used for SSL traffic. This is all done asynchronously, no
  • lib/ssl_gnutls.c

    r2af3e23 r8e9e2b7  
    6060static gboolean ssl_handshake( gpointer data, gint source, b_input_condition cond );
    6161
     62
     63void ssl_init( void )
     64{
     65        gnutls_global_init();
     66        initialized = TRUE;
     67        atexit( gnutls_global_deinit );
     68}
    6269
    6370void *ssl_connect( char *host, int port, ssl_input_function func, gpointer data )
     
    122129        if( !initialized )
    123130        {
    124                 gnutls_global_init();
    125                 initialized = TRUE;
    126                 atexit( gnutls_global_deinit );
     131                ssl_init();
    127132        }
    128133       
  • lib/ssl_nss.c

    r2af3e23 r8e9e2b7  
    9191
    9292
     93void ssl_init( void )
     94{
     95        PR_Init( PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 1);
     96        NSS_NoDB_Init(NULL);
     97        NSS_SetDomesticPolicy();
     98        initialized = TRUE;
     99}
     100
    93101void *ssl_connect( char *host, int port, ssl_input_function func, gpointer data )
    94102{
     
    107115        if( !initialized )
    108116        {
    109                 PR_Init( PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 1);
    110                 NSS_NoDB_Init(NULL);
    111                 NSS_SetDomesticPolicy();
     117                ssl_init();
    112118        }
    113119
  • lib/ssl_openssl.c

    r2af3e23 r8e9e2b7  
    5656static gboolean ssl_handshake( gpointer data, gint source, b_input_condition cond );
    5757
     58
     59void ssl_init( void )
     60{
     61        initialized = TRUE;
     62        SSL_library_init();
     63        // SSLeay_add_ssl_algorithms();
     64}
    5865
    5966void *ssl_connect( char *host, int port, ssl_input_function func, gpointer data )
     
    115122        if( !initialized )
    116123        {
    117                 initialized = TRUE;
    118                 SSL_library_init();
    119                 //SSLeay_add_ssl_algorithms();
    120                 //OpenSSL_add_all_algorithms();
     124                ssl_init();
    121125        }
    122126       
  • log.c

    r2af3e23 r8e9e2b7  
    3030static log_t logoutput;
    3131
    32 static void log_null(int level, char *logmessage);
    33 static void log_irc(int level, char *logmessage);
    34 static void log_syslog(int level, char *logmessage);
    35 static void log_console(int level, char *logmessage);
     32static void log_null(int level, const char *logmessage);
     33static void log_irc(int level, const char *logmessage);
     34static void log_syslog(int level, const char *logmessage);
     35static void log_console(int level, const char *logmessage);
    3636
    3737void log_init(void) {
     
    9797}
    9898
    99 void log_message(int level, char *message, ... ) {
     99void log_message(int level, const char *message, ... ) {
    100100
    101101        va_list ap;
     
    122122}
    123123
    124 void log_error(char *functionname) {
     124void log_error(const char *functionname) {
    125125        log_message(LOGLVL_ERROR, "%s: %s", functionname, strerror(errno));
    126126       
     
    128128}
    129129
    130 static void log_null(int level, char *message) {
     130static void log_null(int level, const char *message) {
    131131        return;
    132132}
    133133
    134 static void log_irc(int level, char *message) {
     134static void log_irc(int level, const char *message) {
    135135        if(level == LOGLVL_ERROR)
    136136                irc_write_all(1, "ERROR :Error: %s", message);
     
    147147}
    148148
    149 static void log_syslog(int level, char *message) {
     149static void log_syslog(int level, const char *message) {
    150150        if(level == LOGLVL_ERROR)
    151151                syslog(LOG_ERR, "%s", message);
     
    161161}
    162162
    163 static void log_console(int level, char *message) {
     163static void log_console(int level, const char *message) {
    164164        if(level == LOGLVL_ERROR)
    165165                fprintf(stderr, "Error: %s\n", message);
  • log.h

    r2af3e23 r8e9e2b7  
    4444
    4545typedef struct log_t {
    46         void (*error)(int level, char *logmessage);
    47         void (*warning)(int level, char *logmessage);
    48         void (*informational)(int level, char *logmessage);
     46        void (*error)(int level, const char *logmessage);
     47        void (*warning)(int level, const char *logmessage);
     48        void (*informational)(int level, const char *logmessage);
    4949#ifdef DEBUG
    50         void (*debug)(int level, char *logmessage);
     50        void (*debug)(int level, const char *logmessage);
    5151#endif
    5252} log_t;
     
    5454void log_init(void);
    5555void log_link(int level, int output);
    56 void log_message(int level, char *message, ...) G_GNUC_PRINTF( 2, 3 );
    57 void log_error(char *functionname);
     56void log_message(int level, const char *message, ...) G_GNUC_PRINTF( 2, 3 );
     57void log_error(const char *functionname);
    5858
    5959#endif
  • nick.c

    r2af3e23 r8e9e2b7  
    196196                   LC_CTYPE being set to something other than C/POSIX. */
    197197                if( part )
    198                         part = asc = g_convert( part, -1, "ASCII//TRANSLIT//IGNORE",
    199                                                 "UTF-8", NULL, NULL, NULL );
     198                        part = asc = g_convert_with_fallback( part, -1, "ASCII//TRANSLIT",
     199                                                              "UTF-8", "", NULL, NULL, NULL );
    200200               
    201201                if( ret->len == 0 && part && isdigit( *part ) )
  • protocols/bee_user.c

    r2af3e23 r8e9e2b7  
    265265        }
    266266       
    267         if( ( g_strcasecmp( set_getstr( &ic->bee->set, "strip_html" ), "always" ) == 0 ) ||
    268             ( ( ic->flags & OPT_DOES_HTML ) && set_getbool( &ic->bee->set, "strip_html" ) ) )
    269                 strip_html( msg );
    270        
    271267        if( bee->ui->user_msg && bu )
    272268                bee->ui->user_msg( bee, bu, msg, sent_at );
  • protocols/jabber/jabber.c

    r2af3e23 r8e9e2b7  
    557557       
    558558        ret->name = "jabber";
     559    ret->mms = 0;                        /* no limit */
    559560        ret->login = jabber_login;
    560561        ret->init = jabber_init;
  • protocols/msn/msn.c

    r2af3e23 r8e9e2b7  
    355355       
    356356        ret->name = "msn";
     357    ret->mms = 1409;         /* this guess taken from libotr UPGRADING file */
    357358        ret->login = msn_login;
    358359        ret->init = msn_init;
  • protocols/nogaim.h

    r2af3e23 r8e9e2b7  
    6868#define OPT_TYPING      0x00000100 /* Some pieces of code make assumptions */
    6969#define OPT_THINKING    0x00000200 /* about these values... Stupid me! */
     70#define OPT_NOOTR       0x00001000 /* protocol not suitable for OTR */
    7071
    7172/* ok. now the fun begins. first we create a connection structure */
     
    142143        const char *name;
    143144        void *data;
     145        /* Maximum Message Size of this protocol.
     146         * - Introduced for OTR, in order to fragment large protocol messages.
     147         * - 0 means "unlimited". */
     148        unsigned int mms;
    144149
    145150        /* Added this one to be able to add per-account settings, don't think
  • protocols/oscar/oscar.c

    r2af3e23 r8e9e2b7  
    26122612        struct prpl *ret = g_new0(struct prpl, 1);
    26132613        ret->name = "oscar";
     2614    ret->mms = 2343;       /* this guess taken from libotr UPGRADING file */
    26142615        ret->away_states = oscar_away_states;
    26152616        ret->init = oscar_init;
  • protocols/twitter/twitter.c

    r2af3e23 r8e9e2b7  
    534534        struct prpl *ret = g_new0(struct prpl, 1);
    535535       
     536        ret->options = OPT_NOOTR;
    536537        ret->name = "twitter";
    537538        ret->login = twitter_login;
  • protocols/yahoo/yahoo.c

    r2af3e23 r8e9e2b7  
    379379        struct prpl *ret = g_new0(struct prpl, 1);
    380380        ret->name = "yahoo";
     381    ret->mms = 832;           /* this guess taken from libotr UPGRADING file */
    381382        ret->init = byahoo_init;
    382383       
  • query.c

    r2af3e23 r8e9e2b7  
    106106        int count = 0;
    107107       
     108        if( !ic )
     109                return;
     110       
    108111        q = irc->queries;
    109112        def = query_default( irc );
     
    148151                else
    149152                        irc_usermsg( irc, "Accepted: %s", q->question );
    150                 q->yes( q->data );
     153                if( q->yes )
     154                        q->yes( q->data );
    151155        }
    152156        else
     
    156160                else
    157161                        irc_usermsg( irc, "Rejected: %s", q->question );
    158                 q->no( q->data );
     162                if( q->no )
     163                        q->no( q->data );
    159164        }
    160165        q->data = NULL;
  • root_commands.c

    r2af3e23 r8e9e2b7  
    5555       
    5656        len = strlen( cmd[0] );
    57         for( i = 0; commands[i].command; i++ )
    58                 if( g_strncasecmp( commands[i].command, cmd[0], len ) == 0 )
    59                 {
    60                         if( commands[i+1].command &&
    61                             g_strncasecmp( commands[i+1].command, cmd[0], len ) == 0 )
     57        for( i = 0; root_commands[i].command; i++ )
     58                if( g_strncasecmp( root_commands[i].command, cmd[0], len ) == 0 )
     59                {
     60                        if( root_commands[i+1].command &&
     61                            g_strncasecmp( root_commands[i+1].command, cmd[0], len ) == 0 )
    6262                                /* Only match on the first letters if the match is unique. */
    6363                                break;
    6464                       
    65                         MIN_ARGS( commands[i].required_parameters );
     65                        MIN_ARGS( root_commands[i].required_parameters );
    6666                       
    67                         commands[i].execute( irc, cmd );
     67                        root_commands[i].execute( irc, cmd );
    6868                        return;
    6969                }
     
    13131313
    13141314/* IMPORTANT: Keep this list sorted! The short command logic needs that. */
    1315 const command_t commands[] = {
     1315command_t root_commands[] = {
    13161316        { "account",        1, cmd_account,        0 },
    13171317        { "add",            2, cmd_add,            0 },
     
    13371337        { "transfer",       0, cmd_transfer,       0 },
    13381338        { "yes",            0, cmd_yesno,          0 },
    1339         { NULL }
     1339        /* Not expecting too many plugins adding root commands so just make a
     1340           dumb array with some empty entried at the end. */
     1341        { NULL },
     1342        { NULL },
     1343        { NULL },
     1344        { NULL },
     1345        { NULL },
     1346        { NULL },
     1347        { NULL },
     1348        { NULL },
     1349        { NULL },
    13401350};
     1351static const int num_root_commands = sizeof( root_commands ) / sizeof( command_t );
     1352
     1353gboolean root_command_add( const char *command, int params, void (*func)(irc_t *, char **args), int flags )
     1354{
     1355        int i;
     1356       
     1357        if( root_commands[num_root_commands-2].command )
     1358                /* Planning fail! List is full. */
     1359                return FALSE;
     1360       
     1361        for( i = 0; root_commands[i].command; i++ )
     1362        {
     1363                if( g_strcasecmp( root_commands[i].command, command ) == 0 )
     1364                        return FALSE;
     1365                else if( g_strcasecmp( root_commands[i].command, command ) > 0 )
     1366                        break;
     1367        }
     1368        memmove( root_commands + i + 1, root_commands + i,
     1369                 sizeof( command_t ) * ( num_root_commands - i - 1 ) );
     1370       
     1371        root_commands[i].command = g_strdup( command );
     1372        root_commands[i].required_parameters = params;
     1373        root_commands[i].execute = func;
     1374        root_commands[i].flags = flags;
     1375       
     1376        return TRUE;
     1377}
  • storage.c

    r2af3e23 r8e9e2b7  
    115115                status = st->load(irc, password);
    116116                if (status == STORAGE_OK)
     117                {
     118                        GSList *l;
     119                        for( l = irc_plugins; l; l = l->next )
     120                        {
     121                                irc_plugin_t *p = l->data;
     122                                if( p->storage_load )
     123                                        p->storage_load( irc );
     124                        }
    117125                        return status;
     126                }
    118127               
    119128                if (status != STORAGE_NO_SUCH_USER)
     
    127136{
    128137        storage_status_t st;
     138        GSList *l;
    129139       
    130140        if (password != NULL) {
     
    140150        st = ((storage_t *)global.storage->data)->save(irc, overwrite);
    141151       
     152        for( l = irc_plugins; l; l = l->next )
     153        {
     154                irc_plugin_t *p = l->data;
     155                if( p->storage_save )
     156                        p->storage_save( irc );
     157        }
     158       
    142159        if (password != NULL) {
    143160                irc_setpass(irc, NULL);
     
    151168        GList *gl;
    152169        storage_status_t ret = STORAGE_OK;
     170        gboolean ok = FALSE;
     171        GSList *l;
    153172       
    154173        /* Remove this account from all storage backends. If this isn't
     
    160179
    161180                status = st->remove(nick, password);
     181                ok |= status == STORAGE_OK;
    162182                if (status != STORAGE_NO_SUCH_USER && status != STORAGE_OK)
    163183                        ret = status;
    164184        }
     185       
     186        /* If at least one succeeded, remove plugin data. */
     187        if( ok )
     188                for( l = irc_plugins; l; l = l->next )
     189                {
     190                        irc_plugin_t *p = l->data;
     191                        if( p->storage_remove )
     192                                p->storage_remove( nick );
     193                }
    165194       
    166195        return ret;
  • unix.c

    r2af3e23 r8e9e2b7  
    2929#include "base64.h"
    3030#include "commands.h"
     31#include "otr.h"
    3132#include "protocols/nogaim.h"
    3233#include "help.h"
    3334#include "ipc.h"
     35#include "lib/ssl_client.h"
    3436#include "md5.h"
    3537#include "misc.h"
     
    6870       
    6971        b_main_init();
     72       
     73        /* Ugly Note: libotr and gnutls both use libgcrypt. libgcrypt
     74           has a process-global config state whose initialization happpens
     75           twice if libotr and gnutls are used together. libotr installs custom
     76           memory management functions for libgcrypt while our gnutls module
     77           uses the defaults. Therefore we initialize OTR after SSL. *sigh* */
     78        ssl_init();
     79#ifdef OTR_BI
     80        otr_init();
     81#endif
     82        /* And in case OTR is loaded as a plugin, it'll also get loaded after
     83           this point. */
    7084       
    7185        srand( time( NULL ) ^ getpid() );
Note: See TracChangeset for help on using the changeset viewer.