Changeset 5ebff60 for lib/oauth2.c


Ignore:
Timestamp:
2015-02-20T22:50:54Z (6 years ago)
Author:
dequis <dx@…>
Branches:
master
Children:
0b9daac, 3d45471, 7733b8c
Parents:
af359b4
git-author:
Indent <please@…> (19-02-15 05:47:20)
git-committer:
dequis <dx@…> (20-02-15 22:50:54)
Message:

Reindent everything to K&R style with tabs

Used uncrustify, with the configuration file in ./doc/uncrustify.cfg

Commit author set to "Indent <please@…>" so that it's easier to
skip while doing git blame.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/oauth2.c

    raf359b4 r5ebff60  
    2828   use JSON. Wait, no, Facebook's version doesn't use JSON. For some of its
    2929   responses.
    30    
     30
    3131   Apparently too many people were too retarded to comprehend the elementary
    3232   bits of crypto in OAuth 1.0a (took me one afternoon to implement) so
    3333   the standard was replaced with what comes down to a complicated scheme
    3434   around what's really just application-specific passwords.
    35    
     35
    3636   And then a bunch of mostly incompatible implementations. Great work, guys.
    37    
     37
    3838   http://hueniverse.com/2012/07/oauth-2-0-and-the-road-to-hell/ */
    3939
     
    4646#include "url.h"
    4747
    48 char *oauth2_url( const struct oauth2_service *sp )
     48char *oauth2_url(const struct oauth2_service *sp)
    4949{
    50         return g_strconcat( sp->auth_url,
    51                             "?scope=", sp->scope,
    52                             "&response_type=code"
    53                             "&redirect_uri=", sp->redirect_url,
    54                             "&client_id=", sp->consumer_key,
    55                             NULL );
     50        return g_strconcat(sp->auth_url,
     51                           "?scope=", sp->scope,
     52                           "&response_type=code"
     53                           "&redirect_uri=", sp->redirect_url,
     54                           "&client_id=", sp->consumer_key,
     55                           NULL);
    5656}
    5757
    58 struct oauth2_access_token_data
    59 {
     58struct oauth2_access_token_data {
    6059        oauth2_token_callback func;
    6160        gpointer data;
    6261};
    6362
    64 static void oauth2_access_token_done( struct http_request *req );
     63static void oauth2_access_token_done(struct http_request *req);
    6564
    66 int oauth2_access_token( const struct oauth2_service *sp,
    67                          const char *auth_type, const char *auth,
    68                          oauth2_token_callback func, gpointer data )
     65int oauth2_access_token(const struct oauth2_service *sp,
     66                        const char *auth_type, const char *auth,
     67                        oauth2_token_callback func, gpointer data)
    6968{
    7069        GSList *args = NULL;
     
    7372        struct http_request *req;
    7473        struct oauth2_access_token_data *cb_data;
    75        
    76         if( !url_set( &url_p, sp->token_url ) )
     74
     75        if (!url_set(&url_p, sp->token_url)) {
    7776                return 0;
    78        
    79         oauth_params_add( &args, "client_id", sp->consumer_key );
    80         oauth_params_add( &args, "client_secret", sp->consumer_secret );
    81         oauth_params_add( &args, "grant_type", auth_type );
    82         if( strcmp( auth_type, OAUTH2_AUTH_CODE ) == 0 )
    83         {
    84                 oauth_params_add( &args, "redirect_uri", sp->redirect_url );
    85                 oauth_params_add( &args, "code", auth );
    8677        }
    87         else
    88         {
    89                 oauth_params_add( &args, "refresh_token", auth );
     78
     79        oauth_params_add(&args, "client_id", sp->consumer_key);
     80        oauth_params_add(&args, "client_secret", sp->consumer_secret);
     81        oauth_params_add(&args, "grant_type", auth_type);
     82        if (strcmp(auth_type, OAUTH2_AUTH_CODE) == 0) {
     83                oauth_params_add(&args, "redirect_uri", sp->redirect_url);
     84                oauth_params_add(&args, "code", auth);
     85        } else {
     86                oauth_params_add(&args, "refresh_token", auth);
    9087        }
    91         args_s = oauth_params_string( args );
    92         oauth_params_free( &args );
    93        
    94         s = g_strdup_printf( "POST %s HTTP/1.0\r\n"
    95                              "Host: %s\r\n"
    96                              "Content-Type: application/x-www-form-urlencoded\r\n"
    97                              "Content-Length: %zd\r\n"
    98                              "\r\n"
    99                              "%s", url_p.file, url_p.host, strlen( args_s ), args_s );
    100         g_free( args_s );
    101        
    102         cb_data = g_new0( struct oauth2_access_token_data, 1 );
     88        args_s = oauth_params_string(args);
     89        oauth_params_free(&args);
     90
     91        s = g_strdup_printf("POST %s HTTP/1.0\r\n"
     92                            "Host: %s\r\n"
     93                            "Content-Type: application/x-www-form-urlencoded\r\n"
     94                            "Content-Length: %zd\r\n"
     95                            "\r\n"
     96                            "%s", url_p.file, url_p.host, strlen(args_s), args_s);
     97        g_free(args_s);
     98
     99        cb_data = g_new0(struct oauth2_access_token_data, 1);
    103100        cb_data->func = func;
    104101        cb_data->data = data;
    105        
    106         req = http_dorequest( url_p.host, url_p.port, url_p.proto == PROTO_HTTPS,
    107                               s, oauth2_access_token_done, cb_data );
    108        
    109         g_free( s );
    110        
    111         if( req == NULL )
    112                 g_free( cb_data );
    113        
     102
     103        req = http_dorequest(url_p.host, url_p.port, url_p.proto == PROTO_HTTPS,
     104                             s, oauth2_access_token_done, cb_data);
     105
     106        g_free(s);
     107
     108        if (req == NULL) {
     109                g_free(cb_data);
     110        }
     111
    114112        return req != NULL;
    115113}
    116114
    117 static char* oauth2_parse_error( json_value *e )
     115static char* oauth2_parse_error(json_value *e)
    118116{
    119117        /* This does a reasonable job with some of the flavours of error
    120118           responses I've seen. Because apparently it's not standardised. */
    121        
    122         if( e->type == json_object )
    123         {
     119
     120        if (e->type == json_object) {
    124121                /* Facebook style */
    125                 const char *msg = json_o_str( e, "message" );
    126                 const char *type = json_o_str( e, "type" );
    127                 json_value *code_o = json_o_get( e, "code" );
     122                const char *msg = json_o_str(e, "message");
     123                const char *type = json_o_str(e, "type");
     124                json_value *code_o = json_o_get(e, "code");
    128125                int code = 0;
    129                
    130                 if( code_o && code_o->type == json_integer )
     126
     127                if (code_o && code_o->type == json_integer) {
    131128                        code = code_o->u.integer;
    132                
    133                 return g_strdup_printf( "Error %d: %s", code, msg ? msg : type ? type : "Unknown error" );
    134         }
    135         else if( e->type == json_string )
    136         {
    137                 return g_strdup( e->u.string.ptr );
     129                }
     130
     131                return g_strdup_printf("Error %d: %s", code, msg ? msg : type ? type : "Unknown error");
     132        } else if (e->type == json_string) {
     133                return g_strdup(e->u.string.ptr);
    138134        }
    139135        return NULL;
    140136}
    141137
    142 static void oauth2_access_token_done( struct http_request *req )
     138static void oauth2_access_token_done(struct http_request *req)
    143139{
    144140        struct oauth2_access_token_data *cb_data = req->data;
    145141        char *atoken = NULL, *rtoken = NULL, *error = NULL;
    146142        char *content_type;
    147        
    148         if( getenv( "BITLBEE_DEBUG" ) && req->reply_body )
    149                 printf( "%s\n", req->reply_body );
    150        
    151         content_type = get_rfc822_header( req->reply_headers, "Content-Type", 0 );
    152        
    153         if( content_type && ( strstr( content_type, "application/json" ) ||
    154                               strstr( content_type, "text/javascript" ) ) )
    155         {
    156                 json_value *js = json_parse( req->reply_body, req->body_size );
    157                 if( js && js->type == json_object )
    158                 {
    159                         JSON_O_FOREACH( js, k, v )
    160                         {
    161                                 if( strcmp( k, "error" ) == 0 )
    162                                         error = oauth2_parse_error( v );
    163                                 if( v->type != json_string )
     143
     144        if (getenv("BITLBEE_DEBUG") && req->reply_body) {
     145                printf("%s\n", req->reply_body);
     146        }
     147
     148        content_type = get_rfc822_header(req->reply_headers, "Content-Type", 0);
     149
     150        if (content_type && (strstr(content_type, "application/json") ||
     151                             strstr(content_type, "text/javascript"))) {
     152                json_value *js = json_parse(req->reply_body, req->body_size);
     153                if (js && js->type == json_object) {
     154                        JSON_O_FOREACH(js, k, v){
     155                                if (strcmp(k, "error") == 0) {
     156                                        error = oauth2_parse_error(v);
     157                                }
     158                                if (v->type != json_string) {
    164159                                        continue;
    165                                 if( strcmp( k, "access_token" ) == 0 )
    166                                         atoken = g_strdup( v->u.string.ptr );
    167                                 if( strcmp( k, "refresh_token" ) == 0 )
    168                                         rtoken = g_strdup( v->u.string.ptr );
     160                                }
     161                                if (strcmp(k, "access_token") == 0) {
     162                                        atoken = g_strdup(v->u.string.ptr);
     163                                }
     164                                if (strcmp(k, "refresh_token") == 0) {
     165                                        rtoken = g_strdup(v->u.string.ptr);
     166                                }
    169167                        }
    170168                }
    171                 json_value_free( js );
    172         }
    173         else
    174         {
     169                json_value_free(js);
     170        } else {
    175171                /* Facebook use their own odd format here, seems to be URL-encoded. */
    176172                GSList *p_in = NULL;
    177                
    178                 oauth_params_parse( &p_in, req->reply_body );
    179                 atoken = g_strdup( oauth_params_get( &p_in, "access_token" ) );
    180                 rtoken = g_strdup( oauth_params_get( &p_in, "refresh_token" ) );
    181                 oauth_params_free( &p_in );
     173
     174                oauth_params_parse(&p_in, req->reply_body);
     175                atoken = g_strdup(oauth_params_get(&p_in, "access_token"));
     176                rtoken = g_strdup(oauth_params_get(&p_in, "refresh_token"));
     177                oauth_params_free(&p_in);
    182178        }
    183         if( getenv( "BITLBEE_DEBUG" ) )
    184                 printf( "Extracted atoken=%s rtoken=%s\n", atoken, rtoken );
    185         if( !atoken && !rtoken && !error )
    186                 error = g_strdup( "Unusable response" );
    187        
    188         cb_data->func( cb_data->data, atoken, rtoken, error );
    189         g_free( content_type );
    190         g_free( atoken );
    191         g_free( rtoken );
    192         g_free( error );
    193         g_free( cb_data );
     179        if (getenv("BITLBEE_DEBUG")) {
     180                printf("Extracted atoken=%s rtoken=%s\n", atoken, rtoken);
     181        }
     182        if (!atoken && !rtoken && !error) {
     183                error = g_strdup("Unusable response");
     184        }
     185
     186        cb_data->func(cb_data->data, atoken, rtoken, error);
     187        g_free(content_type);
     188        g_free(atoken);
     189        g_free(rtoken);
     190        g_free(error);
     191        g_free(cb_data);
    194192}
Note: See TracChangeset for help on using the changeset viewer.