Changeset 26

Show
Ignore:
Timestamp:
02/22/07 16:02:49 (2 years ago)
Author:
inz
Message:

Make blogger plugin use libsoup.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • maemo-blog/trunk/Makefile

    r15 r26  
    6464libmetaweblog_la_DIR := $(PLUGINDIR) 
    6565 
    66 libblogger_la_CFLAGS += $(CFLAGS) `pkg-config glib-2.0 --cflags` `xmlrpc-c-config client --cflags` 
    67 libblogger_la_LDFLAGS = `xmlrpc-c-config client --libs` -module -shared -rpath $(LIBDIR) -avoid-version 
     66libblogger_la_CFLAGS += $(CFLAGS) `pkg-config glib-2.0 libsoup-2.2 --cflags` 
     67libblogger_la_LDFLAGS = `pkg-config glib-2.0 libsoup-2.2 --libs` -module -shared -rpath $(LIBDIR) -avoid-version 
    6868libblogger_la_SOURCES := blog-blogger.c 
    6969libblogger_la_HEADERS := blog-plugin.h 

  • maemo-blog/trunk/blog-blogger.c

    r15 r26  
    33 
    44#include <glib.h> 
    5 #include <xmlrpc.h> 
    6 #include <xmlrpc_client.h> 
     5#include <glib/gthread.h> 
     6#include <libsoup/soup-session-async.h> 
     7#include <libsoup/soup-xmlrpc-message.h> 
     8#include <libsoup/soup-xmlrpc-response.h> 
    79#include <string.h> 
    810 
    …… 
    1012 
    1113struct BloggerPluginData { 
    12         xmlrpc_client *client; 
    13         xmlrpc_env env; 
     14        SoupSession *session; 
    1415}; 
    15  
    16 static gboolean _event_loop(gpointer user_data) 
    17 { 
    18         struct BloggerPluginData *data = user_data; 
    19  
    20         xmlrpc_client_event_loop_finish_timeout(data->client, 20); 
    21  
    22         return TRUE; 
    23 } 
    24  
    25 /* We're a command-line utility, so we abort if an error occurs. */ 
    26 static void die_if_fault_occurred (xmlrpc_env *env) 
    27 { 
    28     if (env->fault_occurred) { 
    29         fprintf(stderr, "XML-RPC Fault #%d: %s\n", 
    30                 env->fault_code, env->fault_string); 
    31         exit(1); 
    32     } 
    33 } 
    3416 
    3517struct BlogBloggerConnectedClosure { 
    …… 
    4224        gchar *pass; 
    4325}; 
    44 static void _blog_blogger_connected(const char *server_url, 
    45                 const char *method_name, 
    46                 xmlrpc_value *param_array, 
    47                 void *user_data, 
    48                 xmlrpc_env *fault, 
    49                 xmlrpc_value *result); 
     26static void _blog_blogger_connected(SoupMessage *message, 
     27                gpointer user_data); 
    5028static gboolean blog_blogger_connect(BlogPlugin *plugin, 
    5129                const gchar *uri, const gchar *user, 
    …… 
    6038        gboolean new_post; 
    6139}; 
    62 static void _blog_blogger_posted(const char *server_url, 
    63                 const char *method_name, 
    64                 xmlrpc_value *param_array, 
    65                 void *user_data, 
    66                 xmlrpc_env *fault, 
    67                 xmlrpc_value *result); 
     40static void _blog_blogger_posted(SoupMessage *message, 
     41                gpointer user_data); 
    6842static gboolean blog_blogger_new_post(Blog *blog, BlogPost *post, 
    6943                gboolean publish, BlogPostCb cb, gpointer user_data); 
    …… 
    7852}; 
    7953static void blog_blogger_get_categories(Blog *blog, BlogFetchCb cb, gpointer user_data); 
    80 static void _blog_blogger_got_recent(const char *server_url, 
    81                 const char *method_name, 
    82                 xmlrpc_value *param_array, 
    83                 void *user_data, 
    84                 xmlrpc_env *fault, 
    85                 xmlrpc_value *result); 
     54static void _blog_blogger_got_recent(SoupMessage *message, 
     55                gpointer user_data); 
    8656static void blog_blogger_get_recent(Blog *blog, BlogFetchCb cb, gpointer user_data); 
    8757static void blog_blogger_unload(BlogPlugin *plugin); 
    …… 
    9666{ 
    9767        BlogPlugin *retval = g_new0(BlogPlugin, 1); 
    98         struct xmlrpc_curl_xportparms transportParms; 
    99         struct xmlrpc_clientparms clientParms; 
    10068        struct BloggerPluginData *data; 
    10169 
    …… 
    11179        retval->name = g_strdup("Blogger 1.0"); 
    11280 
    113         memset(&transportParms, 0, sizeof(transportParms)); 
    114         memset(&clientParms, 0, sizeof(clientParms)); 
    115  
    116         clientParms.transport = "curl"; 
    117         clientParms.transportparmsP = (struct xmlrpc_xportparms *)&transportParms; 
    118         clientParms.transportparm_size = XMLRPC_CXPSIZE(no_ssl_verifyhost); 
    119  
    120         transportParms.no_ssl_verifypeer = 1; 
    121         transportParms.no_ssl_verifyhost = 1; 
    122  
    123         xmlrpc_env_init(&data->env); 
    124         xmlrpc_client_setup_global_const(&data->env); 
    125         xmlrpc_client_create(&data->env, XMLRPC_CLIENT_NO_FLAGS, (char *)"maemo-blog", (char *)"0.0.1", &clientParms, XMLRPC_CPSIZE(transportparm_size), &data->client); 
     81        if (!g_thread_supported()) { 
     82                g_thread_init(NULL); 
     83        } 
     84 
     85        data->session = soup_session_async_new(); 
    12686 
    12787        return retval; 
    12888} 
    12989 
    130 static void _blog_blogger_connected(const char *server_url, 
    131                 const char *method_name, 
    132                 xmlrpc_value *param_array, 
    133                 void *user_data, 
    134                 xmlrpc_env *fault, 
    135                 xmlrpc_value *blogs) 
     90static void _blog_blogger_connected(SoupMessage *message, 
     91                gpointer user_data) 
    13692{ 
    13793        struct BlogBloggerConnectedClosure *clo = user_data; 
    13894        Blog **retval = NULL; 
    139         guint i, size; 
    140  
    141         (void)server_url; 
    142         (void)method_name; 
    143         (void)param_array; 
    144  
    145         die_if_fault_occurred(fault); 
    146          
    147         if (xmlrpc_value_type(blogs) == XMLRPC_TYPE_ARRAY) { 
    148         size = xmlrpc_array_size(fault, blogs); 
    149         die_if_fault_occurred(fault); 
    150  
    151         retval = g_new0(Blog *, size + 1); 
    152  
    153         for (i = 0; i < size; i++) { 
    154                 xmlrpc_value *blog = xmlrpc_array_get_item(fault, blogs, i); 
    155                 gchar *blogid = NULL, *name = NULL; 
    156                 xmlrpc_parse_value(fault, blog, "{s:s,s:s,*}", 
    157                                 "blogid", &blogid, 
    158                                 "blogName", &name); 
    159                 retval[i] = g_new0(Blog, 1); 
    160                 retval[i]->url = g_strdup(clo->uri); 
    161                 retval[i]->user = g_strdup(clo->user); 
    162                 retval[i]->pass = g_strdup(clo->pass); 
    163                 retval[i]->id = g_strdup(blogid); 
    164                 retval[i]->name = g_strdup(name); 
    165                 retval[i]->plugin = clo->self; 
    166                 retval[i]->posts = NULL; 
    167         } 
    168         retval[i] = NULL; 
     95        SoupXmlrpcResponse *response = soup_xmlrpc_message_parse_response( 
     96                        SOUP_XMLRPC_MESSAGE(message)); 
     97        SoupXmlrpcValue *value = soup_xmlrpc_response_get_value(response); 
     98        GSList *blogs = NULL; 
     99        guint count = 0; 
     100        SoupXmlrpcValueArrayIterator *iter; 
     101 
     102        if (soup_xmlrpc_value_array_get_iterator(value, &iter)) { 
     103                while (iter) { 
     104                        Blog *blog = g_new0(Blog, 1); 
     105                        GHashTable *hash; 
     106                        SoupXmlrpcValue *val; 
     107                        SoupXmlrpcValue *array_val; 
     108 
     109                        soup_xmlrpc_value_array_iterator_get_value(iter, 
     110                                        &array_val); 
     111 
     112                        soup_xmlrpc_value_get_struct(array_val, &hash); 
     113 
     114                        val = g_hash_table_lookup(hash, "blogid"); 
     115                        soup_xmlrpc_value_get_string(val, &blog->id); 
     116                        val = g_hash_table_lookup(hash, "blogName"); 
     117                        soup_xmlrpc_value_get_string(val, &blog->name); 
     118                        g_hash_table_destroy(hash); 
     119                        blog->url = g_strdup(clo->uri); 
     120                        blog->user = g_strdup(clo->user); 
     121                        blog->pass = g_strdup(clo->pass); 
     122                        blog->plugin = clo->self; 
     123 
     124                        blogs = g_slist_prepend(blogs, blog); 
     125                        count++; 
     126 
     127                        iter = soup_xmlrpc_value_array_iterator_next(iter); 
     128                } 
    169129        } else { 
    170                 retval = g_new0(Blog *, 2); 
    171                 gchar *blogid = NULL, *name = NULL; 
    172                 xmlrpc_parse_value(fault, blogs, "{s:s,s:s,*}", 
    173                                 "blogid", &blogid, 
    174                                 "blogName", &name); 
    175                 retval[0] = g_new0(Blog, 1); 
    176                 retval[0]->url = g_strdup(clo->uri); 
    177                 retval[0]->user = g_strdup(clo->user); 
    178                 retval[0]->pass = g_strdup(clo->pass); 
    179                 retval[0]->id = g_strdup(blogid); 
    180                 retval[0]->name = g_strdup(name); 
    181                 retval[0]->plugin = clo->self; 
    182                 retval[0]->posts = NULL; 
    183                 retval[1] = NULL; 
     130                        Blog *blog = g_new0(Blog, 1); 
     131                        GHashTable *hash; 
     132                        SoupXmlrpcValue *val; 
     133                        soup_xmlrpc_value_get_struct(value, &hash); 
     134 
     135                        val = g_hash_table_lookup(hash, "blogid"); 
     136                        soup_xmlrpc_value_get_string(val, &blog->id); 
     137                        val = g_hash_table_lookup(hash, "blogName"); 
     138                        soup_xmlrpc_value_get_string(val, &blog->name); 
     139                        g_hash_table_destroy(hash); 
     140                        blog->url = g_strdup(clo->uri); 
     141                        blog->user = g_strdup(clo->user); 
     142                        blog->pass = g_strdup(clo->pass); 
     143                        blog->plugin = clo->self; 
     144 
     145                        blogs = g_slist_prepend(blogs, blog); 
     146                        count++; 
     147        } 
     148 
     149        retval = g_new0(Blog *, count + 1); 
     150        retval[count] = NULL; 
     151 
     152        while (blogs) { 
     153                retval[--count] = blogs->data; 
     154                blogs = g_slist_delete_link(blogs, blogs); 
    184155        } 
    185156 
    186157        clo->cb(retval, clo->user_data); 
    187         g_source_remove(clo->timeout_id); 
    188158        g_free(clo->uri); 
    189159        g_free(clo->user); 
    …… 
    198168        struct BlogBloggerConnectedClosure *clo = g_new0(struct BlogBloggerConnectedClosure, 1); 
    199169        struct BloggerPluginData *data = plugin->plugin_data; 
     170        SoupXmlrpcMessage *msg; 
    200171        clo->cb = cb; 
    201172        clo->user_data = user_data; 
    …… 
    205176        clo->self = plugin; 
    206177 
    207         xmlrpc_client_start_rpcf(&data->env, 
    208                         data->client, 
    209                         (gchar *)uri,  
    210                         (char *)"blogger.getUsersBlogs", 
    211                         _blog_blogger_connected, 
    212                         clo, 
    213                         (char *)"(sss)", 
    214                         "0123456789ABCDEF", 
    215                         user, 
     178        msg = soup_xmlrpc_message_new(uri); 
     179        soup_xmlrpc_message_start_call(msg, 
     180                        "blogger.getUsersBlogs"); 
     181        soup_xmlrpc_message_start_param(msg); 
     182        soup_xmlrpc_message_write_string(msg, 
     183                        "0123456789ABCDEF"); 
     184        soup_xmlrpc_message_end_param(msg); 
     185        soup_xmlrpc_message_start_param(msg); 
     186        soup_xmlrpc_message_write_string(msg, 
     187                        user); 
     188        soup_xmlrpc_message_end_param(msg); 
     189        soup_xmlrpc_message_start_param(msg); 
     190        soup_xmlrpc_message_write_string(msg, 
    216191                        pass); 
    217  
    218         clo->timeout_id = g_timeout_add(500, _event_loop, data); 
     192        soup_xmlrpc_message_end_param(msg); 
     193        soup_xmlrpc_message_end_call(msg); 
     194        soup_xmlrpc_message_persist(msg); 
     195 
     196        soup_session_queue_message(data->session, SOUP_MESSAGE(msg), 
     197                        _blog_blogger_connected, clo); 
    219198 
    220199        return TRUE; 
    221200} 
    222 static void _blog_blogger_posted(const char *server_url, 
    223                 const char *method_name, 
    224                 xmlrpc_value *param_array, 
    225                 void *user_data, 
    226                 xmlrpc_env *fault, 
    227                 xmlrpc_value *retval) 
     201static void _blog_blogger_posted(SoupMessage *message, 
     202                gpointer user_data) 
    228203{ 
    229204        struct BlogBloggerPostedClosure *clo = user_data; 
    230205        gboolean status = TRUE; 
    231         gint numeric_id = 0; 
     206        long numeric_id = 0; 
    232207        gchar *string_id = NULL; 
    233208 
    234         (void)server_url; 
    235         (void)method_name; 
    236         (void)param_array; 
     209        SoupXmlrpcResponse *response = soup_xmlrpc_message_parse_response( 
     210                        SOUP_XMLRPC_MESSAGE(message)); 
     211 
     212        SoupXmlrpcValue *value = soup_xmlrpc_response_get_value(response); 
     213 
    237214 
    238215        if (clo->new_post) { 
    239                 switch (xmlrpc_value_type(retval)) { 
    240                 case XMLRPC_TYPE_INT: 
    241                         xmlrpc_parse_value(fault, retval, "i", &numeric_id); 
     216                switch (soup_xmlrpc_value_get_type(value)) { 
     217                case SOUP_XMLRPC_VALUE_TYPE_INT: 
     218                        soup_xmlrpc_value_get_int(value, 
     219                                        &numeric_id); 
    242220                        break; 
    243                 case XMLRPC_TYPE_STRING: 
    244                         xmlrpc_parse_value(fault, retval, "s", &string_id); 
     221                case SOUP_XMLRPC_VALUE_TYPE_STRING: 
     222                        soup_xmlrpc_value_get_string(value, 
     223                                        &string_id); 
    245224                        break; 
    246225                default: 
    …… 
    248227                        break; 
    249228                } 
    250                 die_if_fault_occurred(fault); 
    251229 
    252230                if (string_id) { 
    253                         clo->post->id = g_strdup(string_id); 
     231                        clo->post->id = string_id; 
    254232                } else { 
    255                         clo->post->id = g_strdup_printf("%d\n", numeric_id); 
     233                        clo->post->id = g_strdup_printf("%ld\n", numeric_id); 
    256234                } 
    257235 
    258236                clo->blog->posts = g_slist_prepend(clo->blog->posts, clo->post); 
    259237        } else { 
    260                 xmlrpc_parse_value(fault, retval, "b", &status); 
     238                soup_xmlrpc_value_get_boolean(value, &status); 
    261239        } 
    262240        clo->cb(clo->blog, clo->post, status, clo->user_data); 
    263         g_source_remove(clo->timeout_id); 
    264241        g_free(clo); 
    265242} 
    …… 
    269246                gboolean publish, BlogPostCb cb, gpointer user_data) 
    270247{ 
    271         gchar *content; 
    272248        struct BlogBloggerPostedClosure *clo; 
    273249        struct BloggerPluginData *data = blog->plugin->plugin_data; 
     250        SoupXmlrpcMessage *msg; 
     251        gchar *content; 
    274252 
    275253        if (!post || !post->content) { 
    …… 
    288266                        post->content); 
    289267 
    290         xmlrpc_client_start_rpcf(&data->env, 
    291                         data->client, 
    292                         blog->url, 
    293                         (char *)"blogger.newPost", 
    294                         _blog_blogger_posted, 
    295                         clo, 
    296                         (char *)"(sssssb)", 
    297                         "0123456789ABCDEF", 
    298                         blog->id, 
    299                         blog->user, 
    300                         blog->pass, 
    301                         content, 
    302                         publish); 
     268        msg = soup_xmlrpc_message_new(blog->url); 
     269        soup_xmlrpc_message_start_call(msg, "blogger.newPost"); 
     270        soup_xmlrpc_message_start_param(msg); 
     271        soup_xmlrpc_message_write_string(msg, "0123456789ABCDEF"); 
     272        soup_xmlrpc_message_end_param(msg); 
     273        soup_xmlrpc_message_start_param(msg); 
     274        soup_xmlrpc_message_write_string(msg, blog->id); 
     275        soup_xmlrpc_message_end_param(msg); 
     276        soup_xmlrpc_message_start_param(msg); 
     277        soup_xmlrpc_message_write_string(msg, blog->user); 
     278        soup_xmlrpc_message_end_param(msg); 
     279        soup_xmlrpc_message_start_param(msg); 
     280        soup_xmlrpc_message_write_string(msg, blog->pass); 
     281        soup_xmlrpc_message_end_param(msg); 
     282        soup_xmlrpc_message_start_param(msg); 
     283        soup_xmlrpc_message_write_string(msg, content); 
     284        soup_xmlrpc_message_end_param(msg); 
     285        soup_xmlrpc_message_start_param(msg); 
     286        soup_xmlrpc_message_write_boolean(msg, publish); 
     287        soup_xmlrpc_message_end_param(msg); 
     288        soup_xmlrpc_message_end_call(msg); 
     289        soup_xmlrpc_message_persist(msg); 
     290 
     291        soup_session_queue_message(data->session, SOUP_MESSAGE(msg), 
     292                        _blog_blogger_posted, clo); 
     293 
    303294        g_free(content); 
    304         content = NULL; 
    305  
    306         clo->timeout_id = g_timeout_add(500, _event_loop, data); 
    307295 
    308296        return TRUE; 
    …… 
    315303        struct BlogBloggerPostedClosure *clo; 
    316304        struct BloggerPluginData *data = blog->plugin->plugin_data; 
     305        SoupXmlrpcMessage *msg; 
    317306 
    318307        if (!post || !post->content || !post->id) { 
    …… 
    331320                        post->content); 
    332321 
    333         xmlrpc_client_start_rpcf(&data->env, 
    334                         data->client, 
    335                         blog->url, (char *)"blogger.editPost", 
    336                         _blog_blogger_posted, 
    337                         clo, 
    338                         (char *)"(sssssb)", 
    339                         "0123456789ABCDEF", 
    340                         post->id, 
    341                         blog->user, 
    342                         blog->pass, 
    343                         content, 
    344                         publish); 
     322        msg = soup_xmlrpc_message_new(blog->url); 
     323        soup_xmlrpc_message_start_call(msg, "blogger.editPost"); 
     324        soup_xmlrpc_message_start_param(msg); 
     325        soup_xmlrpc_message_write_string(msg, "0123456789ABCDEF"); 
     326        soup_xmlrpc_message_end_param(msg); 
     327        soup_xmlrpc_message_start_param(msg); 
     328        soup_xmlrpc_message_write_string(msg, post->id); 
     329        soup_xmlrpc_message_end_param(msg); 
     330        soup_xmlrpc_message_start_param(msg); 
     331        soup_xmlrpc_message_write_string(msg, blog->user); 
     332        soup_xmlrpc_message_end_param(msg); 
     333        soup_xmlrpc_message_start_param(msg); 
     334        soup_xmlrpc_message_write_string(msg, blog->pass); 
     335        soup_xmlrpc_message_end_param(msg); 
     336        soup_xmlrpc_message_start_param(msg); 
     337        soup_xmlrpc_message_write_string(msg, content); 
     338        soup_xmlrpc_message_end_param(msg); 
     339        soup_xmlrpc_message_start_param(msg); 
     340        soup_xmlrpc_message_write_boolean(msg, publish); 
     341        soup_xmlrpc_message_end_param(msg); 
     342        soup_xmlrpc_message_end_call(msg); 
     343        soup_xmlrpc_message_persist(msg); 
     344 
     345        soup_session_queue_message(data->session, SOUP_MESSAGE(msg), 
     346                        _blog_blogger_posted, clo); 
     347 
    345348        g_free(content); 
    346  
    347         clo->timeout_id = g_timeout_add(500, _event_loop, data); 
    348349 
    349350        return TRUE; 
    …… 
    372373} 
    373374 
    374 static void _blog_blogger_got_recent(const char *server_url, 
    375                 const char *method_name, 
    376                 xmlrpc_value *param_array, 
    377                 void *user_data, 
    378                 xmlrpc_env *fault, 
    379                 xmlrpc_value *retval) 
     375static void _blog_blogger_got_recent(SoupMessage *message, 
     376                gpointer user_data) 
    380377{ 
    381378        struct BlogBloggerFetchedClosure *clo = (struct BlogBloggerFetchedClosure *)user_data; 
    382         size_t size, i; 
    383  
    384         (void)server_url; 
    385         (void)method_name; 
    386         (void)param_array; 
    387  
    388         size = xmlrpc_array_size(fault, retval); 
    389         die_if_fault_occurred(fault); 
    390  
    391         for (i = 0; i < size; i++) { 
     379        SoupXmlrpcResponse *response = soup_xmlrpc_message_parse_response( 
     380                        SOUP_XMLRPC_MESSAGE(message)); 
     381        SoupXmlrpcValue *array = soup_xmlrpc_response_get_value(response); 
     382        SoupXmlrpcValue *value; 
     383        SoupXmlrpcValueArrayIterator *iter; 
     384 
     385        for (soup_xmlrpc_value_array_get_iterator(array, &iter); 
     386                        iter; 
     387                        iter = soup_xmlrpc_value_array_iterator_next(iter)) { 
    392388                BlogPost *new_post = g_new0(BlogPost, 1); 
    393                 xmlrpc_value *post = xmlrpc_array_get_item(fault, retval, i); 
     389                soup_xmlrpc_value_array_iterator_get_value(iter, &value); 
    394390                gchar *id, *content; 
    395391                gchar *temp1, *temp2; 
    396  
    397                 xmlrpc_parse_value(fault, post, "{s:s,s:s,*}", 
    398                                 "postid", &id, 
    399                                 "content", &content); 
    400  
    401                 new_post->id = g_strdup(id); 
     392                GHashTable *table; 
     393 
     394                soup_xmlrpc_value_get_struct(value, &table); 
     395                value = g_hash_table_lookup(table, "postid"); 
     396                if (value) { 
     397                        soup_xmlrpc_value_get_string(value, &id); 
     398                } 
     399                value = g_hash_table_lookup(table, "content"); 
     400                if (value) { 
     401                        soup_xmlrpc_value_get_string(value, &content); 
     402                } 
     403 
     404                new_post->id = id; 
    402405                temp1 = strstr(content, "<title>"); 
    403406                temp2 = strstr(content, "</title>"); 
    …… 
    410413                        temp2 += strlen("</title>"); 
    411414                        new_post->content = g_strdup(temp2); 
     415                        g_free(content); 
    412416                } else { 
    413                         new_post->content = g_strdup(content); 
    414                 } 
     417                        new_post->content = content; 
     418                } 
     419 
     420                g_hash_table_destroy(table); 
    415421 
    416422                clo->blog->posts = g_slist_append(clo->blog->posts, new_post); 
    417423        } 
    418424 
    419         g_source_remove(clo->timeout_id); 
    420425        clo->cb(clo->blog, clo->user_data); 
    421426        g_free(clo); 
    …… 
    426431        struct BlogBloggerFetchedClosure *clo = g_new0(struct BlogBloggerFetchedClosure, 1); 
    427432        struct BloggerPluginData *data = blog->plugin->plugin_data; 
     433        SoupXmlrpcMessage *msg; 
    428434        clo->blog = blog; 
    429435        clo->cb = cb; 
    430436        clo->user_data = user_data; 
    431437 
    432         xmlrpc_client_start_rpcf(&data->env, 
    433                         data->client, 
    434                         blog->url, 
    435                         (char *)"blogger.getRecentPosts", 
    436                         _blog_blogger_got_recent, 
    437                         clo, 
    438                         (char *)"(ssssi)", 
    439                         "0123456789ABCDEF", 
    440                         blog->id, 
    441                         blog->user, 
    442                         blog->pass, 
    443                         15); 
    444          
    445         clo->timeout_id = g_timeout_add(500, _event_loop, data); 
     438        msg = soup_xmlrpc_message_new(blog->url); 
     439        soup_xmlrpc_message_start_call(msg, "metaWeblog.getRecentPosts"); 
     440        soup_xmlrpc_message_start_param(msg); 
     441        soup_xmlrpc_message_write_string(msg, "0123456789ABCDEF"); 
     442        soup_xmlrpc_message_end_param(msg); 
     443        soup_xmlrpc_message_start_param(msg); 
     444        soup_xmlrpc_message_write_string(msg, blog->id); 
     445        soup_xmlrpc_message_end_param(msg); 
     446        soup_xmlrpc_message_start_param(msg); 
     447        soup_xmlrpc_message_write_string(msg, blog->user); 
     448        soup_xmlrpc_message_end_param(msg); 
     449        soup_xmlrpc_message_start_param(msg); 
     450        soup_xmlrpc_message_write_string(msg, blog->pass); 
     451        soup_xmlrpc_message_end_param(msg); 
     452        soup_xmlrpc_message_start_param(msg); 
     453        soup_xmlrpc_message_write_int(msg, 15); 
     454        soup_xmlrpc_message_end_param(msg); 
     455        soup_xmlrpc_message_end_call(msg); 
     456        soup_xmlrpc_message_persist(msg); 
     457 
     458        soup_session_queue_message(data->session, SOUP_MESSAGE(msg), 
     459                        _blog_blogger_got_recent, clo); 
    446460} 
    447461 
    …… 
    449463{ 
    450464        struct BloggerPluginData *data = plugin->plugin_data; 
    451         xmlrpc_env_clean(&data->env); 
    452         xmlrpc_client_destroy(data->client); 
    453         g_free(plugin->plugin_data); 
     465        g_object_unref(data->session); 
     466        g_free(data); 
    454467        g_free(plugin->name); 
    455468        g_free(plugin); 

  • maemo-blog/trunk/blog-metaweblog.c

    r17 r26  
    576576        SoupXmlrpcValue *value; 
    577577        SoupXmlrpcValueArrayIterator *iter; 
    578         soup_xmlrpc_value_array_get_iterator(array, &iter); 
    579578 
    580579        for (soup_xmlrpc_value_array_get_iterator(array, &iter); 
    …… 
    628627                } 
    629628 
     629                g_hash_table_destroy(table); 
     630 
    630631                new_post->id = id; 
    631632                new_post->content = content; 

  • maemo-blog/trunk/debian/changelog

    r16 r26  
     1maemo-blog (0.1.7) mistral; urgency=low 
     2 
     3  * Make blogger plugin use libsoup. 
     4 
     5 -- Santtu Lakkala <inz@inz.fi>  Thu, 22 Feb 2007 15:02:34 +0200 
     6 
    17maemo-blog (0.1.6) mistral; urgency=low 
    28 

  • maemo-blog/trunk/debian/control

    r7 r26  
    33Priority: optional 
    44Maintainer: Santtu Lakkala <ext-santtu.1.lakkala@nokia.com> 
    5 Build-Depends: debhelper (>= 4.0.0), libxmlrpc-c3-dev (>= 1.0), libgtk2.0-dev, libgnomevfsutil-dev | libgnomeui-dev 
     5Build-Depends: debhelper (>= 4.0.0), libgtk2.0-dev, libgnomevfsutil-dev | libgnomeui-dev 
    66Standards-Version: 3.6.0 
    77