Changes in / [0fbd3a6d:793cc25]


Ignore:
Files:
23 edited

Legend:

Unmodified
Added
Removed
  • account.c

    r0fbd3a6d r793cc25  
    9595                g_free( acc->server );
    9696                if( *value )
    97                 {
    9897                        acc->server = g_strdup( value );
    99                         return value;
    100                 }
    10198                else
    102                 {
    10399                        acc->server = NULL;
    104                         return g_strdup( set->def );
    105                 }
     100                return value;
    106101        }
    107102        else if( strcmp( set->key, "auto_connect" ) == 0 )
  • dcc.c

    r0fbd3a6d r793cc25  
    125125        file = df->ft;
    126126        file->write = dccs_send_write;
     127        file->sending = TRUE;
    127128
    128129        /* listen and request */
  • doc/CREDITS

    r0fbd3a6d r793cc25  
    5555- Greg (gropeep.org), for updating the Yahoo! module to fix some issues
    5656  that were there for quite some time already.
    57 - misc@mandriva.org for lots of Jabber contributions.
    5857
    5958- And all other users who help us by sending useful bug reports, positive
  • doc/user-guide/commands.xml

    r0fbd3a6d r793cc25  
    1717
    1818                <bitlbee-command name="add">
    19                         <syntax>account add &lt;protocol&gt; &lt;username&gt; &lt;password&gt;</syntax>
     19                        <syntax>account add &lt;protocol&gt; &lt;username&gt; &lt;password&gt; [&lt;server&gt;]</syntax>
    2020
    2121                        <description>
     
    2626                       
    2727                        <bitlbee-command name="jabber">
    28                                 <syntax>account add jabber &lt;handle@server.tld&gt; &lt;password&gt;</syntax>
     28                                <syntax>account add jabber &lt;handle@server.tld&gt; &lt;password&gt; [&lt;servertag&gt;]</syntax>
    2929
    3030                                <description>
     
    5050                       
    5151                        <bitlbee-command name="oscar">
    52                                 <syntax>account add oscar &lt;handle&gt; &lt;password&gt;</syntax>
     52                                <syntax>account add oscar &lt;handle&gt; &lt;password&gt; [&lt;servername&gt;]</syntax>
    5353
    5454                                <description>
    5555                                        <para>
    56                                                 OSCAR is the protocol used to connect to AIM and/or ICQ. The servers will automatically detect if you're using a numeric or non-numeric username so there's no need to tell which network you want to connect to.
     56                                                Specifying a server is required for OSCAR, since OSCAR can be used for both ICQ- and AIM-connections. Although these days it's supposed to be possible to connect to ICQ via AIM-servers and vice versa, we like to stick with this separation for now. For ICQ connections, the servername is <emphasis>login.icq.com</emphasis>, for AIM connections it's <emphasis>login.oscar.aol.com</emphasis>.
    5757                                        </para>
    5858                                </description>
    5959
    6060                                <ircexample>
    61                                         <ircline nick="wilmer">account add oscar 72696705 hobbelmeeuw</ircline>
     61                                        <ircline nick="wilmer">account add oscar 72696705 hobbelmeeuw login.icq.com</ircline>
    6262                                        <ircline nick="root">Account successfully added</ircline>
    6363                                </ircexample>
     
    595595                <description>
    596596                        <para>
    597                                 Can be set for Jabber- and OSCAR-connections. For Jabber, you might have to set this if the servername isn't equal to the part after the @ in the Jabber handle. For OSCAR this shouldn't be necessary anymore in recent BitlBee versions.
     597                                Can be set for Jabber- and OSCAR-connections. For OSCAR, this must be set to <emphasis>login.icq.com</emphasis> if it's an ICQ connection, or <emphasis>login.oscar.aol.com</emphasis> if it's an AIM connection. For Jabber, you have to set this if the servername isn't equal to the part after the @ in the Jabber handle.
    598598                        </para>
    599599                </description>
  • doc/user-guide/quickstart.xml

    r0fbd3a6d r793cc25  
    3838
    3939<ircexample>
    40         <ircline nick="you">account add jabber bitlbee@jabber.org QuickStart</ircline>
     40        <ircline nick="you">account add oscar 72696705 QuickStart login.icq.com</ircline>
    4141        <ircline nick="root">Account successfully added</ircline>
    4242</ircexample>
    4343
    4444<para>
    45 Other available IM protocols are msn, oscar, and yahoo. Oscar is the protocol used by ICQ and AOL.
     45Other available IM protocols are jabber, msn, and yahoo. Oscar is the protocol used by ICQ and AOL. For oscar, you need to specify the IM-server as a fourth argument (for msn and yahoo there is no fourth argument). For AOL Instant Messenger, the server name is <emphasis>login.oscar.aol.com</emphasis>. For ICQ, the server name is <emphasis>login.icq.com</emphasis>.
    4646</para>
    4747
  • irc_commands.c

    r0fbd3a6d r793cc25  
    207207                if( c->ic && c->ic->acc->prpl->chat_invite )
    208208                {
    209                         c->ic->acc->prpl->chat_invite( c, u->handle, NULL );
     209                        c->ic->acc->prpl->chat_invite( c, "", u->handle );
    210210                        irc_reply( irc, 341, "%s %s", nick, channel );
    211211                        return;
  • lib/misc.c

    r0fbd3a6d r793cc25  
    4444#include <resolv.h>
    4545#endif
    46 
    47 #include "ssl_client.h"
    4846
    4947void strip_linefeed(gchar *text)
     
    593591        return g_string_free( ret, FALSE );
    594592}
    595 
    596 gboolean ssl_sockerr_again( void *ssl )
    597 {
    598         if( ssl )
    599                 return ssl_errno == SSL_AGAIN;
    600         else
    601                 return sockerr_again();
    602 }
  • lib/misc.h

    r0fbd3a6d r793cc25  
    6666G_MODULE_EXPORT char *word_wrap( char *msg, int line_len );
    6767
    68 G_MODULE_EXPORT gboolean ssl_sockerr_again( void *ssl );
    69 
    7068#endif
  • lib/ssl_gnutls.c

    r0fbd3a6d r793cc25  
    223223        closesocket( conn->fd );
    224224       
    225         if( conn->session )
    226                 gnutls_deinit( conn->session );
    227         if( conn->xcred )
    228                 gnutls_certificate_free_credentials( conn->xcred );
     225        gnutls_deinit( conn->session );
     226        gnutls_certificate_free_credentials( conn->xcred );
    229227        g_free( conn );
    230228}
  • nick.c

    r0fbd3a6d r793cc25  
    154154   With one difference, we allow dashes. */
    155155
    156 static char *nick_lc_chars = "0123456789abcdefghijklmnopqrstuvwxyz{}^`-_|";
    157 static char *nick_uc_chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ[]~`-_\\";
    158 
    159 void nick_strip( char *nick )
     156static char *nick_lc_chars = "0123456789abcdefghijklmnopqrstuvwxyz{}^-_|";
     157static char *nick_uc_chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ[]~-_\\";
     158
     159void nick_strip( char * nick )
    160160{
    161161        int i, j;
     
    170170                }
    171171        }
    172         if( isdigit( nick[0] ) )
    173         {
    174                 char *orig;
    175                
    176                 orig = g_strdup( nick );
    177                 g_snprintf( nick, MAX_NICK_LENGTH, "_%s", orig );
    178                 g_free( orig );
    179                 j ++;
    180         }
    181172        while( j <= MAX_NICK_LENGTH )
    182173                nick[j++] = '\0';
     
    187178        const char *s;
    188179       
    189         /* Empty/long nicks are not allowed, nor numbers at [0] */
    190         if( !*nick || isdigit( nick[0] ) || strlen( nick ) > MAX_NICK_LENGTH )
     180        /* Empty/long nicks are not allowed */
     181        if( !*nick || strlen( nick ) > MAX_NICK_LENGTH )
    191182                return( 0 );
    192183       
  • protocols/jabber/conference.c

    r0fbd3a6d r793cc25  
    174174       
    175175        return 1;
    176 }
    177 
    178 void jabber_chat_invite( struct groupchat *c, char *who, char *message )
    179 {
    180         struct xt_node *node;
    181         struct im_connection *ic = c->ic;
    182         struct jabber_chat *jc = c->data;
    183 
    184         node = xt_new_node( "reason", message, NULL );
    185 
    186         node = xt_new_node( "invite", NULL, node );
    187         xt_add_attr( node, "to", who );
    188 
    189         node = xt_new_node( "x", NULL, node );
    190         xt_add_attr( node, "xmlns", XMLNS_MUC_USER );
    191        
    192         node = jabber_make_packet( "message", NULL, jc->name, node );
    193 
    194         jabber_write_packet( ic, node );
    195 
    196         xt_free_node( node );
    197176}
    198177
  • protocols/jabber/io.c

    r0fbd3a6d r793cc25  
    120120                return TRUE;
    121121        }
    122         else if( st == 0 || ( st < 0 && !ssl_sockerr_again( jd->ssl ) ) )
     122        else if( st == 0 || ( st < 0 && !sockerr_again() ) )
    123123        {
    124124                /* Set fd to -1 to make sure we won't write to it anymore. */
     
    231231                }
    232232        }
    233         else if( st == 0 || ( st < 0 && !ssl_sockerr_again( jd->ssl ) ) )
     233        else if( st == 0 || ( st < 0 && !sockerr_again() ) )
    234234        {
    235235                closesocket( jd->fd );
  • protocols/jabber/iq.c

    r0fbd3a6d r793cc25  
    5050        else if( strcmp( type, "get" ) == 0 )
    5151        {
    52                 if( !( ( c = xt_find_node( node->children, "query" ) ) ||
    53                        ( c = xt_find_node( node->children, "ping" ) ) ) || /* O_o WHAT is wrong with just <query/> ????? */
     52                if( !( c = xt_find_node( node->children, "query" ) ) ||
    5453                    !( s = xt_find_attr( c, "xmlns" ) ) )
    5554                {
     
    8281                        xt_add_child( reply, xt_new_node( "tz", buf, NULL ) );
    8382                }
    84                 else if( strcmp( s, XMLNS_PING ) == 0 )
    85                 {
    86                         xt_free_node( reply );
    87                         reply = jabber_make_packet( "iq", "result", xt_find_attr( node, "from" ), NULL );
    88                         if( ( s = xt_find_attr( node, "id" ) ) )
    89                                 xt_add_attr( reply, "id", s );
    90                         pack = 0;
    91                 }
    92                 else if( strcmp( s, XMLNS_DISCO_INFO ) == 0 )
     83                else if( strcmp( s, XMLNS_DISCOVER ) == 0 )
    9384                {
    9485                        const char *features[] = { XMLNS_VERSION,
     
    9687                                                   XMLNS_CHATSTATES,
    9788                                                   XMLNS_MUC,
    98                                                    XMLNS_PING,
    9989                                                   XMLNS_SI,
    10090                                                   XMLNS_BYTESTREAMS,
     
    575565        return st;
    576566}
    577 
    578 xt_status jabber_iq_parse_features( struct im_connection *ic, struct xt_node *node, struct xt_node *orig );
    579 
    580 xt_status jabber_iq_query_features( struct im_connection *ic, char *bare_jid )
    581 {
    582         struct xt_node *node, *query;
    583         struct jabber_buddy *bud;
    584        
    585         if( ( bud = jabber_buddy_by_jid( ic, bare_jid , 0 ) ) == NULL )
    586         {
    587                 /* Who cares about the unknown... */
    588                 imcb_log( ic, "Couldnt find the man: %s", bare_jid);
    589                 return 0;
    590         }
    591        
    592         if( bud->features ) /* been here already */
    593                 return XT_HANDLED;
    594        
    595         node = xt_new_node( "query", NULL, NULL );
    596         xt_add_attr( node, "xmlns", XMLNS_DISCO_INFO );
    597        
    598         if( !( query = jabber_make_packet( "iq", "get", bare_jid, node ) ) )
    599         {
    600                 imcb_log( ic, "WARNING: Couldn't generate feature query" );
    601                 xt_free_node( node );
    602         }
    603 
    604         jabber_cache_add( ic, query, jabber_iq_parse_features );
    605 
    606         return jabber_write_packet( ic, query );
    607 }
    608 
    609 xt_status jabber_iq_parse_features( struct im_connection *ic, struct xt_node *node, struct xt_node *orig )
    610 {
    611         struct xt_node *c;
    612         struct jabber_buddy *bud;
    613         char *feature;
    614 
    615         if( !( c = xt_find_node( node->children, "query" ) ) ||
    616             !( strcmp( xt_find_attr( c, "xmlns" ), XMLNS_DISCO_INFO ) == 0 ) )
    617         {
    618                 imcb_log( ic, "WARNING: Received incomplete IQ-result packet for discover" );
    619                 return XT_HANDLED;
    620         }
    621         if( ( bud = jabber_buddy_by_jid( ic, xt_find_attr( node, "from") , 0 ) ) == NULL )
    622         {
    623                 /* Who cares about the unknown... */
    624                 imcb_log( ic, "Couldnt find the man: %s", xt_find_attr( node, "from"));
    625                 return 0;
    626         }
    627        
    628         c = c->children;
    629         while( ( c = xt_find_node( c, "feature" ) ) ) {
    630                 feature = xt_find_attr( c, "var" );
    631                 bud->features = g_slist_append(bud->features, g_strdup(feature) );
    632                 c = c->next;
    633         }
    634 
    635         return XT_HANDLED;
    636 }
    637 
    638 xt_status jabber_iq_parse_server_features( struct im_connection *ic, struct xt_node *node, struct xt_node *orig );
    639 
    640 xt_status jabber_iq_query_server( struct im_connection *ic, char *jid, char *xmlns )
    641 {
    642         struct xt_node *node, *query;
    643         struct jabber_data *jd = ic->proto_data;
    644        
    645         node = xt_new_node( "query", NULL, NULL );
    646         xt_add_attr( node, "xmlns", xmlns );
    647        
    648         if( !( query = jabber_make_packet( "iq", "get", jid, node ) ) )
    649         {
    650                 imcb_log( ic, "WARNING: Couldn't generate server query" );
    651                 xt_free_node( node );
    652         }
    653 
    654         jd->have_streamhosts--;
    655         jabber_cache_add( ic, query, jabber_iq_parse_server_features );
    656 
    657         return jabber_write_packet( ic, query );
    658 }
    659 
    660 /*
    661  * Query the server for "items", query each "item" for identities, query each "item" that's a proxy for it's bytestream info
    662  */
    663 xt_status jabber_iq_parse_server_features( struct im_connection *ic, struct xt_node *node, struct xt_node *orig )
    664 {
    665         struct xt_node *c;
    666         struct jabber_data *jd = ic->proto_data;
    667 
    668         if( !( c = xt_find_node( node->children, "query" ) ) ||
    669             !xt_find_attr( node, "from" ) )
    670         {
    671                 imcb_log( ic, "WARNING: Received incomplete IQ-result packet for discover" );
    672                 return XT_HANDLED;
    673         }
    674 
    675         jd->have_streamhosts++;
    676 
    677         if( strcmp( xt_find_attr( c, "xmlns" ), XMLNS_DISCO_ITEMS ) == 0 )
    678         {
    679                 char *item, *itemjid;
    680 
    681                 /* answer from server */
    682        
    683                 c = c->children;
    684                 while( ( c = xt_find_node( c, "item" ) ) )
    685                 {
    686                         item = xt_find_attr( c, "name" );
    687                         itemjid = xt_find_attr( c, "jid" );
    688 
    689                         jabber_iq_query_server( ic, itemjid, XMLNS_DISCO_INFO );
    690 
    691                         c = c->next;
    692                 }
    693         } else if( strcmp( xt_find_attr( c, "xmlns" ), XMLNS_DISCO_INFO ) == 0 )
    694         {
    695                 char *category, *type;
    696 
    697                 /* answer from potential proxy */
    698 
    699                 c = c->children;
    700                 while( ( c = xt_find_node( c, "identity" ) ) )
    701                 {
    702                         category = xt_find_attr( c, "category" );
    703                         type = xt_find_attr( c, "type" );
    704 
    705                         if( type && ( strcmp( type, "bytestreams" ) == 0 ) &&
    706                             category && ( strcmp( category, "proxy" ) == 0 ) )
    707                                 jabber_iq_query_server( ic, xt_find_attr( node, "from" ), XMLNS_BYTESTREAMS );
    708 
    709                         c = c->next;
    710                 }
    711         } else if( strcmp( xt_find_attr( c, "xmlns" ), XMLNS_BYTESTREAMS ) == 0 )
    712         {
    713                 char *host, *jid;
    714                 int port;
    715 
    716                 /* answer from proxy */
    717 
    718                 if( ( c = xt_find_node( c->children, "streamhost" ) ) &&
    719                     ( host = xt_find_attr( c, "host" ) ) &&
    720                     ( port = atoi( xt_find_attr( c, "port" ) ) ) &&
    721                     ( jid = xt_find_attr( c, "jid" ) ) )
    722                 {
    723                         jabber_streamhost_t *sh = g_new0( jabber_streamhost_t, 1 );
    724                         sh->jid = g_strdup( jid );
    725                         sh->host = g_strdup( host );
    726                         sprintf( sh->port, "%u", port );
    727 
    728                         imcb_log( ic, "Proxy found: jid %s host %s port %u", jid, host, port );
    729                         jd->streamhosts = g_slist_append( jd->streamhosts, sh );
    730                 }
    731         }
    732 
    733         if( jd->have_streamhosts == 0 )
    734                 jd->have_streamhosts++;
    735         return XT_HANDLED;
    736 }
  • protocols/jabber/jabber.c

    r0fbd3a6d r793cc25  
    7676        jd->username = g_strdup( acc->user );
    7777        jd->server = strchr( jd->username, '@' );
    78        
    79         jd->fd = jd->r_inpa = jd->w_inpa = -1;
    8078       
    8179        if( jd->server == NULL )
     
    234232        struct jabber_data *jd = ic->proto_data;
    235233       
    236         if( jd->fd >= 0 )
    237                 jabber_end_stream( ic );
     234        jabber_end_stream( ic );
    238235       
    239236        while( ic->groupchats )
     
    253250                g_free( jd->txq );
    254251       
    255         if( jd->node_cache )
    256                 g_hash_table_destroy( jd->node_cache );
     252        g_hash_table_destroy( jd->node_cache );
    257253       
    258254        xt_free( jd->xt );
     
    425421        if( c )
    426422                jabber_chat_leave( c, NULL );
    427 }
    428 
    429 static void jabber_chat_invite_( struct groupchat *c, char *who, char *msg )
    430 {
    431         struct jabber_chat *jc = c->data;
    432         gchar *msg_alt = NULL;
    433 
    434         if( msg == NULL )
    435                 msg_alt = g_strdup_printf( "%s invited you to %s", c->ic->acc->user, jc->name );
    436        
    437         if( c && who )
    438                 jabber_chat_invite( c, who, msg ? msg : msg_alt );
    439        
    440         g_free( msg_alt );
    441423}
    442424
     
    512494        ret->chat_msg = jabber_chat_msg_;
    513495        ret->chat_topic = jabber_chat_topic_;
    514         ret->chat_invite = jabber_chat_invite_;
     496//      ret->chat_invite = jabber_chat_invite;
    515497        ret->chat_leave = jabber_chat_leave_;
    516498        ret->chat_join = jabber_chat_join_;
  • protocols/jabber/jabber.h

    r0fbd3a6d r793cc25  
    5757} jabber_buddy_flags_t;
    5858
    59 /* Stores a streamhost's(a.k.a. proxy) data */
    60 typedef struct
    61 {
    62         char *jid;
    63         char *host;
    64         char port[6];
    65 } jabber_streamhost_t;
    66 
    6759struct jabber_data
    6860{
     
    9183
    9284        GSList *filetransfers;
    93         GSList *streamhosts;
    94         int have_streamhosts;
    9585};
    9686
     
    121111        struct jabber_away_state *away_state;
    122112        char *away_message;
    123         GSList *features;
    124113       
    125114        time_t last_act;
     
    189178#define XMLNS_VERSION      "jabber:iq:version"                                   /* XEP-0092 */
    190179#define XMLNS_TIME         "jabber:iq:time"                                      /* XEP-0090 */
    191 #define XMLNS_PING         "urn:xmpp:ping"                                       /* XEP-0199 */
    192180#define XMLNS_VCARD        "vcard-temp"                                          /* XEP-0054 */
    193181#define XMLNS_DELAY        "jabber:x:delay"                                      /* XEP-0091 */
    194182#define XMLNS_XDATA        "jabber:x:data"                                       /* XEP-0004 */
    195183#define XMLNS_CHATSTATES   "http://jabber.org/protocol/chatstates"               /* XEP-0085 */
    196 #define XMLNS_DISCO_INFO   "http://jabber.org/protocol/disco#info"               /* XEP-0030 */
    197 #define XMLNS_DISCO_ITEMS  "http://jabber.org/protocol/disco#items"              /* XEP-0030 */
     184#define XMLNS_DISCOVER     "http://jabber.org/protocol/disco#info"               /* XEP-0030 */
    198185#define XMLNS_MUC          "http://jabber.org/protocol/muc"                      /* XEP-0045 */
    199186#define XMLNS_MUC_USER     "http://jabber.org/protocol/muc#user"                 /* XEP-0045 */
     
    212199int jabber_add_to_roster( struct im_connection *ic, char *handle, char *name );
    213200int jabber_remove_from_roster( struct im_connection *ic, char *handle );
    214 xt_status jabber_iq_query_features( struct im_connection *ic, char *bare_jid );
    215 xt_status jabber_iq_query_server( struct im_connection *ic, char *jid, char *xmlns );
    216201
    217202/* si.c */
     
    294279void jabber_chat_pkt_presence( struct im_connection *ic, struct jabber_buddy *bud, struct xt_node *node );
    295280void jabber_chat_pkt_message( struct im_connection *ic, struct jabber_buddy *bud, struct xt_node *node );
    296 void jabber_chat_invite( struct groupchat *c, char *who, char *message );
    297281
    298282#endif
  • protocols/jabber/s5bytestream.c

    r0fbd3a6d r793cc25  
    3030        struct jabber_transfer *tf;
    3131
    32         jabber_streamhost_t *sh;
    33         GSList *streamhosts;
     32        /* <query> element and <streamhost> elements */
     33        struct xt_node *qnode, *shnode;
    3434
    3535        enum
     
    7474gboolean jabber_bs_abort( struct bs_transfer *bt, char *format, ... );
    7575void jabber_bs_canceled( file_transfer_t *ft , char *reason );
    76 void jabber_bs_free_transfer( file_transfer_t *ft );
     76void jabber_bs_free_transfer( file_transfer_t *ft);
    7777gboolean jabber_bs_connect_timeout( gpointer data, gint fd, b_input_condition cond );
    7878gboolean jabber_bs_poll( struct bs_transfer *bt, int fd, short *revents );
     
    8484gboolean jabber_bs_recv_handshake( gpointer data, gint fd, b_input_condition cond );
    8585gboolean jabber_bs_recv_handshake_abort( struct bs_transfer *bt, char *error );
    86 int jabber_bs_recv_request( struct im_connection *ic, struct xt_node *node, struct xt_node *qnode );
     86int jabber_bs_recv_request( struct im_connection *ic, struct xt_node *node, struct xt_node *qnode);
    8787
    8888gboolean jabber_bs_send_handshake_abort( struct bs_transfer *bt, char *error );
    89 gboolean jabber_bs_send_request( struct jabber_transfer *tf, GSList *streamhosts );
     89gboolean jabber_bs_send_request( struct jabber_transfer *tf, char *host, char *port );
    9090gboolean jabber_bs_send_handshake( gpointer data, gint fd, b_input_condition cond );
    9191gboolean jabber_bs_send_listen( struct bs_transfer *bt, struct sockaddr_storage *saddr, char *host, char *port );
    92 static xt_status jabber_bs_send_handle_activate( struct im_connection *ic, struct xt_node *node, struct xt_node *orig );
    93 void jabber_bs_send_activate( struct bs_transfer *bt );
    9492
    9593/*
     
    9997        struct jabber_transfer *tf = ft->data;
    10098        struct bs_transfer *bt = tf->streamhandle;
    101         jabber_streamhost_t *sh;
    10299
    103100        if ( tf->watch_in )
     
    108105       
    109106        g_free( bt->pseudoadr );
    110 
    111         while( bt->streamhosts )
    112         {
    113                 sh = bt->streamhosts->data;
    114                 bt->streamhosts = g_slist_remove( bt->streamhosts, sh );
    115                 g_free( sh->jid );
    116                 g_free( sh->host );
    117                 g_free( sh );
    118         }
    119        
     107        xt_free_node( bt->qnode );
    120108        g_free( bt );
    121109
     
    123111}
    124112
    125 /*
    126  * Checks if buflen data is available on the socket and
    127  * writes it to buffer if that's the case.
    128  */
    129113gboolean jabber_bs_peek( struct bs_transfer *bt, void *buffer, int buflen )
    130114{
     
    163147}
    164148
    165 /*
    166  * Polls the socket, checks for errors and removes a connect timer
    167  * if there is one.
    168  */
    169149gboolean jabber_bs_poll( struct bs_transfer *bt, int fd, short *revents )
    170150{
     
    201181}
    202182
    203 /*
    204  * Used for receive and send path.
    205  */
    206183gboolean jabber_bs_abort( struct bs_transfer *bt, char *format, ... )
    207184{
     
    214191        va_end( params );
    215192        if( bt->tf->ft->sending )
     193                return jabber_bs_recv_handshake_abort( bt, error );
     194        else
    216195                return jabber_bs_send_handshake_abort( bt, error );
    217         else
    218                 return jabber_bs_recv_handshake_abort( bt, error );
    219196}
    220197
     
    237214        GSList *tflist;
    238215        struct bs_transfer *bt;
    239         GSList *shlist=NULL;
    240         struct xt_node *shnode;
    241216
    242217        sha1_state_t sha;
     
    258233        {
    259234                imcb_log( ic, "WARNING: Received SI Request for unsupported bytestream mode %s", xt_find_attr( qnode, "mode" ) );
    260                 return XT_HANDLED;
    261         }
    262 
    263         shnode = qnode->children;
    264         while( ( shnode = xt_find_node( shnode, "streamhost" ) ) )
    265         {
    266                 char *jid, *host;
    267                 int port;
    268                 if( ( jid = xt_find_attr( shnode, "jid" ) ) &&
    269                     ( host = xt_find_attr( shnode, "host" ) ) &&
    270                     ( ( port = atoi( xt_find_attr( shnode, "port" ) ) ) ) )
    271                 {
    272                         jabber_streamhost_t *sh = g_new0( jabber_streamhost_t, 1 );
    273                         sh->jid = g_strdup(jid);
    274                         sh->host = g_strdup(host);
    275                         sprintf( sh->port, "%u", port );
    276                         shlist = g_slist_append( shlist, sh );
    277                 }
    278                 shnode = shnode->next;
    279         }
    280        
    281         if( !shlist )
    282         {
    283                 imcb_log( ic, "WARNING: Received incomplete SI bytestream request, no parseable streamhost entries");
    284235                return XT_HANDLED;
    285236        }
     
    323274        bt = g_new0( struct bs_transfer, 1 );
    324275        bt->tf = tf;
    325         bt->streamhosts = shlist;
    326         bt->sh = shlist->data;
     276        bt->qnode = xt_dup( qnode );
     277        bt->shnode = bt->qnode->children;
    327278        bt->phase = BS_PHASE_CONNECT;
    328279        bt->pseudoadr = g_strdup( hash_hex );
     
    334285        return XT_HANDLED;
    335286}
    336 
    337287/*
    338288 * This is what a protocol handshake can look like in cooperative multitasking :)
     
    355305        case BS_PHASE_CONNECT:
    356306                {
     307                        struct xt_node *c;
     308                        char *host, *port;
    357309                        struct addrinfo hints, *rp;
    358310
    359                         memset( &hints, 0, sizeof( struct addrinfo ) );
    360                         hints.ai_socktype = SOCK_STREAM;
    361 
    362                         if ( getaddrinfo( bt->sh->host, bt->sh->port, &hints, &rp ) != 0 )
    363                                 return jabber_bs_abort( bt, "getaddrinfo() failed: %s", strerror( errno ) );
    364 
    365                         ASSERTSOCKOP( bt->tf->fd = fd = socket( rp->ai_family, rp->ai_socktype, 0 ), "Opening socket" );
    366 
    367                         sock_make_nonblocking( fd );
    368 
    369                         imcb_log( bt->tf->ic, "File %s: Connecting to streamhost %s:%s", bt->tf->ft->file_name, bt->sh->host, bt->sh->port );
    370 
    371                         if( ( connect( fd, rp->ai_addr, rp->ai_addrlen ) == -1 ) &&
    372                             ( errno != EINPROGRESS ) )
    373                                 return jabber_bs_abort( bt , "connect() failed: %s", strerror( errno ) );
    374 
    375                         freeaddrinfo( rp );
    376 
    377                         bt->phase = BS_PHASE_CONNECTED;
    378                        
    379                         bt->tf->watch_out = b_input_add( fd, GAIM_INPUT_WRITE, jabber_bs_recv_handshake, bt );
    380 
    381                         /* since it takes forever(3mins?) till connect() fails on itself we schedule a timeout */
    382                         bt->connect_timeout = b_timeout_add( JABBER_BS_CONTIMEOUT * 1000, jabber_bs_connect_timeout, bt );
    383 
    384                         bt->tf->watch_in = 0;
    385                         return FALSE;
     311                        if( ( c = bt->shnode = xt_find_node( bt->shnode, "streamhost" ) ) &&
     312                            ( port = xt_find_attr( c, "port" ) ) &&
     313                            ( host = xt_find_attr( c, "host" ) ) &&
     314                            xt_find_attr( c, "jid" ) )
     315                        {
     316                                memset( &hints, 0, sizeof( struct addrinfo ) );
     317                                hints.ai_socktype = SOCK_STREAM;
     318
     319                                if ( getaddrinfo( host, port, &hints, &rp ) != 0 )
     320                                        return jabber_bs_abort( bt, "getaddrinfo() failed: %s", strerror( errno ) );
     321
     322                                ASSERTSOCKOP( bt->tf->fd = fd = socket( rp->ai_family, rp->ai_socktype, 0 ), "Opening socket" );
     323
     324                                sock_make_nonblocking( fd );
     325
     326                                imcb_log( bt->tf->ic, "File %s: Connecting to streamhost %s:%s", bt->tf->ft->file_name, host, port );
     327
     328                                if( ( connect( fd, rp->ai_addr, rp->ai_addrlen ) == -1 ) &&
     329                                    ( errno != EINPROGRESS ) )
     330                                        return jabber_bs_abort( bt , "connect() failed: %s", strerror( errno ) );
     331
     332                                freeaddrinfo( rp );
     333
     334                                bt->phase = BS_PHASE_CONNECTED;
     335                               
     336                                bt->tf->watch_out = b_input_add( fd, GAIM_INPUT_WRITE, jabber_bs_recv_handshake, bt );
     337
     338                                /* since it takes forever(3mins?) till connect() fails on itself we schedule a timeout */
     339                                bt->connect_timeout = b_timeout_add( JABBER_BS_CONTIMEOUT * 1000, jabber_bs_connect_timeout, bt );
     340
     341                                bt->tf->watch_in = 0;
     342                                return FALSE;
     343                        } else
     344                                return jabber_bs_abort( bt, c ? "incomplete streamhost entry: host=%s port=%s jid=%s" : NULL,
     345                                                                  host, port, xt_find_attr( c, "jid" ) );
    386346                }
    387347        case BS_PHASE_CONNECTED:
     
    462422                                        socks5_reply.addrlen);
    463423
    464                         if( bt->tf->ft->sending )
    465                                 jabber_bs_send_activate( bt );
    466                         else
    467                                 jabber_bs_recv_answer_request( bt );
     424                        jabber_bs_recv_answer_request( bt );
    468425
    469426                        return FALSE;
     
    490447        struct jabber_transfer *tf = bt->tf;
    491448        struct xt_node *reply, *iqnode;
    492         GSList *shlist;
    493 
    494         imcb_log( tf->ic, "Transferring file %s: connection to streamhost %s:%s failed (%s)",
    495                   tf->ft->file_name,
    496                   bt->sh->host,
    497                   bt->sh->port,
    498                   error );
    499 
    500         /* Alright, this streamhost failed, let's try the next... */
    501         bt->phase = BS_PHASE_CONNECT;
    502         shlist = g_slist_find( bt->streamhosts, bt->sh );
    503         if( shlist && shlist->next )
    504         {
    505                 bt->sh = shlist->next->data;
    506                 return jabber_bs_recv_handshake( bt, 0, 0 );
    507         }
    508 
     449
     450        if( bt->shnode )
     451        {
     452                imcb_log( tf->ic, "Transferring file %s: connection to streamhost %s:%s failed (%s)",
     453                          tf->ft->file_name,
     454                          xt_find_attr( bt->shnode, "host" ),
     455                          xt_find_attr( bt->shnode, "port" ),
     456                          error );
     457
     458                /* Alright, this streamhost failed, let's try the next... */
     459                bt->phase = BS_PHASE_CONNECT;
     460                bt->shnode = bt->shnode->next;
     461               
     462                /* the if is not neccessary but saves us one recursion */
     463                if( bt->shnode )
     464                        return jabber_bs_recv_handshake( bt, 0, 0 );
     465        }
    509466
    510467        /* out of stream hosts */
     
    538495        imcb_log( tf->ic, "File %s: established SOCKS5 connection to %s:%s",
    539496                  tf->ft->file_name,
    540                   bt->sh->host,
    541                   bt->sh->port );
     497                  xt_find_attr( bt->shnode, "host" ),
     498                  xt_find_attr( bt->shnode, "port" ) );
    542499
    543500        tf->ft->data = tf;
     501        tf->ft->started = time( NULL );
    544502        tf->watch_in = b_input_add( tf->fd, GAIM_INPUT_READ, jabber_bs_recv_read, bt );
    545503        tf->ft->write_request = jabber_bs_recv_write_request;
    546504
    547505        reply = xt_new_node( "streamhost-used", NULL, NULL );
    548         xt_add_attr( reply, "jid", bt->sh->jid );
     506        xt_add_attr( reply, "jid", xt_find_attr( bt->shnode, "jid" ) );
    549507
    550508        reply = xt_new_node( "query", NULL, reply );
     
    593551                return jabber_bs_abort( bt, "Remote end closed connection" );
    594552       
    595         if( tf->bytesread == 0 )
    596                 tf->ft->started = time( NULL );
    597 
    598553        tf->bytesread += ret;
    599554
     
    648603                return jabber_bs_abort( bt, "BUG: write() called while watching " );
    649604       
    650         /* TODO: catch broken pipe */
    651605        ASSERTSOCKOP( ret = send( tf->fd, buffer, len, 0 ), "Sending" );
    652 
    653         if( tf->byteswritten == 0 )
    654                 tf->ft->started = time( NULL );
    655606
    656607        tf->byteswritten += ret;
     
    714665        tf->accepted = TRUE;
    715666
    716         if( strcmp( jid, tf->ini_jid ) == 0 )
    717         {
    718                 /* we're streamhost and target */
    719                 if( bt->phase == BS_PHASE_REPLY )
    720                 {
    721                         /* handshake went through, let's start transferring */
    722                         tf->ft->write_request( tf->ft );
    723                 }
    724         } else
    725         {
    726                 /* using a proxy */
    727                 GSList *shlist;
    728                 for( shlist = jd->streamhosts ; shlist ; shlist = g_slist_next( shlist ) )
    729                 {
    730                         jabber_streamhost_t *sh = shlist->data;
    731                         if( strcmp( sh->jid, jid ) == 0 )
    732                         {
    733                                 bt->sh = sh;
    734                                 jabber_bs_recv_handshake( bt, 0, 0 );
    735                                 return XT_HANDLED;
    736                         }
    737                 }
    738 
    739                 imcb_log( ic, "WARNING: Received SOCKS5 bytestream reply with unknown streamhost %s", jid );
     667        if( bt->phase == BS_PHASE_REPLY )
     668        {
     669                /* handshake went through, let's start transferring */
     670                tf->ft->started = time( NULL );
     671                tf->ft->write_request( tf->ft );
    740672        }
    741673
     
    743675}
    744676
    745 /*
    746  * Tell the proxy to activate the stream. Looks like this:
    747  *
    748  * <iq type=set>
    749  *      <query xmlns=bs sid=sid>
    750  *              <activate>tgt_jid</activate>
    751  *      </query>
    752  * </iq>
    753  */
    754 void jabber_bs_send_activate( struct bs_transfer *bt )
    755 {
    756         struct xt_node *node;
    757 
    758         node = xt_new_node( "activate", bt->tf->tgt_jid, NULL );
    759         node = xt_new_node( "query", NULL, node );
    760         xt_add_attr( node, "xmlns", XMLNS_BYTESTREAMS );
    761         xt_add_attr( node, "sid", bt->tf->sid );
    762         node = jabber_make_packet( "iq", "set", bt->sh->jid, node );
    763 
    764         jabber_cache_add( bt->tf->ic, node, jabber_bs_send_handle_activate );
    765 
    766         jabber_write_packet( bt->tf->ic, node );
    767 }
    768 
    769 /*
    770  * The proxy has activated the bytestream.
    771  * We can finally start pushing some data out.
    772  */
    773 static xt_status jabber_bs_send_handle_activate( struct im_connection *ic, struct xt_node *node, struct xt_node *orig )
    774 {
    775         char *sid;
    776         GSList *tflist;
    777         struct jabber_transfer *tf;
    778         struct xt_node *query;
    779         struct jabber_data *jd = ic->proto_data;
    780 
    781         query = xt_find_node( orig->children, "query" );
    782         sid = xt_find_attr( query, "sid" );
    783 
    784         for( tflist = jd->filetransfers ; tflist; tflist = g_slist_next(tflist) )
    785         {
    786                 struct jabber_transfer *tft = tflist->data;
    787                 if( ( strcmp( tft->sid, sid ) == 0 ) )
    788                 {
    789                         tf = tft;
    790                         break;
    791                 }
    792         }
    793 
    794         if( !tf )
    795         {
    796                 imcb_log( ic, "WARNING: Received SOCKS5 bytestream activation for unknown stream" );
    797                 return XT_HANDLED;
    798         }
    799 
    800         /* handshake went through, let's start transferring */
    801         tf->ft->write_request( tf->ft );
    802 
    803         return XT_HANDLED;
    804 }
    805 
    806 /*
    807  * Starts a bytestream.
    808  */
    809677gboolean jabber_bs_send_start( struct jabber_transfer *tf )
    810678{
    811         char host[INET6_ADDRSTRLEN];
     679        char host[INET6_ADDRSTRLEN], port[6];
    812680        struct bs_transfer *bt;
    813681        sha1_state_t sha;
    814682        char hash_hex[41];
    815683        unsigned char hash[20];
    816         int i,ret;
    817         struct jabber_data *jd = tf->ic->proto_data;
    818         jabber_streamhost_t sh;
    819         GSList *streamhosts = jd->streamhosts;
     684        int i;
    820685
    821686        /* SHA1( SID + Initiator JID + Target JID ) is given to the streamhost which it will match against the initiator's value */
     
    837702        tf->ft->canceled = jabber_bs_canceled;
    838703
    839         if ( !jabber_bs_send_listen( bt, &tf->saddr, sh.host = host, sh.port ) )
     704        if ( !jabber_bs_send_listen( bt, &tf->saddr, host, port ) )
    840705                return FALSE;
    841706
    842707        bt->tf->watch_in = b_input_add( tf->fd, GAIM_INPUT_READ, jabber_bs_send_handshake, bt );
    843708        bt->connect_timeout = b_timeout_add( JABBER_BS_LISTEN_TIMEOUT * 1000, jabber_bs_connect_timeout, bt );
    844 
    845         sh.jid = tf->ini_jid;
    846 
    847         /* temporarily add listen address to streamhosts, send the request and remove it */
    848         streamhosts = g_slist_prepend( streamhosts, &sh );
    849         ret = jabber_bs_send_request( tf, streamhosts);
    850         streamhosts = g_slist_remove( streamhosts, &sh );
    851 
    852         return ret;
    853 }
    854 
    855 gboolean jabber_bs_send_request( struct jabber_transfer *tf, GSList *streamhosts )
    856 {
    857         struct xt_node *shnode, *query, *iq;
     709        return jabber_bs_send_request( tf, host, port );
     710}
     711
     712gboolean jabber_bs_send_request( struct jabber_transfer *tf, char *host, char *port )
     713{
     714        struct xt_node *sh, *query, *iq;
     715
     716        sh = xt_new_node( "streamhost", NULL, NULL );
     717        xt_add_attr( sh, "jid", tf->ini_jid );
     718        xt_add_attr( sh, "host", host );
     719        xt_add_attr( sh, "port", port );
    858720
    859721        query = xt_new_node( "query", NULL, NULL );
     
    861723        xt_add_attr( query, "sid", tf->sid );
    862724        xt_add_attr( query, "mode", "tcp" );
    863 
    864         while( streamhosts ) {
    865                 jabber_streamhost_t *sh = streamhosts->data;
    866                 shnode = xt_new_node( "streamhost", NULL, NULL );
    867                 xt_add_attr( shnode, "jid", sh->jid );
    868                 xt_add_attr( shnode, "host", sh->host );
    869                 xt_add_attr( shnode, "port", sh->port );
    870 
    871                 xt_add_child( query, shnode );
    872 
    873                 streamhosts = g_slist_next( streamhosts );
    874         }
    875 
     725        xt_add_child( query, sh );
    876726
    877727        iq = jabber_make_packet( "iq", "set", tf->tgt_jid, query );
     
    889739        struct jabber_transfer *tf = bt->tf;
    890740
    891         /* TODO: did the receiver get here somehow??? */
    892741        imcb_log( tf->ic, "Transferring file %s: SOCKS5 handshake failed: %s",
    893742                  tf->ft->file_name,
     
    1052901                        {
    1053902                                /* streamhost-used message came already in(possible?), let's start sending */
     903                                tf->ft->started = time( NULL );
    1054904                                tf->ft->write_request( tf->ft );
    1055905                        }
  • protocols/jabber/si.c

    r0fbd3a6d r793cc25  
    8383        struct jabber_transfer *tf;
    8484        struct jabber_data *jd = ic->proto_data;
    85         char *server  = jd->server;
    8685
    8786        imcb_log( ic, "Trying to send %s(%zd bytes) to %s", ft->file_name, ft->file_size, who );
     
    9897        jd->filetransfers = g_slist_prepend( jd->filetransfers, tf );
    9998
    100         /* query the buddy's features */
    101         jabber_iq_query_features( ic, who );
    102 
    103         /* query proxies from the server */
    104         if( !jd->have_streamhosts )
    105                 jabber_iq_query_server( ic, server, XMLNS_DISCO_ITEMS );
    106 
    107         /* send the request to our buddy */
    10899        jabber_si_send_request( ic, who, tf );
    109100
    110         /* and start the receive logic */
    111101        imcb_file_recv_start( ft );
    112102}
  • protocols/msn/msn.c

    r0fbd3a6d r793cc25  
    241241}
    242242
    243 static void msn_chat_invite( struct groupchat *c, char *who, char *message )
     243static void msn_chat_invite( struct groupchat *c, char *msg, char *who )
    244244{
    245245        struct msn_switchboard *sb = msn_sb_by_chat( c );
  • protocols/oscar/aim.h

    r0fbd3a6d r793cc25  
    9494 *
    9595 */
    96 #define AIM_DEFAULT_LOGIN_SERVER "login.messaging.aol.com"
     96#define AIM_DEFAULT_LOGIN_SERVER "login.oscar.aol.com"
    9797#define AIM_LOGIN_PORT 5190
    9898
  • protocols/oscar/oscar.c

    r0fbd3a6d r793cc25  
    341341        set_t *s;
    342342       
    343         s = set_add( &acc->set, "server", AIM_DEFAULT_LOGIN_SERVER, set_eval_account, acc );
     343        s = set_add( &acc->set, "server", NULL, set_eval_account, acc );
    344344        s->flags |= ACC_SET_NOSAVE | ACC_SET_OFFLINE_ONLY;
    345345       
     
    356356        struct oscar_data *odata = ic->proto_data = g_new0(struct oscar_data, 1);
    357357
    358         if (!isdigit(acc->user[0])) {
     358        if (isdigit(acc->user[0])) {
     359                odata->icq = TRUE;
     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... </bitlbee> */
     363                /* ic->acc->pass[8] = 0;
     364                   Not touching this anymore now that it belongs to account_t!
     365                   Let's hope nothing will break. ;-) */
     366        } else {
    359367                ic->flags |= OPT_DOES_HTML;
    360368        }
     
    377385        }
    378386       
     387        if (acc->server == NULL) {
     388                imcb_error(ic, "No servername specified");
     389                imc_logout(ic, FALSE);
     390                return;
     391        }
     392       
     393        if (g_strcasecmp(acc->server, "login.icq.com") != 0 &&
     394            g_strcasecmp(acc->server, "login.oscar.aol.com") != 0) {
     395                imcb_log(ic, "Warning: Unknown OSCAR server: `%s'. Please review your configuration if the connection fails.",acc->server);
     396        }
     397       
    379398        imcb_log(ic, _("Signon: %s"), ic->acc->user);
    380399
     
    383402
    384403        conn->status |= AIM_CONN_STATUS_INPROGRESS;
    385         conn->fd = proxy_connect(set_getstr(&acc->set, "server"),
    386                                  AIM_LOGIN_PORT, oscar_login_connect, ic);
     404        conn->fd = proxy_connect(acc->server, AIM_LOGIN_PORT, oscar_login_connect, ic);
    387405        if (conn->fd < 0) {
    388406                imcb_error(ic, _("Couldn't connect to host"));
     
    24912509}
    24922510
    2493 void oscar_chat_invite(struct groupchat *c, char *who, char *message)
     2511void oscar_chat_invite(struct groupchat *c, char *message, char *who)
    24942512{
    24952513        struct im_connection *ic = c->ic;
  • protocols/yahoo/yahoo.c

    r0fbd3a6d r793cc25  
    306306}
    307307
    308 static void byahoo_chat_invite( struct groupchat *c, char *who, char *msg )
     308static void byahoo_chat_invite( struct groupchat *c, char *msg, char *who )
    309309{
    310310        struct byahoo_data *yd = (struct byahoo_data *) c->ic->proto_data;
  • root_commands.c

    r0fbd3a6d r793cc25  
    199199                break;
    200200        default:
    201                 irc_usermsg( irc, "Error: `%d'", status );
     201                irc_usermsg( irc, "Error: '%d'", status );
    202202                break;
    203203        }
     
    234234                a = account_add( irc, prpl, cmd[3], cmd[4] );
    235235                if( cmd[5] )
    236                 {
    237                         irc_usermsg( irc, "Warning: Passing a servername/other flags to `account add' "
    238                                           "is now deprecated. Use `account set' instead." );
    239236                        set_setstr( &a->set, "server", cmd[5] );
    240                 }
    241237               
    242238                irc_usermsg( irc, "Account successfully added" );
     
    321317                        else
    322318                        {
    323                                 irc_usermsg( irc, "No accounts known. Use `account add' to add one." );
     319                                irc_usermsg( irc, "No accounts known. Use 'account add' to add one." );
    324320                        }
    325321                }
     
    407403                        }
    408404                       
    409                         if( g_strncasecmp( cmd[2], "-del", 4 ) == 0 )
     405                        if( ( strcmp( cmd[3], "=" ) ) == 0 && cmd[4] )
     406                                irc_usermsg( irc, "Warning: Correct syntax: \002account set <variable> <value>\002 (without =)" );
     407                        else if( g_strncasecmp( cmd[2], "-del", 4 ) == 0 )
    410408                                set_reset( &a->set, set_name );
    411409                        else
     
    747745static void cmd_set( irc_t *irc, char **cmd )
    748746{
    749         char *set_name = cmd[1];
     747        char *set_name = NULL;
    750748       
    751749        if( cmd[1] && cmd[2] )
    752750        {
    753                 if( g_strncasecmp( cmd[1], "-del", 4 ) == 0 )
     751                if( ( strcmp( cmd[2], "=" ) ) == 0 && cmd[3] )
     752                {
     753                        irc_usermsg( irc, "Warning: Correct syntax: \002set <variable> <value>\002 (without =)" );
     754                        return;
     755                }
     756                else if( g_strncasecmp( cmd[1], "-del", 4 ) == 0 )
    754757                {
    755758                        set_reset( &irc->set, cmd[2] );
     
    759762                {
    760763                        set_setstr( &irc->set, cmd[1], cmd[2] );
     764                        set_name = cmd[1];
    761765                }
    762766        }
  • tests/check_nick.c

    r0fbd3a6d r793cc25  
    1515                "thisisave:ryveryveryverylongnick",
    1616                "t::::est",
    17                 "test123",
    18                 "123test",
    19                 "123",
    2017                NULL };
    2118        const char *expected[] = { "test", "test", "test",
     
    2320                "thisisaveryveryveryveryl",
    2421                "test",
    25                 "test123",
    26                 "_123test",
    27                 "_123",
    2822                NULL };
    2923
     
    4135START_TEST(test_nick_ok_ok)
    4236{
    43         const char *nicks[] = { "foo", "bar123", "bla[", "blie]", "BreEZaH",
    44                                 "\\od^~", "_123", "_123test", NULL };
     37        const char *nicks[] = { "foo", "bar", "bla[", "blie]",
     38                                    "BreEZaH", "\\od^~", NULL };
    4539        int i;
    4640
     
    5549{
    5650        const char *nicks[] = { "thisisaveryveryveryveryveryveryverylongnick",
    57                                     "\nillegalchar", "", "nick%", "123test", NULL };
     51                                    "\nillegalchar", "", "nick%", NULL };
    5852        int i;
    5953
Note: See TracChangeset for help on using the changeset viewer.