Changeset bae0617


Ignore:
Timestamp:
2010-09-03T21:24:58Z (10 years ago)
Author:
Wilmer van der Gaast <wilmer@…>
Branches:
master
Children:
4aa8a04
Parents:
64768d4
Message:

Rearrange things a bit to support multiple NS connections. This is apparently
needed for refreshing auth. tokens.

Location:
protocols/msn
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • protocols/msn/msn.c

    r64768d4 rbae0617  
    5353       
    5454        ic->proto_data = md;
    55         md->fd = -1;
    5655       
    5756        if( strchr( acc->user, '@' ) == NULL )
     
    6261        }
    6362       
    64         imcb_log( ic, "Connecting" );
    65        
    66         md->fd = proxy_connect( "messenger.hotmail.com", 1863, msn_ns_connected, ic );
    67         if( md->fd < 0 )
    68         {
    69                 imcb_error( ic, "Could not connect to server" );
    70                 imc_logout( ic, TRUE );
    71                 return;
    72         }
    73        
    7463        md->ic = ic;
    7564        md->away_state = msn_away_state_list;
    7665        md->domaintree = g_tree_new( msn_domaintree_cmp );
    7766       
    78         msn_connections = g_slist_append( msn_connections, ic );
     67        msn_connections = g_slist_prepend( msn_connections, ic );
     68       
     69        imcb_log( ic, "Connecting" );
     70        msn_ns_connect( ic, md->ns, MSN_NS_HOST, MSN_NS_PORT );
    7971}
    8072
     
    9385                */
    9486               
    95                 if( md->fd >= 0 )
    96                         closesocket( md->fd );
    97                
    98                 if( md->handler )
    99                 {
    100                         if( md->handler->rxq ) g_free( md->handler->rxq );
    101                         if( md->handler->cmd_text ) g_free( md->handler->cmd_text );
    102                         g_free( md->handler );
    103                 }
     87                msn_ns_close( md->ns );
     88                msn_ns_close( md->auth );
    10489               
    10590                while( md->switchboards )
  • protocols/msn/msn.h

    r64768d4 rbae0617  
    4444*/
    4545
     46#define MSN_NS_HOST "messenger.hotmail.com"
     47#define MSN_NS_PORT 1863
     48
    4649/* Some other version.
    4750#define MSNP11_PROD_KEY "O4BG@C7BWLYQX?5G"
     
    8083} msn_flags_t;
    8184
     85struct msn_handler_data
     86{
     87        int fd, inpa;
     88        int rxlen;
     89        char *rxq;
     90       
     91        int msglen;
     92        char *cmd_text;
     93       
     94        /* Either ic or sb */
     95        gpointer data;
     96       
     97        int (*exec_command) ( struct msn_handler_data *handler, char **cmd, int count );
     98        int (*exec_message) ( struct msn_handler_data *handler, char *msg, int msglen, char **cmd, int count );
     99};
     100
    82101struct msn_data
    83102{
    84103        struct im_connection *ic;
    85104       
    86         int fd;
    87         struct msn_handler_data *handler;
     105        struct msn_handler_data ns[1], auth[1];
    88106        msn_flags_t flags;
    89107       
     
    111129        struct im_connection *ic;
    112130       
     131        /* The following two are also in the handler. TODO: Clean up. */
    113132        int fd;
    114133        gint inp;
     
    150169        char *who;
    151170        char *group;
    152 };
    153 
    154 struct msn_handler_data
    155 {
    156         int fd;
    157         int rxlen;
    158         char *rxq;
    159        
    160         int msglen;
    161         char *cmd_text;
    162        
    163         gpointer data;
    164        
    165         int (*exec_command) ( gpointer data, char **cmd, int count );
    166         int (*exec_message) ( gpointer data, char *msg, int msglen, char **cmd, int count );
    167171};
    168172
     
    209213/* ns.c */
    210214int msn_ns_write( struct im_connection *ic, int fd, const char *fmt, ... );
    211 gboolean msn_ns_connected( gpointer data, gint source, b_input_condition cond );
     215gboolean msn_ns_connect( struct im_connection *ic, struct msn_handler_data *handler, const char *host, int port );
     216void msn_ns_close( struct msn_handler_data *handler );
    212217void msn_auth_got_passport_token( struct im_connection *ic, const char *token, const char *error );
    213218void msn_auth_got_contact_list( struct im_connection *ic );
  • protocols/msn/msn_util.c

    r64768d4 rbae0617  
    351351                                        cmd = msn_linesplit( cmd_text );
    352352                                        for( count = 0; cmd[count]; count ++ );
    353                                         st = h->exec_command( h->data, cmd, count );
     353                                        st = h->exec_command( h, cmd, count );
    354354                                        g_free( cmd_text );
    355355                                       
     
    386386                        for( count = 0; cmd[count]; count ++ );
    387387                       
    388                         st = h->exec_message( h->data, msg, h->msglen, cmd, count );
     388                        st = h->exec_message( h, msg, h->msglen, cmd, count );
    389389                        g_free( msg );
    390390                        g_free( h->cmd_text );
  • protocols/msn/ns.c

    r64768d4 rbae0617  
    3131#include "xmltree.h"
    3232
     33static gboolean msn_ns_connected( gpointer data, gint source, b_input_condition cond );
    3334static gboolean msn_ns_callback( gpointer data, gint source, b_input_condition cond );
    34 static int msn_ns_command( gpointer data, char **cmd, int num_parts );
    35 static int msn_ns_message( gpointer data, char *msg, int msglen, char **cmd, int num_parts );
     35static int msn_ns_command( struct msn_handler_data *handler, char **cmd, int num_parts );
     36static int msn_ns_message( struct msn_handler_data *handler, char *msg, int msglen, char **cmd, int num_parts );
    3637
    3738static void msn_ns_send_adl_start( struct im_connection *ic );
     
    5152       
    5253        if( fd < 0 )
    53                 fd = md->fd;
     54                fd = md->ns->fd;
    5455       
    5556        if( getenv( "BITLBEE_DEBUG" ) )
     
    6970}
    7071
    71 gboolean msn_ns_connected( gpointer data, gint source, b_input_condition cond )
    72 {
    73         struct im_connection *ic = data;
    74         struct msn_data *md;
    75        
    76         if( !g_slist_find( msn_connections, ic ) )
    77                 return FALSE;
    78        
    79         if( source == -1 )
     72gboolean msn_ns_connect( struct im_connection *ic, struct msn_handler_data *handler, const char *host, int port )
     73{
     74        if( handler->fd >= 0 )
     75                closesocket( handler->fd );
     76       
     77        handler->exec_command = msn_ns_command;
     78        handler->exec_message = msn_ns_message;
     79        handler->data = ic;
     80        handler->fd = proxy_connect( host, port, msn_ns_connected, handler );
     81        if( handler->fd < 0 )
    8082        {
    8183                imcb_error( ic, "Could not connect to server" );
     
    8486        }
    8587       
     88        return TRUE;
     89}
     90
     91static gboolean msn_ns_connected( gpointer data, gint source, b_input_condition cond )
     92{
     93        struct msn_handler_data *handler = data;
     94        struct im_connection *ic = handler->data;
     95        struct msn_data *md;
     96       
     97        if( !g_slist_find( msn_connections, ic ) )
     98                return FALSE;
     99       
    86100        md = ic->proto_data;
    87101       
    88         if( !md->handler )
    89         {
    90                 md->handler = g_new0( struct msn_handler_data, 1 );
    91                 md->handler->data = ic;
    92                 md->handler->exec_command = msn_ns_command;
    93                 md->handler->exec_message = msn_ns_message;
    94         }
    95         else
    96         {
    97                 if( md->handler->rxq )
    98                         g_free( md->handler->rxq );
    99                
    100                 md->handler->rxlen = 0;
    101         }
    102        
    103         md->handler->fd = md->fd;
    104         md->handler->rxq = g_new0( char, 1 );
     102        if( source == -1 )
     103        {
     104                imcb_error( ic, "Could not connect to server" );
     105                imc_logout( ic, TRUE );
     106                return FALSE;
     107        }
     108       
     109        g_free( handler->rxq );
     110        handler->rxlen = 0;
     111        handler->rxq = g_new0( char, 1 );
    105112       
    106113        if( msn_ns_write( ic, -1, "VER %d %s CVR0\r\n", ++md->trId, MSNP_VER ) )
    107114        {
    108                 ic->inpa = b_input_add( md->fd, B_EV_IO_READ, msn_ns_callback, ic );
     115                handler->inpa = b_input_add( handler->fd, B_EV_IO_READ, msn_ns_callback, handler );
    109116                imcb_log( ic, "Connected to server, waiting for reply" );
    110117        }
     
    113120}
    114121
     122void msn_ns_close( struct msn_handler_data *handler )
     123{
     124        if( handler->fd >= 0 )
     125        {
     126                closesocket( handler->fd );
     127                b_event_remove( handler->inpa );
     128        }
     129       
     130        handler->fd = handler->inpa = -1;
     131        g_free( handler->rxq );
     132        g_free( handler->cmd_text );
     133       
     134        handler->rxlen = 0;
     135        handler->rxq = NULL;
     136        handler->cmd_text = NULL;
     137}
     138
    115139static gboolean msn_ns_callback( gpointer data, gint source, b_input_condition cond )
    116140{
    117         struct im_connection *ic = data;
    118         struct msn_data *md = ic->proto_data;
    119        
    120         if( msn_handler( md->handler ) == -1 ) /* Don't do this on ret == 0, it's already done then. */
     141        struct msn_handler_data *handler = data;
     142        struct im_connection *ic = handler->data;
     143       
     144        if( msn_handler( handler ) == -1 ) /* Don't do this on ret == 0, it's already done then. */
    121145        {
    122146                imcb_error( ic, "Error while reading from server" );
     
    129153}
    130154
    131 static int msn_ns_command( gpointer data, char **cmd, int num_parts )
    132 {
    133         struct im_connection *ic = data;
     155static int msn_ns_command( struct msn_handler_data *handler, char **cmd, int num_parts )
     156{
     157        struct im_connection *ic = handler->data;
    134158        struct msn_data *md = ic->proto_data;
    135159       
     
    164188                if( num_parts >= 6 && strcmp( cmd[2], "NS" ) == 0 )
    165189                {
    166                         b_event_remove( ic->inpa );
    167                         ic->inpa = 0;
    168                         closesocket( md->fd );
     190                        b_event_remove( handler->inpa );
     191                        handler->inpa = -1;
    169192                       
    170193                        server = strchr( cmd[3], ':' );
     
    180203                       
    181204                        imcb_log( ic, "Transferring to other server" );
    182                        
    183                         md->fd = proxy_connect( server, port, msn_ns_connected, ic );
     205                        return msn_ns_connect( ic, handler, server, port );
    184206                }
    185207                else if( num_parts >= 6 && strcmp( cmd[2], "SB" ) == 0 )
     
    273295                }
    274296               
    275                 md->handler->msglen = atoi( cmd[3] );
    276                
    277                 if( md->handler->msglen <= 0 )
     297                handler->msglen = atoi( cmd[3] );
     298               
     299                if( handler->msglen <= 0 )
    278300                {
    279301                        imcb_error( ic, "Syntax error" );
     
    296318                else if( num_parts >= 3 )
    297319                {
    298                         md->handler->msglen = atoi( cmd[2] );
     320                        handler->msglen = atoi( cmd[2] );
    299321                }
    300322        }
     
    460482                imcb_error( ic, "Received IPG command, we don't handle them yet." );
    461483               
    462                 md->handler->msglen = atoi( cmd[1] );
    463                
    464                 if( md->handler->msglen <= 0 )
     484                handler->msglen = atoi( cmd[1] );
     485               
     486                if( handler->msglen <= 0 )
    465487                {
    466488                        imcb_error( ic, "Syntax error" );
     
    519541                /* Coming up is cmd[2] bytes of stuff we're supposed to
    520542                   censore. Meh. */
    521                 md->handler->msglen = atoi( cmd[2] );
     543                handler->msglen = atoi( cmd[2] );
    522544        }
    523545        else if( strcmp( cmd[0], "UBX" ) == 0 )
     
    525547                /* Status message. */
    526548                if( num_parts >= 4 )
    527                         md->handler->msglen = atoi( cmd[3] );
     549                        handler->msglen = atoi( cmd[3] );
    528550        }
    529551        else if( strcmp( cmd[0], "NOT" ) == 0 )
     
    532554                   apparently used to announce address book changes. */
    533555                if( num_parts >= 2 )
    534                         md->handler->msglen = atoi( cmd[1] );
     556                        handler->msglen = atoi( cmd[1] );
    535557        }
    536558        else if( isdigit( cmd[0][0] ) )
     
    549571                /* Oh yes, errors can have payloads too now. Discard them for now. */
    550572                if( num_parts >= 3 )
    551                         md->handler->msglen = atoi( cmd[2] );
     573                        handler->msglen = atoi( cmd[2] );
    552574        }
    553575        else
     
    559581}
    560582
    561 static int msn_ns_message( gpointer data, char *msg, int msglen, char **cmd, int num_parts )
    562 {
    563         struct im_connection *ic = data;
     583static int msn_ns_message( struct msn_handler_data *handler, char *msg, int msglen, char **cmd, int num_parts )
     584{
     585        struct im_connection *ic = handler->data;
    564586        char *body;
    565587        int blen = 0;
  • protocols/msn/sb.c

    r64768d4 rbae0617  
    3232
    3333static gboolean msn_sb_callback( gpointer data, gint source, b_input_condition cond );
    34 static int msn_sb_command( gpointer data, char **cmd, int num_parts );
    35 static int msn_sb_message( gpointer data, char *msg, int msglen, char **cmd, int num_parts );
     34static int msn_sb_command( struct msn_handler_data *handler, char **cmd, int num_parts );
     35static int msn_sb_message( struct msn_handler_data *handler, char *msg, int msglen, char **cmd, int num_parts );
    3636
    3737int msn_sb_write( struct msn_switchboard *sb, const char *fmt, ... )
     
    392392}
    393393
    394 static int msn_sb_command( gpointer data, char **cmd, int num_parts )
    395 {
    396         struct msn_switchboard *sb = data;
     394static int msn_sb_command( struct msn_handler_data *handler, char **cmd, int num_parts )
     395{
     396        struct msn_switchboard *sb = handler->data;
    397397        struct im_connection *ic = sb->ic;
    398398       
     
    665665}
    666666
    667 static int msn_sb_message( gpointer data, char *msg, int msglen, char **cmd, int num_parts )
    668 {
    669         struct msn_switchboard *sb = data;
     667static int msn_sb_message( struct msn_handler_data *handler, char *msg, int msglen, char **cmd, int num_parts )
     668{
     669        struct msn_switchboard *sb = handler->data;
    670670        struct im_connection *ic = sb->ic;
    671671        char *body;
Note: See TracChangeset for help on using the changeset viewer.