Changeset c2ecadc for lib


Ignore:
Timestamp:
2010-05-01T13:53:59Z (10 years ago)
Author:
Wilmer van der Gaast <wilmer@…>
Branches:
master
Children:
f4b0911
Parents:
85ef57f
Message:

Cleaned up OAuth stuff: consumer key/secret should *not* be in lib/oauth.c.
Keep it in the Twitter module, and use the oauth_info struct through the
whole session to keep all this together.

Location:
lib
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • lib/oauth.c

    r85ef57f rc2ecadc  
    3333#include "oauth.h"
    3434
    35 #define CONSUMER_KEY "xsDNKJuNZYkZyMcu914uEA"
    36 #define CONSUMER_SECRET "FCxqcr0pXKzsF9ajmP57S3VQ8V6Drk4o2QYtqMcOszo"
    37 /* How can it be a secret if it's right here in the source code? No clue... */
    38 
    3935#define HMAC_BLOCK_SIZE 64
    4036
    4137static char *oauth_sign( const char *method, const char *url,
    42                          const char *params, const char *token_secret )
     38                         const char *params, struct oauth_info *oi )
    4339{
    4440        sha1_state_t sha1;
     
    5147           otherwise just pad. */
    5248        memset( key, 0, HMAC_BLOCK_SIZE );
    53         i = strlen( CONSUMER_SECRET ) + 1 + ( token_secret ? strlen( token_secret ) : 0 );
     49        i = strlen( oi->sp->consumer_secret ) + 1 + ( oi->token_secret ? strlen( oi->token_secret ) : 0 );
    5450        if( i > HMAC_BLOCK_SIZE )
    5551        {
    5652                sha1_init( &sha1 );
    57                 sha1_append( &sha1, (uint8_t*) CONSUMER_SECRET, strlen( CONSUMER_SECRET ) );
     53                sha1_append( &sha1, (uint8_t*) oi->sp->consumer_secret, strlen( oi->sp->consumer_secret ) );
    5854                sha1_append( &sha1, (uint8_t*) "&", 1 );
    59                 if( token_secret )
    60                         sha1_append( &sha1, (uint8_t*) token_secret, strlen( token_secret ) );
     55                if( oi->token_secret )
     56                        sha1_append( &sha1, (uint8_t*) oi->token_secret, strlen( oi->token_secret ) );
    6157                sha1_finish( &sha1, key );
    6258        }
     
    6460        {
    6561                g_snprintf( (gchar*) key, HMAC_BLOCK_SIZE + 1, "%s&%s",
    66                             CONSUMER_SECRET, token_secret ? : "" );
     62                            oi->sp->consumer_secret, oi->token_secret ? : "" );
    6763        }
    6864       
     
    229225        if( info )
    230226        {
    231                 g_free( info->auth_params );
     227                g_free( info->auth_url );
    232228                g_free( info->request_token );
    233                 g_free( info->access_token );
     229                g_free( info->token );
     230                g_free( info->token_secret );
    234231                g_free( info );
    235232        }
    236233}
    237234
    238 static void oauth_add_default_params( GSList **params )
     235static void oauth_add_default_params( GSList **params, struct oauth_service *sp )
    239236{
    240237        char *s;
    241238       
    242         oauth_params_set( params, "oauth_consumer_key", CONSUMER_KEY );
     239        oauth_params_set( params, "oauth_consumer_key", sp->consumer_key );
    243240        oauth_params_set( params, "oauth_signature_method", "HMAC-SHA1" );
    244241       
     
    254251}
    255252
    256 static void *oauth_post_request( const char *url, GSList **params_, http_input_function func, void *data )
     253static void *oauth_post_request( const char *url, GSList **params_, http_input_function func, struct oauth_info *oi )
    257254{
    258255        GSList *params = NULL;
     
    270267                params = *params_;
    271268       
    272         oauth_add_default_params( &params );
     269        oauth_add_default_params( &params, oi->sp );
    273270       
    274271        params_s = oauth_params_string( params );
    275272        oauth_params_free( &params );
    276273       
    277         s = oauth_sign( "POST", url, params_s, NULL );
     274        s = oauth_sign( "POST", url, params_s, oi );
    278275        post = g_strdup_printf( "%s&oauth_signature=%s", params_s, s );
    279276        g_free( params_s );
     
    289286       
    290287        req = http_dorequest( url_p.host, url_p.port, url_p.proto == PROTO_HTTPS,
    291                               s, func, data );
     288                              s, func, oi );
    292289        g_free( s );
    293290       
     
    297294static void oauth_request_token_done( struct http_request *req );
    298295
    299 struct oauth_info *oauth_request_token( const char *url, oauth_cb func, void *data )
     296struct oauth_info *oauth_request_token( struct oauth_service *sp, oauth_cb func, void *data )
    300297{
    301298        struct oauth_info *st = g_new0( struct oauth_info, 1 );
     
    304301        st->func = func;
    305302        st->data = data;
     303        st->sp = sp;
    306304       
    307305        oauth_params_add( &params, "oauth_callback", "oob" );
    308306       
    309         if( !oauth_post_request( url, &params, oauth_request_token_done, st ) )
     307        if( !oauth_post_request( sp->url_request_token, &params, oauth_request_token_done, st ) )
    310308        {
    311309                oauth_info_free( st );
     
    326324                GSList *params = NULL;
    327325               
    328                 st->auth_params = g_strdup( req->reply_body );
    329                 oauth_params_parse( &params, st->auth_params );
     326                st->auth_url = g_strdup_printf( "%s?%s", st->sp->url_authorize, req->reply_body );
     327                oauth_params_parse( &params, req->reply_body );
    330328                st->request_token = g_strdup( oauth_params_get( &params, "oauth_token" ) );
    331329                oauth_params_free( &params );
     
    333331       
    334332        st->stage = OAUTH_REQUEST_TOKEN;
    335         if( !st->func( st ) )
    336                 oauth_info_free( st );
     333        st->func( st );
    337334}
    338335
    339336static void oauth_access_token_done( struct http_request *req );
    340337
    341 void oauth_access_token( const char *url, const char *pin, struct oauth_info *st )
     338gboolean oauth_access_token( const char *pin, struct oauth_info *st )
    342339{
    343340        GSList *params = NULL;
     
    346343        oauth_params_add( &params, "oauth_verifier", pin );
    347344       
    348         if( !oauth_post_request( url, &params, oauth_access_token_done, st ) )
    349                 oauth_info_free( st );
     345        return oauth_post_request( st->sp->url_access_token, &params, oauth_access_token_done, st ) != NULL;
    350346}
    351347
     
    359355        {
    360356                GSList *params = NULL;
    361                 const char *token, *token_secret;
    362357               
    363358                oauth_params_parse( &params, req->reply_body );
    364                 token = oauth_params_get( &params, "oauth_token" );
    365                 token_secret = oauth_params_get( &params, "oauth_token_secret" );
    366                 st->access_token = g_strdup_printf(
    367                         "oauth_token=%s&oauth_token_secret=%s", token, token_secret );
     359                st->token = g_strdup( oauth_params_get( &params, "oauth_token" ) );
     360                st->token_secret = g_strdup( oauth_params_get( &params, "oauth_token_secret" ) );
    368361                oauth_params_free( &params );
    369362        }
    370363       
    371364        st->stage = OAUTH_ACCESS_TOKEN;
    372         st->func( st );
    373         oauth_info_free( st );
    374 }
    375 
    376 char *oauth_http_header( char *access_token, const char *method, const char *url, char *args )
     365        if( st->func( st ) )
     366        {
     367                /* Don't need these anymore, but keep the rest. */
     368                g_free( st->auth_url );
     369                st->auth_url = NULL;
     370                g_free( st->request_token );
     371                st->request_token = NULL;
     372        }
     373}
     374
     375char *oauth_http_header( struct oauth_info *oi, const char *method, const char *url, char *args )
    377376{
    378377        GSList *params = NULL, *l;
    379         char *token_secret = NULL, *sig = NULL, *params_s, *s;
     378        char *sig = NULL, *params_s, *s;
    380379        GString *ret = NULL;
    381380       
    382         /* First, get the two pieces of info from the access token that we need. */
    383         oauth_params_parse( &params, access_token );
    384         if( params == NULL )
    385                 goto err;
    386        
    387         /* Pick out the token secret, we shouldn't include it but use it for signing. */
    388         token_secret = g_strdup( oauth_params_get( &params, "oauth_token_secret" ) );
    389         if( token_secret == NULL )
    390                 goto err;
    391         oauth_params_del( &params, "oauth_token_secret" );
    392        
    393         oauth_add_default_params( &params );
     381        oauth_params_add( &params, "oauth_token", oi->token );
     382        oauth_add_default_params( &params, oi->sp );
    394383       
    395384        /* Start building the OAuth header. 'key="value", '... */
     
    421410        {
    422411                s = g_strdup( s + 1 );
    423                 oauth_params_parse( &params, s + 1 );
     412                oauth_params_parse( &params, s );
    424413                g_free( s );
    425414        }
     
    427416        /* Append the signature and we're done! */
    428417        params_s = oauth_params_string( params );
    429         sig = oauth_sign( method, url, params_s, token_secret );
     418        sig = oauth_sign( method, url, params_s, oi );
    430419        g_string_append_printf( ret, "oauth_signature=\"%s\"", sig );
    431420        g_free( params_s );
    432421       
    433 err:
    434422        oauth_params_free( &params );
    435423        g_free( sig );
    436         g_free( token_secret );
    437424       
    438425        return ret ? g_string_free( ret, FALSE ) : NULL;
  • lib/oauth.h

    r85ef57f rc2ecadc  
    4040{
    4141        oauth_stage_t stage;
     42        struct oauth_service *sp;
    4243       
    4344        oauth_cb func;
     
    4647        struct http_request *http;
    4748       
    48         char *auth_params;
     49        char *auth_url;
    4950        char *request_token;
    5051       
    51         char *access_token;
     52        char *token;
     53        char *token_secret;
     54};
     55
     56struct oauth_service
     57{
     58        char *url_request_token;
     59        char *url_access_token;
     60        char *url_authorize;
     61       
     62        char *consumer_key;
     63        char *consumer_secret;
    5264};
    5365
     
    5668   authorization URL for the user. This is passed to the callback function
    5769   in a struct oauth_info. */
    58 struct oauth_info *oauth_request_token( const char *url, oauth_cb func, void *data );
     70struct oauth_info *oauth_request_token( struct oauth_service *sp, oauth_cb func, void *data );
    5971
    6072/* http://oauth.net/core/1.0a/#auth_step3 (section 6.3)
     
    6274   token. This is passed to the callback function in the same
    6375   struct oauth_info. */
    64 void oauth_access_token( const char *url, const char *pin, struct oauth_info *st );
     76gboolean oauth_access_token( const char *pin, struct oauth_info *st );
    6577
    6678/* http://oauth.net/core/1.0a/#anchor12 (section 7)
     
    6981   whatever's going to be in the POST body of the request. GET args will
    7082   automatically be grabbed from url. */
    71 char *oauth_http_header( char *access_token, const char *method, const char *url, char *args );
     83char *oauth_http_header( struct oauth_info *oi, const char *method, const char *url, char *args );
    7284
    7385/* Shouldn't normally be required unless the process is aborted by the user. */
Note: See TracChangeset for help on using the changeset viewer.