Changes in / [eda54e4:82135c7]


Ignore:
Files:
2 added
3 deleted
20 edited

Legend:

Unmodified
Added
Removed
  • Makefile

    reda54e4 r82135c7  
    1111# Program variables
    1212objects = account.o bitlbee.o conf.o crypting.o help.o ipc.o irc.o irc_commands.o log.o nick.o query.o root_commands.o set.o storage.o $(STORAGE_OBJS) unix.o user.o
    13 headers = account.h bitlbee.h commands.h conf.h config.h crypting.h help.h ipc.h irc.h log.h nick.h query.h set.h sock.h storage.h user.h lib/events.h lib/http_client.h lib/ini.h lib/md5.h lib/misc.h lib/proxy.h lib/sha.h lib/ssl_client.h lib/url.h protocols/nogaim.h
     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
    1414subdirs = lib protocols
    1515
  • configure

    reda54e4 r82135c7  
    2929strip=1
    3030gcov=0
    31 plugins=1
    3231ipv6=1
    3332
     
    7069--strip=0/1     Disable/enable binary stripping         $strip
    7170--gcov=0/1      Disable/enable test coverage reporting  $gcov
    72 --plugins=0/1   Disable/enable plugins support          $plugins
    7371
    7472--ipv6=0/1      IPv6 socket support                     $ipv6
     73
     74--ldap=0/1/auto LDAP support                            $ldap
    7575
    7676--events=...    Event handler (glib, libevent)          $events
     
    140140
    141141if [ "$debug" = "1" ]; then
    142         [ -z "$CFLAGS" ] && CFLAGS=-g
     142        echo 'CFLAGS=-g' >> Makefile.settings
    143143        echo 'DEBUG=1' >> Makefile.settings
    144144        echo '#define DEBUG' >> config.h
    145145else
    146         [ -z "$CFLAGS" ] && CFLAGS=-O3
    147 fi
    148 
    149 echo CFLAGS=$CFLAGS >> Makefile.settings
     146        echo 'CFLAGS=-O3' >> Makefile.settings
     147fi
     148
    150149echo CFLAGS+=-I`pwd` -I`pwd`/lib -I`pwd`/protocols -I. >> Makefile.settings
    151150
     
    386385fi
    387386
    388 if [ "$plugins" = 0 ]; then
    389         echo '#undef WITH_PLUGINS' >> config.h
    390 else
    391         echo '#define WITH_PLUGINS' >> config.h
    392 fi
    393 
    394387echo
    395388if [ -z "$BITLBEE_VERSION" -a -d .bzr ] && type bzr > /dev/null 2> /dev/null; then
  • doc/CHANGES

    reda54e4 r82135c7  
    1 Version 1.2:
     1Version 1.1dev:
    22- First BitlBee development/testing RELEASE. This should be quite stable
    33  though (and for most people more stable than 1.0.x). It just has a couple
     
    6565    resources available for that buddy. (Of course this only works if the
    6666    buddy is in your contact list.)
    67 
    68 Finished ???
    69 
    70 Version 1.0.4:
    71 - Removed sethostent(), which causes problems for many people, especially on
    72   *BSD. This is basically the reason for this release.
    73 - "allow" command actually displays the allow list, not the block list.
    74 - Yahoo away state/msg fix.
    75 - Don't display "Gender: Male" by default if nothing's filled in (OSCAR
    76   "info" command)
    77 - Fixed account cleanup (possible infinite loop) in irc_free().
    78 - Fixed configdir error message to not always display the compile-time
    79   setting.
    80 
    81 Finished 20 Aug 2007
    8267
    8368Version 1.0.3:
  • doc/user-guide/commands.xml

    reda54e4 r82135c7  
    596596        </bitlbee-setting>
    597597
    598         <bitlbee-setting name="simulate_netsplit" type="boolean" scope="global">
    599                 <default>true</default>
    600 
    601                 <description>
    602                         <para>
    603                                 Some IRC clients parse quit messages sent by the IRC server to see if someone really left or just disappeared because of a netsplit. By default, BitlBee tries to simulate netsplit-like quit messages to keep the control channel window clean. If you don't like this (or if your IRC client doesn't support this) you can disable this setting.
    604                         </para>
    605                 </description>
    606         </bitlbee-setting>
    607 
    608598        <bitlbee-setting name="ssl" type="boolean" scope="account">
    609599                <default>false</default>
  • irc.c

    reda54e4 r82135c7  
    132132        set_add( &irc->set, "buddy_sendbuffer", "false", set_eval_bool, irc );
    133133        set_add( &irc->set, "buddy_sendbuffer_delay", "200", set_eval_int, irc );
    134         set_add( &irc->set, "charset", "utf-8", set_eval_charset, irc );
     134        set_add( &irc->set, "charset", "iso8859-1", set_eval_charset, irc );
    135135        set_add( &irc->set, "debug", "false", set_eval_bool, irc );
    136136        set_add( &irc->set, "default_target", "root", NULL, irc );
     
    143143        set_add( &irc->set, "query_order", "lifo", NULL, irc );
    144144        set_add( &irc->set, "save_on_quit", "true", set_eval_bool, irc );
    145         set_add( &irc->set, "simulate_netsplit", "true", set_eval_bool, irc );
    146145        set_add( &irc->set, "strip_html", "true", NULL, irc );
    147146        set_add( &irc->set, "to_char", ": ", set_eval_to_char, irc );
     
    911910        char reason[128];
    912911       
    913         if( u->ic && u->ic->flags & OPT_LOGGING_OUT && set_getbool( &irc->set, "simulate_netsplit" ) )
     912        if( u->ic && u->ic->flags & OPT_LOGGING_OUT )
    914913        {
    915914                if( u->ic->acc->server )
  • lib/Makefile

    reda54e4 r82135c7  
    1010
    1111# [SH] Program variables
    12 objects = arc.o base64.o $(EVENT_HANDLER) http_client.o ini.o md5.o misc.o proxy.o sha.o $(SSL_CLIENT) url.o
     12objects = base64.o $(EVENT_HANDLER) http_client.o ini.o md5.o misc.o proxy.o rc4.o sha.o $(SSL_CLIENT) url.o
    1313
    1414CFLAGS += -Wall
  • lib/base64.c

    reda54e4 r82135c7  
    3131char *tobase64(const char *text)
    3232{
    33         return base64_encode((const unsigned char *)text, strlen(text));
     33        return base64_encode(text, strlen(text));
    3434}
    3535
    36 char *base64_encode(const unsigned char *in, int len)
     36char *base64_encode(const char *in, int len)
    3737{
    3838        char *out;
  • lib/base64.h

    reda54e4 r82135c7  
    2727
    2828G_MODULE_EXPORT char *tobase64( const char *text );
    29 G_MODULE_EXPORT char *base64_encode( const unsigned char *in, int len );
     29G_MODULE_EXPORT char *base64_encode( const char *in, int len );
    3030G_MODULE_EXPORT int base64_encode_real( const unsigned char *in, int inlen, unsigned char *out, const char *b64digits );
    3131G_MODULE_EXPORT char *frombase64( const char *in );
  • lib/misc.c

    reda54e4 r82135c7  
    545545        return reply;
    546546}
    547 
    548 /* Word wrapping. Yes, I know this isn't UTF-8 clean. I'm willing to take the risk. */
    549 char *word_wrap( char *msg, int line_len )
    550 {
    551         GString *ret = g_string_sized_new( strlen( msg ) + 16 );
    552        
    553         while( strlen( msg ) > line_len )
    554         {
    555                 int i;
    556                
    557                 /* First try to find out if there's a newline already. Don't
    558                    want to add more splits than necessary. */
    559                 for( i = line_len; i > 0 && msg[i] != '\n'; i -- );
    560                 if( msg[i] == '\n' )
    561                 {
    562                         g_string_append_len( ret, msg, i + 1 );
    563                         msg += i + 1;
    564                         continue;
    565                 }
    566                
    567                 for( i = line_len; i > 0; i -- )
    568                 {
    569                         if( msg[i] == '-' )
    570                         {
    571                                 g_string_append_len( ret, msg, i + 1 );
    572                                 g_string_append_c( ret, '\n' );
    573                                 msg += i + 1;
    574                                 break;
    575                         }
    576                         else if( msg[i] == ' ' )
    577                         {
    578                                 g_string_append_len( ret, msg, i );
    579                                 g_string_append_c( ret, '\n' );
    580                                 msg += i + 1;
    581                                 break;
    582                         }
    583                 }
    584                 if( i == 0 )
    585                 {
    586                         g_string_append_len( ret, msg, line_len );
    587                         g_string_append_c( ret, '\n' );
    588                         msg += line_len;
    589                 }
    590         }
    591         g_string_append( ret, msg );
    592        
    593         return g_string_free( ret, FALSE );
    594 }
  • lib/misc.h

    reda54e4 r82135c7  
    6464G_MODULE_EXPORT struct ns_srv_reply *srv_lookup( char *service, char *protocol, char *domain );
    6565
    66 G_MODULE_EXPORT char *word_wrap( char *msg, int line_len );
    67 
    6866#endif
  • lib/ssl_bogus.c

    reda54e4 r82135c7  
    5252}
    5353
    54 void *ssl_starttls( int fd, ssl_input_function func, gpointer data )
    55 {
    56         return NULL;
    57 }
    58 
    5954b_input_condition ssl_getdirection( void *conn )
    6055{
  • protocols/jabber/sasl.c

    reda54e4 r82135c7  
    8989                strcpy( s + 1, jd->username );
    9090                strcpy( s + 2 + strlen( jd->username ), ic->acc->pass );
    91                 reply->text = base64_encode( (unsigned char *)s, len );
     91                reply->text = base64_encode( s, len );
    9292                reply->text_len = strlen( reply->text );
    9393                g_free( s );
     
    185185        struct jabber_data *jd = ic->proto_data;
    186186        struct xt_node *reply = NULL;
    187         char *nonce = NULL, *realm = NULL, *cnonce = NULL;
    188         unsigned char cnonce_bin[30];
     187        char *nonce = NULL, *realm = NULL, *cnonce = NULL, cnonce_bin[30];
    189188        char *digest_uri = NULL;
    190189        char *dec = NULL;
     
    217216                        realm = g_strdup( jd->server );
    218217               
    219                 random_bytes( cnonce_bin, sizeof( cnonce_bin ) );
     218                random_bytes( (unsigned char *) cnonce_bin, sizeof( cnonce_bin ) );
    220219                cnonce = base64_encode( cnonce_bin, sizeof( cnonce_bin ) );
    221220                digest_uri = g_strdup_printf( "%s/%s", "xmpp", jd->server );
  • protocols/nogaim.c

    reda54e4 r82135c7  
    4848
    4949        if(!mod) {
    50                 log_message(LOGLVL_ERROR, "Can't find `%s', not loading (%s)\n", path, g_module_error());
     50                log_message(LOGLVL_ERROR, "Can't find `%s', not loading", path);
    5151                return FALSE;
    5252        }
     
    608608              ( ( u->online == oo ) && ( oa == !u->away ) ) ) )         /* (De)voice people changing state */
    609609        {
    610                 char *from;
    611                
    612                 if( set_getbool( &ic->irc->set, "simulate_netsplit" ) )
    613                 {
    614                         from = g_strdup( ic->irc->myhost );
    615                 }
    616                 else
    617                 {
    618                         from = g_strdup_printf( "%s!%s@%s", ic->irc->mynick, ic->irc->mynick,
    619                                                             ic->irc->myhost );
    620                 }
    621                 irc_write( ic->irc, ":%s MODE %s %cv %s", from, ic->irc->channel,
    622                                                           u->away?'-':'+', u->nick );
    623                 g_free( from );
     610                irc_write( ic->irc, ":%s MODE %s %cv %s", ic->irc->myhost,
     611                                                          ic->irc->channel, u->away?'-':'+', u->nick );
    624612        }
    625613}
     
    628616{
    629617        irc_t *irc = ic->irc;
    630         char *wrapped;
    631618        user_t *u;
    632619       
     
    671658                strip_html( msg );
    672659
    673         wrapped = word_wrap( msg, 425 );
    674         irc_msgfrom( irc, u->nick, wrapped );
    675         g_free( wrapped );
     660        while( strlen( msg ) > 425 )
     661        {
     662                char tmp, *nl;
     663               
     664                tmp = msg[425];
     665                msg[425] = 0;
     666               
     667                /* If there's a newline/space in this string, split up there,
     668                   looks a bit prettier. */
     669                if( ( nl = strrchr( msg, '\n' ) ) || ( nl = strrchr( msg, ' ' ) ) )
     670                {
     671                        msg[425] = tmp;
     672                        tmp = *nl;
     673                        *nl = 0;
     674                }
     675               
     676                irc_msgfrom( irc, u->nick, msg );
     677               
     678                /* Move on. */
     679                if( nl )
     680                {
     681                        *nl = tmp;
     682                        msg = nl + 1;
     683                }
     684                else
     685                {
     686                        msg[425] = tmp;
     687                        msg += 425;
     688                }
     689        }
     690        irc_msgfrom( irc, u->nick, msg );
    676691}
    677692
     
    735750{
    736751        struct im_connection *ic = c->ic;
    737         char *wrapped;
    738752        user_t *u;
    739753       
     
    748762                strip_html( msg );
    749763       
    750         wrapped = word_wrap( msg, 425 );
    751764        if( c && u )
    752         {
    753                 irc_privmsg( ic->irc, u, "PRIVMSG", c->channel, "", wrapped );
    754         }
     765                irc_privmsg( ic->irc, u, "PRIVMSG", c->channel, "", msg );
    755766        else
    756         {
    757                 imcb_log( ic, "Message from/to conversation %s@0x%x (unknown conv/user): %s", who, (int) c, wrapped );
    758         }
    759         g_free( wrapped );
     767                imcb_log( ic, "Message from/to conversation %s@0x%x (unknown conv/user): %s", who, (int) c, msg );
    760768}
    761769
  • protocols/nogaim.h

    reda54e4 r82135c7  
    9898        struct im_connection *ic;
    9999
    100         /* stuff used just for chat */
    101         /* The in_room variable is a list of handles (not nicks!), kind of
    102          * "nick list". This is how you can check who is in the group chat
    103          * already, for example to avoid adding somebody two times. */
    104100        GList *in_room;
    105101        GList *ignored;
     
    107103        struct groupchat *next;
    108104        char *channel;
    109         /* The title variable contains the ID you gave when you created the
    110          * chat using imcb_chat_new(). */
    111105        char *title;
    112106        char joined;
    113         /* This is for you, you can add your own structure here to extend this
    114          * structure for your protocol's needs. */
    115107        void *data;
    116108};
     
    131123struct prpl {
    132124        int options;
    133         /* You should set this to the name of your protocol.
    134          * - The user sees this name ie. when imcb_log() is used. */
    135125        const char *name;
    136126
    137127        /* Added this one to be able to add per-account settings, don't think
    138          * it should be used for anything else. You are supposed to use the
    139          * set_add() function to add new settings. */
     128           it should be used for anything else. */
    140129        void (* init)           (account_t *);
    141         /* The typical usage of the login() function:
    142          * - Create an im_connection using imcb_new() from the account_t parameter.
    143          * - Initialize your myproto_data struct - you should store all your protocol-specific data there.
    144          * - Save your custom structure to im_connection->proto_data.
    145          * - Use proxy_connect() to connect to the server.
    146          */
     130        /* These should all be pretty obvious. */
    147131        void (* login)          (account_t *);
    148         /* Implementing this function is optional. */
    149132        void (* keepalive)      (struct im_connection *);
    150         /* In this function you should:
    151          * - Tell the server about you are logging out.
    152          * - g_free() your myproto_data struct as BitlBee does not know how to
    153          *   properly do so.
    154          */
    155133        void (* logout)         (struct im_connection *);
    156134       
    157         /* This function is called when the user wants to send a message to a handle.
    158          * - 'to' is a handle, not a nick
    159          * - 'flags' may be ignored
    160          */
    161135        int  (* buddy_msg)      (struct im_connection *, char *to, char *message, int flags);
    162         /* This function is called then the user uses the /away IRC command.
    163          * - 'state' contains the away reason.
    164          * - 'message' may be ignored if your protocol does not support it.
    165          */
    166136        void (* set_away)       (struct im_connection *, char *state, char *message);
    167         /* Implementing this function is optional. */
    168137        void (* get_away)       (struct im_connection *, char *who);
    169         /* Implementing this function is optional. */
    170138        int  (* send_typing)    (struct im_connection *, char *who, int flags);
    171139       
    172         /* 'name' is a handle to add/remove. For now BitlBee doesn't really
    173          * handle groups, just set it to NULL, so you can ignore that
    174          * parameter. */
     140        /* For now BitlBee doesn't really handle groups, just set it to NULL. */
    175141        void (* add_buddy)      (struct im_connection *, char *name, char *group);
    176142        void (* remove_buddy)   (struct im_connection *, char *name, char *group);
    177143       
    178         /* Block list stuff. Implementing these are optional. */
     144        /* Block list stuff. */
    179145        void (* add_permit)     (struct im_connection *, char *who);
    180146        void (* add_deny)       (struct im_connection *, char *who);
     
    185151       
    186152        /* Request profile info. Free-formatted stuff, the IM module gives back
    187            this info via imcb_log(). Implementing these are optional. */
     153           this info via imcb_log(). */
    188154        void (* get_info)       (struct im_connection *, char *who);
    189155        void (* set_my_name)    (struct im_connection *, char *name);
     
    191157       
    192158        /* Group chat stuff. */
    193         /* This is called when the user uses the /invite IRC command.
    194          * - 'who' may be ignored
    195          * - 'message' is a handle to invite
    196          */
    197159        void (* chat_invite)    (struct groupchat *, char *who, char *message);
    198         /* This is called when the user uses the /part IRC command in a group
    199          * chat. You just should tell the user about it, nothing more. */
    200160        void (* chat_leave)     (struct groupchat *);
    201         /* This is called when the user sends a message to the groupchat.
    202          * 'flags' may be ignored. */
    203161        void (* chat_msg)       (struct groupchat *, char *message, int flags);
    204         /* This is called when the user uses the /join #nick IRC command.
    205          * - 'who' is the handle of the nick
    206          */
    207162        struct groupchat *
    208163             (* chat_with)      (struct im_connection *, char *who);
    209         /* This is used when the user uses the /join #channel IRC command.  If
    210          * your protocol does not support publicly named group chats, then do
    211          * not implement this. */
    212164        struct groupchat *
    213165             (* chat_join)      (struct im_connection *, char *room, char *nick, char *password);
    214166       
    215         /* You can tell what away states your protocol supports, so that
    216          * BitlBee will try to map the IRC away reasons to them, or use
    217          * GAIM_AWAY_CUSTOM when calling skype_set_away(). */
    218167        GList *(* away_states)(struct im_connection *ic);
    219168       
    220         /* Mainly for AOL, since they think "Bung hole" == "Bu ngho le". *sigh*
    221          * - Most protocols will just want to set this to g_strcasecmp().*/
     169        /* Mainly for AOL, since they think "Bung hole" == "Bu ngho le". *sigh* */
    222170        int (* handle_cmp) (const char *who1, const char *who2);
    223171};
     
    227175G_MODULE_EXPORT GSList *get_connections();
    228176G_MODULE_EXPORT struct prpl *find_protocol( const char *name );
    229 /* When registering a new protocol, you should allocate space for a new prpl
    230  * struct, initialize it (set the function pointers to point to your
    231  * functions), finally call this function. */
    232177G_MODULE_EXPORT void register_protocol( struct prpl * );
    233178
    234179/* Connection management. */
    235 /* You will need this function in prpl->login() to get an im_connection from
    236  * the account_t parameter. */
    237180G_MODULE_EXPORT struct im_connection *imcb_new( account_t *acc );
    238181G_MODULE_EXPORT void imcb_free( struct im_connection *ic );
    239 /* Once you're connected, you should call this function, so that the user will
    240  * see the success. */
    241182G_MODULE_EXPORT void imcb_connected( struct im_connection *ic );
    242 /* This can be used to disconnect when something went wrong (ie. read error
    243  * from the server). You probably want to set the second parameter to TRUE. */
    244183G_MODULE_EXPORT void imc_logout( struct im_connection *ic, int allow_reconnect );
    245184
    246185/* Communicating with the user. */
    247 /* A printf()-like function to tell the user anything you want. */
    248186G_MODULE_EXPORT void imcb_log( struct im_connection *ic, char *format, ... ) G_GNUC_PRINTF( 2, 3 );
    249 /* To tell the user an error, ie. before logging out when an error occurs. */
    250187G_MODULE_EXPORT void imcb_error( struct im_connection *ic, char *format, ... ) G_GNUC_PRINTF( 2, 3 );
    251 /* To ask a your about something.
    252  * - 'msg' is the question.
    253  * - 'data' can be your custom struct - it will be passed to the callbacks.
    254  * - 'doit' or 'dont' will be called depending of the answer of the user.
    255  */
    256188G_MODULE_EXPORT void imcb_ask( struct im_connection *ic, char *msg, void *data, void *doit, void *dont );
    257189G_MODULE_EXPORT void imcb_ask_add( struct im_connection *ic, char *handle, const char *realname );
    258190
    259191/* Buddy management */
    260 /* This function should be called for each handle which are visible to the
    261  * user, usually after a login, or if the user added a buddy and the IM
    262  * server confirms that the add was successful. Don't forget to do this! */
    263192G_MODULE_EXPORT void imcb_add_buddy( struct im_connection *ic, char *handle, char *group );
    264193G_MODULE_EXPORT void imcb_remove_buddy( struct im_connection *ic, char *handle, char *group );
     
    268197
    269198/* Buddy activity */
    270 /* To manipulate the status of a handle.
    271  * - flags can be |='d with OPT_* constants. You will need at least:
    272  *   OPT_LOGGED_IN and OPT_AWAY.
    273  * - 'state' and 'message' can be NULL */
    274199G_MODULE_EXPORT void imcb_buddy_status( struct im_connection *ic, const char *handle, int flags, const char *state, const char *message );
    275200/* Not implemented yet! */ G_MODULE_EXPORT void imcb_buddy_times( struct im_connection *ic, const char *handle, time_t login, time_t idle );
    276 /* Call when a handle says something. 'flags' and 'sent_at may be just 0. */
    277201G_MODULE_EXPORT void imcb_buddy_msg( struct im_connection *ic, char *handle, char *msg, u_int32_t flags, time_t sent_at );
    278202G_MODULE_EXPORT void imcb_buddy_typing( struct im_connection *ic, char *handle, u_int32_t flags );
     
    281205/* Groupchats */
    282206G_MODULE_EXPORT void imcb_chat_invited( struct im_connection *ic, char *handle, char *who, char *msg, GList *data );
    283 /* These two functions are to create a group chat.
    284  * - imcb_chat_new(): the 'handle' parameter identifies the chat, like the
    285  *   channel name on IRC.
    286  * - After you have a groupchat pointer, you should add the handles, finally
    287  *   the user her/himself. At that point the group chat will be visible to the
    288  *   user, too. */
    289207G_MODULE_EXPORT struct groupchat *imcb_chat_new( struct im_connection *ic, char *handle );
    290208G_MODULE_EXPORT void imcb_chat_add_buddy( struct groupchat *b, char *handle );
    291 /* To remove a handle from a group chat. Reason can be NULL. */
    292209G_MODULE_EXPORT void imcb_chat_remove_buddy( struct groupchat *b, char *handle, char *reason );
    293 /* To tell BitlBee 'who' said 'msg' in 'c'. 'flags' and 'sent_at' can be 0. */
    294210G_MODULE_EXPORT void imcb_chat_msg( struct groupchat *c, char *who, char *msg, u_int32_t flags, time_t sent_at );
    295211G_MODULE_EXPORT void imcb_chat_free( struct groupchat *c );
  • root_commands.c

    reda54e4 r82135c7  
    383383                }
    384384               
    385                 if( cmd[3] && set_name )
     385                if( cmd[3] )
    386386                {
    387387                        set_t *s = set_find( &a->set, set_name );
  • storage_xml.c

    reda54e4 r82135c7  
    2727#include "bitlbee.h"
    2828#include "base64.h"
    29 #include "arc.h"
     29#include "rc4.h"
    3030#include "md5.h"
    3131
     
    132132        {
    133133                char *protocol, *handle, *server, *password = NULL, *autoconnect;
    134                 char *pass_b64 = NULL;
    135                 unsigned char *pass_cr = NULL;
     134                char *pass_b64 = NULL, *pass_rc4 = NULL;
    136135                int pass_len;
    137136                struct prpl *prpl = NULL;
     
    152151                        g_set_error( error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
    153152                                     "Unknown protocol: %s", protocol );
    154                 else if( ( pass_len = base64_decode( pass_b64, (unsigned char**) &pass_cr ) ) &&
    155                                          arc_decode( pass_cr, pass_len, &password, xd->given_pass ) )
     153                else if( ( pass_len = base64_decode( pass_b64, (unsigned char**) &pass_rc4 ) ) &&
     154                                rc4_decode( (unsigned char*) pass_rc4, pass_len,
     155                                            (unsigned char**) &password, xd->given_pass ) )
    156156                {
    157157                        xd->current_account = account_add( irc, prpl, handle, password );
     
    169169                }
    170170               
    171                 g_free( pass_cr );
     171                g_free( pass_rc4 );
    172172                g_free( password );
    173173        }
     
    410410        md5_finish( &md5_state, pass_md5 );
    411411        /* Save the hash in base64-encoded form. */
    412         pass_buf = base64_encode( pass_md5, 21 );
     412        pass_buf = base64_encode( (char*) pass_md5, 21 );
    413413       
    414414        if( !xml_printf( fd, 0, "<user nick=\"%s\" password=\"%s\" version=\"%d\">\n", irc->nick, pass_buf, XML_FORMAT_VERSION ) )
     
    424424        for( acc = irc->accounts; acc; acc = acc->next )
    425425        {
    426                 unsigned char *pass_cr;
    427                 char *pass_b64;
     426                char *pass_rc4, *pass_b64;
    428427                int pass_len;
    429428               
    430                 pass_len = arc_encode( acc->pass, strlen( acc->pass ), (unsigned char**) &pass_cr, irc->password );
    431                 pass_b64 = base64_encode( pass_cr, pass_len );
    432                 g_free( pass_cr );
     429                pass_len = rc4_encode( (unsigned char*) acc->pass, strlen( acc->pass ), (unsigned char**) &pass_rc4, irc->password );
     430                pass_b64 = base64_encode( pass_rc4, pass_len );
     431                g_free( pass_rc4 );
    433432               
    434433                if( !xml_printf( fd, 1, "<account protocol=\"%s\" handle=\"%s\" password=\"%s\" autoconnect=\"%d\"", acc->prpl->name, acc->user, pass_b64, acc->auto_connect ) )
  • tests/Makefile

    reda54e4 r82135c7  
    1313main_objs = account.o bitlbee.o conf.o crypting.o help.o ipc.o irc.o irc_commands.o log.o nick.o query.o root_commands.o set.o storage.o storage_xml.o storage_text.o user.o
    1414
    15 test_objs = check.o check_util.o check_nick.o check_md5.o check_arc.o check_irc.o check_help.o check_user.o check_crypting.o check_set.o
     15test_objs = check.o check_util.o check_nick.o check_md5.o check_irc.o check_help.o check_user.o check_crypting.o check_set.o
    1616
    1717check: $(test_objs) $(addprefix ../, $(main_objs)) ../protocols/protocols.o ../lib/lib.o
  • tests/check.c

    reda54e4 r82135c7  
    4747/* From check_md5.c */
    4848Suite *md5_suite(void);
    49 
    50 /* From check_arc.c */
    51 Suite *arc_suite(void);
    5249
    5350/* From check_irc.c */
     
    105102        srunner_add_suite(sr, nick_suite());
    106103        srunner_add_suite(sr, md5_suite());
    107         srunner_add_suite(sr, arc_suite());
    108104        srunner_add_suite(sr, irc_suite());
    109105        srunner_add_suite(sr, help_suite());
  • tests/check_util.c

    reda54e4 r82135c7  
    104104END_TEST
    105105
    106 struct
    107 {
    108         char *orig;
    109         int line_len;
    110         char *wrapped;
    111 } word_wrap_tests[] = {
    112         {
    113                 "Line-wrapping is not as easy as it seems?",
    114                 16,
    115                 "Line-wrapping is\nnot as easy as\nit seems?"
    116         },
    117         {
    118                 "Line-wrapping is not as easy as it seems?",
    119                 8,
    120                 "Line-\nwrapping\nis not\nas easy\nas it\nseems?"
    121         },
    122         {
    123                 "Line-wrapping is\nnot as easy as it seems?",
    124                 8,
    125                 "Line-\nwrapping\nis\nnot as\neasy as\nit\nseems?"
    126         },
    127         {
    128                 "a aa aaa aaaa aaaaa aaaaaa aaaaaaa aaaaaaaa",
    129                 5,
    130                 "a aa\naaa\naaaa\naaaaa\naaaaa\na\naaaaa\naa\naaaaa\naaa",
    131         },
    132         {
    133                 "aaaaaaaa aaaaaaa aaaaaa aaaaa aaaa aaa aa a",
    134                 5,
    135                 "aaaaa\naaa\naaaaa\naa\naaaaa\na\naaaaa\naaaa\naaa\naa a",
    136         },
    137         {
    138                 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    139                 5,
    140                 "aaaaa\naaaaa\naaaaa\naaaaa\naaaaa\naaaaa\naaaaa\na",
    141         },
    142         {
    143                 NULL
    144         }
    145 };
    146 
    147 START_TEST(test_word_wrap)
    148         int i;
    149        
    150         for( i = 0; word_wrap_tests[i].orig && *word_wrap_tests[i].orig; i ++ )
    151         {
    152                 char *wrapped = word_wrap( word_wrap_tests[i].orig, word_wrap_tests[i].line_len );
    153                
    154                 fail_unless( strcmp( word_wrap_tests[i].wrapped, wrapped ) == 0,
    155                              "%s (line_len = %d) should wrap to `%s', not to `%s'",
    156                              word_wrap_tests[i].orig, word_wrap_tests[i].line_len,
    157                              word_wrap_tests[i].wrapped, wrapped );
    158                
    159                 g_free( wrapped );
    160         }
    161 END_TEST
    162 
    163106Suite *util_suite (void)
    164107{
     
    173116        tcase_add_test (tc_core, test_set_url_username);
    174117        tcase_add_test (tc_core, test_set_url_username_pwd);
    175         tcase_add_test (tc_core, test_word_wrap);
    176118        return s;
    177119}
  • unix.c

    reda54e4 r82135c7  
    4747        memset( &global, 0, sizeof( global_t ) );
    4848       
     49        b_main_init();
    4950        log_init();
     51        nogaim_init();
     52       
     53        srand( time( NULL ) ^ getpid() );
     54       
    5055        CONF_FILE = g_strdup( CONF_FILE_DEF );
     56        global.helpfile = g_strdup( HELP_FILE );
     57       
    5158        global.conf = conf_load( argc, argv );
    5259        if( global.conf == NULL )
    5360                return( 1 );
    54        
    55         b_main_init();
    56         nogaim_init();
    57        
    58         srand( time( NULL ) ^ getpid() );
    59         global.helpfile = g_strdup( HELP_FILE );
    6061       
    6162        if( global.conf->runmode == RUNMODE_INETD )
Note: See TracChangeset for help on using the changeset viewer.