Ticket #663: twitter-mentions.diff

twitter.c

@@ -29 +29 @@
 #include "url.h"
 
 #define twitter_msg( ic, fmt... ) \
-        do {                                                        \
-                struct twitter_data *td = ic->proto_data;           \
-                if( td->home_timeline_gc )                          \
-                        imcb_chat_log( td->home_timeline_gc, fmt ); \
-                else                                                \
-                        imcb_log( ic, fmt );                        \
+        do {                                            \
+                struct twitter_data *td = ic->proto_data;   \
+                if( td->timeline_gc )                       \
+                        imcb_chat_log( td->timeline_gc, fmt );  \
+                else                                        \
+                        imcb_log( ic, fmt );                    \
         } while( 0 );
 
 GSList *twitter_connections = NULL;
@@ -51 +51 @@
                 return 0;
 
         // Do stuff..
-        twitter_get_home_timeline(ic, -1);
+        twitter_get_timeline(ic, -1);
 
         // If we are still logged in run this function again after timeout.
         return (ic->flags & OPT_LOGGED_IN) == OPT_LOGGED_IN;
@@ -68 +68 @@
 
         // Queue the main_loop
         // Save the return value, so we can remove the timeout on logout.
-        td->main_loop_id = b_timeout_add(60000, twitter_main_loop, ic);
+        td->main_loop_id =
+            b_timeout_add(set_getint(&ic->acc->set, "fetch_every") * 1000, twitter_main_loop, ic);
 }
 
 static void twitter_oauth_start(struct im_connection *ic);
@@ -77 +78 @@
 {
         struct twitter_data *td = ic->proto_data;
 
+        td->timeline_doing = FALSE;
+
         if (set_getbool(&ic->acc->set, "oauth") && !td->oauth_info)
                 twitter_oauth_start(ic);
         else if (g_strcasecmp(set_getstr(&ic->acc->set, "mode"), "one") != 0 &&
@@ -219 +222 @@
 
         s = set_add(&acc->set, "auto_reply_timeout", "10800", set_eval_int, acc);
 
+        s = set_add(&acc->set, "fetch_every", "60", set_eval_int, acc);
+        s->flags |= ACC_SET_OFFLINE_ONLY;
+
         s = set_add(&acc->set, "base_url", def_url, NULL, acc);
         s->flags |= ACC_SET_OFFLINE_ONLY;
 
@@ -226 +232 @@
 
         s = set_add(&acc->set, "message_length", "140", set_eval_int, acc);
 
+        s = set_add(&acc->set, "include_mentions", "true", set_eval_bool, acc);
+
         s = set_add(&acc->set, "mode", "chat", set_eval_mode, acc);
         s->flags |= ACC_SET_OFFLINE_ONLY;
 
@@ -299 +307 @@
         // Remove the main_loop function from the function queue.
         b_event_remove(td->main_loop_id);
 
-        if (td->home_timeline_gc)
-                imcb_chat_free(td->home_timeline_gc);
+        if (td->timeline_gc)
+                imcb_chat_free(td->timeline_gc);
 
         if (td) {
                 oauth_info_free(td->oauth_info);
@@ -386 +394 @@
 {
         struct twitter_data *td = c->ic->proto_data;
 
-        if (c != td->home_timeline_gc)
+        if (c != td->timeline_gc)
                 return;         /* WTF? */
 
         /* If the user leaves the channel: Fine. Rejoin him/her once new
            tweets come in. */
-        imcb_chat_free(td->home_timeline_gc);
-        td->home_timeline_gc = NULL;
+        imcb_chat_free(td->timeline_gc);
+        td->timeline_gc = NULL;
 }
 
 static void twitter_keepalive(struct im_connection *ic)

twitter.c.orig

@@ +1 @@
+/***************************************************************************\
+*                                                                           *
+*  BitlBee - An IRC to IM gateway                                           *
+*  Simple module to facilitate twitter functionality.                       *
+*                                                                           *
+*  Copyright 2009 Geert Mulders <g.c.w.m.mulders@gmail.com>                 *
+*                                                                           *
+*  This library is free software; you can redistribute it and/or            *
+*  modify it under the terms of the GNU Lesser General Public               *
+*  License as published by the Free Software Foundation, version            *
+*  2.1.                                                                     *
+*                                                                           *
+*  This library is distributed in the hope that it will be useful,          *
+*  but WITHOUT ANY WARRANTY; without even the implied warranty of           *
+*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU        *
+*  Lesser General Public License for more details.                          *
+*                                                                           *
+*  You should have received a copy of the GNU Lesser General Public License *
+*  along with this library; if not, write to the Free Software Foundation,  *
+*  Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA           *
+*                                                                           *
+****************************************************************************/
+
+#include "nogaim.h"
+#include "oauth.h"
+#include "twitter.h"
+#include "twitter_http.h"
+#include "twitter_lib.h"
+#include "url.h"
+
+#define twitter_msg( ic, fmt... ) \
+        do {                                                        \
+                struct twitter_data *td = ic->proto_data;           \
+                if( td->home_timeline_gc )                          \
+                        imcb_chat_log( td->home_timeline_gc, fmt ); \
+                else                                                \
+                        imcb_log( ic, fmt );                        \
+        } while( 0 );
+                
+GSList *twitter_connections = NULL;
+
+/**
+ * Main loop function
+ */
+gboolean twitter_main_loop(gpointer data, gint fd, b_input_condition cond)
+{
+        struct im_connection *ic = data;
+        
+        // Check if we are still logged in...
+        if (!g_slist_find( twitter_connections, ic ))
+                return 0;
+
+        // Do stuff..
+        twitter_get_home_timeline(ic, -1);
+
+        // If we are still logged in run this function again after timeout.
+        return (ic->flags & OPT_LOGGED_IN) == OPT_LOGGED_IN;
+}
+
+static void twitter_main_loop_start( struct im_connection *ic )
+{
+        struct twitter_data *td = ic->proto_data;
+        
+        imcb_log( ic, "Getting initial statuses" );
+
+        // Run this once. After this queue the main loop function.
+        twitter_main_loop(ic, -1, 0);
+
+        // Queue the main_loop
+        // Save the return value, so we can remove the timeout on logout.
+        td->main_loop_id = b_timeout_add(60000, twitter_main_loop, ic);
+}
+
+static void twitter_oauth_start( struct im_connection *ic );
+
+void twitter_login_finish( struct im_connection *ic )
+{
+        struct twitter_data *td = ic->proto_data;
+        
+        if( set_getbool( &ic->acc->set, "oauth" ) && !td->oauth_info )
+                twitter_oauth_start( ic );
+        else if( g_strcasecmp( set_getstr( &ic->acc->set, "mode" ), "one" ) != 0 &&
+                 !( td->flags & TWITTER_HAVE_FRIENDS ) )
+        {
+                imcb_log( ic, "Getting contact list" );
+                twitter_get_statuses_friends( ic, -1 );
+        }
+        else
+                twitter_main_loop_start( ic );
+}
+
+static const struct oauth_service twitter_oauth =
+{
+        "http://api.twitter.com/oauth/request_token",
+        "http://api.twitter.com/oauth/access_token",
+        "https://api.twitter.com/oauth/authorize",
+        .consumer_key = "xsDNKJuNZYkZyMcu914uEA",
+        .consumer_secret = "FCxqcr0pXKzsF9ajmP57S3VQ8V6Drk4o2QYtqMcOszo",
+};
+
+static const struct oauth_service identica_oauth =
+{
+        "http://identi.ca/api/oauth/request_token",
+        "http://identi.ca/api/oauth/access_token",
+        "https://identi.ca/api/oauth/authorize",
+        .consumer_key = "e147ff789fcbd8a5a07963afbb43f9da",
+        .consumer_secret = "c596267f277457ec0ce1ab7bb788d828",
+};
+
+static gboolean twitter_oauth_callback( struct oauth_info *info );
+
+static const struct oauth_service *get_oauth_service( struct im_connection *ic )
+{
+        struct twitter_data *td = ic->proto_data;
+        
+        if( strstr( td->url_host, "identi.ca" ) )
+                return &identica_oauth;
+        else
+                return &twitter_oauth;
+        
+        /* Could add more services, or allow configuring your own base URL +
+           API keys. */
+}
+
+static void twitter_oauth_start( struct im_connection *ic )
+{
+        struct twitter_data *td = ic->proto_data;
+        
+        imcb_log( ic, "Requesting OAuth request token" );
+
+        td->oauth_info = oauth_request_token( get_oauth_service( ic ), twitter_oauth_callback, ic );
+        
+        /* We need help from the user to complete OAuth login, so don't time
+           out on this login. */
+        ic->flags |= OPT_SLOW_LOGIN;
+}
+
+static gboolean twitter_oauth_callback( struct oauth_info *info )
+{
+        struct im_connection *ic = info->data;
+        struct twitter_data *td;
+        
+        if( !g_slist_find( twitter_connections, ic ) )
+                return FALSE;
+        
+        td = ic->proto_data;
+        if( info->stage == OAUTH_REQUEST_TOKEN )
+        {
+                char name[strlen(ic->acc->user)+9], *msg;
+                
+                if( info->request_token == NULL )
+                {
+                        imcb_error( ic, "OAuth error: %s", twitter_parse_error( info->http ) );
+                        imc_logout( ic, TRUE );
+                        return FALSE;
+                }
+                
+                sprintf( name, "%s_%s", td->prefix, ic->acc->user );
+                msg = g_strdup_printf( "To finish OAuth authentication, please visit "
+                                       "%s and respond with the resulting PIN code.",
+                                       info->auth_url );
+                imcb_buddy_msg( ic, name, msg, 0, 0 );
+                g_free( msg );
+        }
+        else if( info->stage == OAUTH_ACCESS_TOKEN )
+        {
+                if( info->token == NULL || info->token_secret == NULL )
+                {
+                        imcb_error( ic, "OAuth error: %s", twitter_parse_error( info->http ) );
+                        imc_logout( ic, TRUE );
+                        return FALSE;
+                }
+                else
+                {
+                        const char *sn = oauth_params_get( &info->params, "screen_name" );
+                        
+                        if( sn != NULL && ic->acc->prpl->handle_cmp( sn, ic->acc->user ) != 0 )
+                        {
+                                imcb_log( ic, "Warning: You logged in via OAuth as %s "
+                                          "instead of %s.", sn, ic->acc->user );
+                        }
+                }
+                
+                /* IM mods didn't do this so far and it's ugly but I should
+                   be able to get away with it... */
+                g_free( ic->acc->pass );
+                ic->acc->pass = oauth_to_string( info );
+                
+                twitter_login_finish( ic );
+        }
+        
+        return TRUE;
+}
+
+
+static char *set_eval_mode( set_t *set, char *value )
+{
+        if( g_strcasecmp( value, "one" ) == 0 ||
+            g_strcasecmp( value, "many" ) == 0 ||
+            g_strcasecmp( value, "chat" ) == 0 )
+                return value;
+        else
+                return NULL;
+}
+
+static gboolean twitter_length_check( struct im_connection *ic, gchar *msg )
+{
+        int max = set_getint( &ic->acc->set, "message_length" ), len;
+        
+        if( max == 0 || ( len = g_utf8_strlen( msg, -1 ) ) <= max )
+                return TRUE;
+        
+        imcb_error( ic, "Maximum message length exceeded: %d > %d", len, max );
+        
+        return FALSE;
+}
+
+static void twitter_init( account_t *acc )
+{
+        set_t *s;
+        char *def_url;
+        char *def_oauth;
+        
+        if( strcmp( acc->prpl->name, "twitter" ) == 0 )
+        {
+                def_url = TWITTER_API_URL;
+                def_oauth = "true";
+        }
+        else /* if( strcmp( acc->prpl->name, "identica" ) == 0 ) */
+        {
+                def_url = IDENTICA_API_URL;
+                def_oauth = "false";
+        }
+        
+        s = set_add( &acc->set, "auto_reply_timeout", "10800", set_eval_int, acc );
+        
+        s = set_add( &acc->set, "base_url", def_url, NULL, acc );
+        s->flags |= ACC_SET_OFFLINE_ONLY;
+        
+        s = set_add( &acc->set, "commands", "true", set_eval_bool, acc );
+        
+        s = set_add( &acc->set, "message_length", "140", set_eval_int, acc );
+        
+        s = set_add( &acc->set, "mode", "chat", set_eval_mode, acc );
+        s->flags |= ACC_SET_OFFLINE_ONLY;
+        
+        s = set_add( &acc->set, "show_ids", "false", set_eval_bool, acc );
+        s->flags |= ACC_SET_OFFLINE_ONLY;
+        
+        s = set_add( &acc->set, "oauth", def_oauth, set_eval_bool, acc );
+}
+
+/**
+ * Login method. Since the twitter API works with seperate HTTP request we 
+ * only save the user and pass to the twitter_data object.
+ */
+static void twitter_login( account_t *acc )
+{
+        struct im_connection *ic = imcb_new( acc );
+        struct twitter_data *td;
+        char name[strlen(acc->user)+9];
+        url_t url;
+
+        if( !url_set( &url, set_getstr( &ic->acc->set, "base_url" ) ) ||
+            ( url.proto != PROTO_HTTP && url.proto != PROTO_HTTPS ) )
+        {
+                imcb_error( ic, "Incorrect API base URL: %s", set_getstr( &ic->acc->set, "base_url" ) );
+                imc_logout( ic, FALSE );
+                return;
+        }
+        
+        twitter_connections = g_slist_append( twitter_connections, ic );
+        td = g_new0( struct twitter_data, 1 );
+        ic->proto_data = td;
+        
+        td->url_ssl = url.proto == PROTO_HTTPS;
+        td->url_port = url.port;
+        td->url_host = g_strdup( url.host );
+        if( strcmp( url.file, "/" ) != 0 )
+                td->url_path = g_strdup( url.file );
+        else
+                td->url_path = g_strdup( "" );
+        if( g_str_has_suffix( url.host, ".com" ) )
+                td->prefix = g_strndup( url.host, strlen( url.host ) - 4 );
+        else
+                td->prefix = g_strdup( url.host );
+        
+        td->flags |= TWITTER_HAVE_FRIENDS;
+        td->user = acc->user;
+        if( strstr( acc->pass, "oauth_token=" ) )
+                td->oauth_info = oauth_from_string( acc->pass, get_oauth_service( ic ) );
+        
+        sprintf( name, "%s_%s", td->prefix, acc->user );
+        imcb_add_buddy( ic, name, NULL );
+        imcb_buddy_status( ic, name, OPT_LOGGED_IN, NULL, NULL );
+        
+        if( set_getbool( &acc->set, "show_ids" ) )
+                td->log = g_new0( struct twitter_log_data, TWITTER_LOG_LENGTH );
+        
+        imcb_log( ic, "Connecting" );
+        
+        twitter_login_finish( ic );
+}
+
+/**
+ * Logout method. Just free the twitter_data.
+ */
+static void twitter_logout( struct im_connection *ic )
+{
+        struct twitter_data *td = ic->proto_data;
+        
+        // Set the status to logged out.
+        ic->flags &= ~ OPT_LOGGED_IN;
+
+        // Remove the main_loop function from the function queue.
+        b_event_remove(td->main_loop_id);
+
+        if(td->home_timeline_gc)
+                imcb_chat_free(td->home_timeline_gc);
+
+        if( td )
+        {
+                oauth_info_free( td->oauth_info );
+                g_free( td->prefix );
+                g_free( td->url_host );
+                g_free( td->url_path );
+                g_free( td->pass );
+                g_free( td->log );
+                g_free( td );
+        }
+
+        twitter_connections = g_slist_remove( twitter_connections, ic );
+}
+
+static void twitter_handle_command( struct im_connection *ic, char *message );
+
+/**
+ *
+ */
+static int twitter_buddy_msg( struct im_connection *ic, char *who, char *message, int away )
+{
+        struct twitter_data *td = ic->proto_data;
+        int plen = strlen( td->prefix );
+        
+        if (g_strncasecmp(who, td->prefix, plen) == 0 && who[plen] == '_' &&
+            g_strcasecmp(who + plen + 1, ic->acc->user) == 0)
+        {
+                if( set_getbool( &ic->acc->set, "oauth" ) &&
+                    td->oauth_info && td->oauth_info->token == NULL )
+                {
+                        char pin[strlen(message)+1], *s;
+                        
+                        strcpy( pin, message );
+                        for( s = pin + sizeof( pin ) - 2; s > pin && isspace( *s ); s -- )
+                                *s = '\0';
+                        for( s = pin; *s && isspace( *s ); s ++ ) {}
+                        
+                        if( !oauth_access_token( s, td->oauth_info ) )
+                        {
+                                imcb_error( ic, "OAuth error: %s", "Failed to send access token request" );
+                                imc_logout( ic, TRUE );
+                                return FALSE;
+                        }
+                }
+                else
+                        twitter_handle_command(ic, message);
+        }
+        else
+        {
+                twitter_direct_messages_new(ic, who, message);
+        }
+        return( 0 );
+}
+
+/**
+ *
+ */
+static void twitter_set_my_name( struct im_connection *ic, char *info )
+{
+}
+
+static void twitter_get_info(struct im_connection *ic, char *who) 
+{
+}
+
+static void twitter_add_buddy( struct im_connection *ic, char *who, char *group )
+{
+        twitter_friendships_create_destroy(ic, who, 1);
+}
+
+static void twitter_remove_buddy( struct im_connection *ic, char *who, char *group )
+{
+        twitter_friendships_create_destroy(ic, who, 0);
+}
+
+static void twitter_chat_msg( struct groupchat *c, char *message, int flags )
+{
+        if( c && message )
+                twitter_handle_command( c->ic, message );
+}
+
+static void twitter_chat_invite( struct groupchat *c, char *who, char *message )
+{
+}
+
+static void twitter_chat_leave( struct groupchat *c )
+{
+        struct twitter_data *td = c->ic->proto_data;
+        
+        if( c != td->home_timeline_gc )
+                return; /* WTF? */
+        
+        /* If the user leaves the channel: Fine. Rejoin him/her once new
+           tweets come in. */
+        imcb_chat_free(td->home_timeline_gc);
+        td->home_timeline_gc = NULL;
+}
+
+static void twitter_keepalive( struct im_connection *ic )
+{
+}
+
+static void twitter_add_permit( struct im_connection *ic, char *who )
+{
+}
+
+static void twitter_rem_permit( struct im_connection *ic, char *who )
+{
+}
+
+static void twitter_add_deny( struct im_connection *ic, char *who )
+{
+}
+
+static void twitter_rem_deny( struct im_connection *ic, char *who )
+{
+}
+
+//static char *twitter_set_display_name( set_t *set, char *value )
+//{
+//      return value;
+//}
+
+static void twitter_buddy_data_add( struct bee_user *bu )
+{
+        bu->data = g_new0( struct twitter_user_data, 1 );
+}
+
+static void twitter_buddy_data_free( struct bee_user *bu )
+{
+        g_free( bu->data );
+}
+
+static void twitter_handle_command( struct im_connection *ic, char *message )
+{
+        struct twitter_data *td = ic->proto_data;
+        char *cmds, **cmd, *new = NULL;
+        guint64 in_reply_to = 0;
+        
+        cmds = g_strdup( message );
+        cmd = split_command_parts( cmds );
+        
+        if( cmd[0] == NULL )
+        {
+                g_free( cmds );
+                return;
+        }
+        else if( !set_getbool( &ic->acc->set, "commands" ) )
+        {
+                /* Not supporting commands. */
+        }
+        else if( g_strcasecmp( cmd[0], "undo" ) == 0 )
+        {
+                guint64 id;
+                
+                if( cmd[1] )
+                        id = g_ascii_strtoull( cmd[1], NULL, 10 );
+                else
+                        id = td->last_status_id;
+                
+                /* TODO: User feedback. */
+                if( id )
+                        twitter_status_destroy( ic, id );
+                else
+                        twitter_msg( ic, "Could not undo last action" );
+                
+                g_free( cmds );
+                return;
+        }
+        else if( g_strcasecmp( cmd[0], "follow" ) == 0 && cmd[1] )
+        {
+                twitter_add_buddy( ic, cmd[1], NULL );
+                g_free( cmds );
+                return;
+        }
+        else if( g_strcasecmp( cmd[0], "unfollow" ) == 0 && cmd[1] )
+        {
+                twitter_remove_buddy( ic, cmd[1], NULL );
+                g_free( cmds );
+                return;
+        }
+        else if( g_strcasecmp( cmd[0], "rt" ) == 0 && cmd[1] )
+        {
+                struct twitter_user_data *tud;
+                bee_user_t *bu;
+                guint64 id;
+                
+                if( ( bu = bee_user_by_handle( ic->bee, ic, cmd[1] ) ) &&
+                    ( tud = bu->data ) && tud->last_id )
+                        id = tud->last_id;
+                else
+                {
+                        id = g_ascii_strtoull( cmd[1], NULL, 10 );
+                        if( id < TWITTER_LOG_LENGTH && td->log )
+                                id = td->log[id].id;
+                }
+                
+                td->last_status_id = 0;
+                if( id )
+                        twitter_status_retweet( ic, id );
+                else
+                        twitter_msg( ic, "User `%s' does not exist or didn't "
+                                         "post any statuses recently", cmd[1] );
+                
+                g_free( cmds );
+                return;
+        }
+        else if( g_strcasecmp( cmd[0], "reply" ) == 0 && cmd[1] && cmd[2] )
+        {
+                struct twitter_user_data *tud;
+                bee_user_t *bu = NULL;
+                guint64 id = 0;
+                
+                if( ( bu = bee_user_by_handle( ic->bee, ic, cmd[1] ) ) &&
+                    ( tud = bu->data ) && tud->last_id )
+                {
+                        id = tud->last_id;
+                }
+                else if( ( id = g_ascii_strtoull( cmd[1], NULL, 10 ) ) &&
+                         ( id < TWITTER_LOG_LENGTH ) && td->log )
+                {
+                        bu = td->log[id].bu;
+                        if( g_slist_find( ic->bee->users, bu ) )
+                                id = td->log[id].id;
+                        else
+                                bu = NULL;
+                }
+                if( !id || !bu )
+                {
+                        twitter_msg( ic, "User `%s' does not exist or didn't "
+                                         "post any statuses recently", cmd[1] );
+                        return;
+                }
+                message = new = g_strdup_printf( "@%s %s", bu->handle,
+                                                 message + ( cmd[2] - cmd[0] ) );
+                in_reply_to = id;
+        }
+        else if( g_strcasecmp( cmd[0], "post" ) == 0 )
+        {
+                message += 5;
+        }
+        
+        {
+                char *s;
+                bee_user_t *bu;
+                
+                if( !twitter_length_check( ic, message ) )
+                {
+                        g_free( new );
+                        g_free( cmds );
+                        return;
+                }
+                
+                s = cmd[0] + strlen( cmd[0] ) - 1;
+                if( !new && s > cmd[0] && ( *s == ':' || *s == ',' ) )
+                {
+                        *s = '\0';
+                        
+                        if( ( bu = bee_user_by_handle( ic->bee, ic, cmd[0] ) ) )
+                        {
+                                struct twitter_user_data *tud = bu->data;
+                                
+                                new = g_strdup_printf( "@%s %s", bu->handle,
+                                                       message + ( s - cmd[0] ) + 2 );
+                                message = new;
+                                
+                                if( time( NULL ) < tud->last_time +
+                                    set_getint( &ic->acc->set, "auto_reply_timeout" ) )
+                                        in_reply_to = tud->last_id;
+                        }
+                }
+                
+                /* If the user runs undo between this request and its response
+                   this would delete the second-last Tweet. Prevent that. */
+                td->last_status_id = 0;
+                twitter_post_status( ic, message, in_reply_to );
+                g_free( new );
+        }
+        g_free( cmds );
+}
+
+void twitter_initmodule()
+{
+        struct prpl *ret = g_new0(struct prpl, 1);
+        
+        ret->options = OPT_NOOTR;
+        ret->name = "twitter";
+        ret->login = twitter_login;
+        ret->init = twitter_init;
+        ret->logout = twitter_logout;
+        ret->buddy_msg = twitter_buddy_msg;
+        ret->get_info = twitter_get_info;
+        ret->set_my_name = twitter_set_my_name;
+        ret->add_buddy = twitter_add_buddy;
+        ret->remove_buddy = twitter_remove_buddy;
+        ret->chat_msg = twitter_chat_msg;
+        ret->chat_invite = twitter_chat_invite;
+        ret->chat_leave = twitter_chat_leave;
+        ret->keepalive = twitter_keepalive;
+        ret->add_permit = twitter_add_permit;
+        ret->rem_permit = twitter_rem_permit;
+        ret->add_deny = twitter_add_deny;
+        ret->rem_deny = twitter_rem_deny;
+        ret->buddy_data_add = twitter_buddy_data_add;
+        ret->buddy_data_free = twitter_buddy_data_free;
+        ret->handle_cmp = g_strcasecmp;
+        
+        register_protocol(ret);
+
+        /* And an identi.ca variant: */
+        ret = g_memdup(ret, sizeof(struct prpl));
+        ret->name = "identica";
+        register_protocol(ret);
+}

twitter.h

@@ -44 +44 @@
         char* user;
         char* pass;
         struct oauth_info *oauth_info;
-        guint64 home_timeline_id;
+
+        gboolean timeline_doing;
+        gpointer home_timeline_obj;
+        gboolean home_timeline_done;
+        gpointer mentions_obj;
+        gboolean mentions_done;
+
+        guint64 timeline_id;
         guint64 last_status_id; /* For undo */
         gint main_loop_id;
-        struct groupchat *home_timeline_gc;
+        struct groupchat *timeline_gc;
         gint http_fails;
         twitter_flags_t flags;
         

twitter_lib.c

@@ -78 +78 @@
 {
         if (txu == NULL)
                 return;
+
         g_free(txu->name);
         g_free(txu->screen_name);
         g_free(txu);
 }
 
-
 /**
  * Frees a twitter_xml_status struct.
  */
 static void txs_free(struct twitter_xml_status *txs)
 {
+        if (txs == NULL)
+                return;
+
         g_free(txs->text);
         txu_free(txs->user);
         g_free(txs);
@@ -103 +106 @@
         GSList *l;
         if (txl == NULL)
                 return;
-        for (l = txl->list; l; l = g_slist_next(l))
-                if (txl->type == TXL_STATUS)
+
+        for (l = txl->list; l; l = g_slist_next(l)) {
+                if (txl->type == TXL_STATUS) {
                         txs_free((struct twitter_xml_status *) l->data);
-                else if (txl->type == TXL_ID)
+                } else if (txl->type == TXL_ID) {
                         g_free(l->data);
+                }
+        }
+
         g_slist_free(txl->list);
         g_free(txl);
 }
 
 /**
- * Add a buddy if it is not allready added, set the status to logged in.
+ * Compare status elements
+ */
+static gint twitter_compare_elements(gconstpointer a, gconstpointer b)
+{
+        struct twitter_xml_status *a_status = (struct twitter_xml_status *) a;
+        struct twitter_xml_status *b_status = (struct twitter_xml_status *) b;
+
+        if (a_status->created_at < b_status->created_at) {
+                return -1;
+        } else if (a_status->created_at > b_status->created_at) {
+                return 1;
+        } else {
+                return 0;
+        }
+}
+
+/**
+ * Add a buddy if it is not already added, set the status to logged in.
  */
 static void twitter_add_buddy(struct im_connection *ic, char *name, const char *fullname)
 {
         struct twitter_data *td = ic->proto_data;
 
-        // Check if the buddy is allready in the buddy list.
+        // Check if the buddy is already in the buddy list.
         if (!bee_user_by_handle(ic->bee, ic, name)) {
                 char *mode = set_getstr(&ic->acc->set, "mode");
 
@@ -130 +154 @@
                         /* Necessary so that nicks always get translated to the
                            exact Twitter username. */
                         imcb_buddy_nick_hint(ic, name, name);
-                        imcb_chat_add_buddy(td->home_timeline_gc, name);
+                        imcb_chat_add_buddy(td->timeline_gc, name);
                 } else if (g_strcasecmp(mode, "many") == 0)
                         imcb_buddy_status(ic, name, OPT_LOGGED_IN, NULL, NULL);
         }
@@ -438 +462 @@
         return XT_HANDLED;
 }
 
-static void twitter_http_get_home_timeline(struct http_request *req);
-
-/**
- * Get the timeline.
- */
-void twitter_get_home_timeline(struct im_connection *ic, gint64 next_cursor)
-{
-        struct twitter_data *td = ic->proto_data;
-
-        char *args[4];
-        args[0] = "cursor";
-        args[1] = g_strdup_printf("%lld", (long long) next_cursor);
-        if (td->home_timeline_id) {
-                args[2] = "since_id";
-                args[3] = g_strdup_printf("%llu", (long long unsigned int) td->home_timeline_id);
-        }
-
-        twitter_http(ic, TWITTER_HOME_TIMELINE_URL, twitter_http_get_home_timeline, ic, 0, args,
-                     td->home_timeline_id ? 4 : 2);
-
-        g_free(args[1]);
-        if (td->home_timeline_id) {
-                g_free(args[3]);
-        }
-}
-
 static char *twitter_msg_add_id(struct im_connection *ic,
                                 struct twitter_xml_status *txs, const char *prefix)
 {
@@ -502 +500 @@
         struct twitter_data *td = ic->proto_data;
         GSList *l;
 
-        td->home_timeline_gc = gc = imcb_chat_new(ic, "home/timeline");
+        td->timeline_gc = gc = imcb_chat_new(ic, "twitter/timeline");
 
         name_hint = g_strdup_printf("%s_%s", td->prefix, ic->acc->user);
         imcb_chat_name_hint(gc, name_hint);
@@ -511 +509 @@
         for (l = ic->bee->users; l; l = l->next) {
                 bee_user_t *bu = l->data;
                 if (bu->ic == ic)
-                        imcb_chat_add_buddy(td->home_timeline_gc, bu->handle);
+                        imcb_chat_add_buddy(td->timeline_gc, bu->handle);
         }
 }
 
@@ -524 +522 @@
         GSList *l = NULL;
         struct twitter_xml_status *status;
         struct groupchat *gc;
+        char *text;
+        guint64 last_id = 0;
+        size_t length;
 
         // Create a new groupchat if it does not exsist.
-        if (!td->home_timeline_gc)
+        if (!td->timeline_gc)
                 twitter_groupchat_init(ic);
 
-        gc = td->home_timeline_gc;
+        gc = td->timeline_gc;
         if (!gc->joined)
                 imcb_chat_add_buddy(gc, ic->acc->user);
 
@@ -537 +538 @@
                 char *msg;
 
                 status = l->data;
-                if (status->user == NULL || status->text == NULL)
+                if (status->user == NULL || status->text == NULL || last_id == status->id)
                         continue;
 
-                twitter_add_buddy(ic, status->user->screen_name, status->user->name);
+                last_id = status->id;
 
                 strip_html(status->text);
+
                 msg = twitter_msg_add_id(ic, status, "");
 
                 // Say it!
-                if (g_strcasecmp(td->user, status->user->screen_name) == 0)
+                if (g_strcasecmp(td->user, status->user->screen_name) == 0) {
                         imcb_chat_log(gc, "You: %s", msg ? msg : status->text);
-                else
+                } else {
+                        twitter_add_buddy(ic, status->user->screen_name, status->user->name);
+
                         imcb_chat_msg(gc, status->user->screen_name,
                                       msg ? msg : status->text, 0, status->created_at);
+                }
 
                 g_free(msg);
 
-                // Update the home_timeline_id to hold the highest id, so that by the next request
+                // Update the timeline_id to hold the highest id, so that by the next request
                 // we won't pick up the updates already in the list.
-                td->home_timeline_id = MAX(td->home_timeline_id, status->id);
+                td->timeline_id = MAX(td->timeline_id, status->id);
         }
 }
 
@@ -570 +575 @@
         struct twitter_xml_status *status;
         char from[MAX_STRING];
         gboolean mode_one;
+        guint64 last_id = 0;
 
         mode_one = g_strcasecmp(set_getstr(&ic->acc->set, "mode"), "one") == 0;
 
@@ -582 +588 @@
                 char *prefix = NULL, *text = NULL;
 
                 status = l->data;
+                if (status->user == NULL || status->text == NULL || last_id == status->id)
+                        continue;
+
+                last_id = status->id;
 
                 strip_html(status->text);
                 if (mode_one)
@@ -596 +606 @@
                                mode_one ? from : status->user->screen_name,
                                text ? text : status->text, 0, status->created_at);
 
-                // Update the home_timeline_id to hold the highest id, so that by the next request
+                // Update the timeline_id to hold the highest id, so that by the next request
                 // we won't pick up the updates already in the list.
-                td->home_timeline_id = MAX(td->home_timeline_id, status->id);
+                td->timeline_id = MAX(td->timeline_id, status->id);
 
                 g_free(text);
                 g_free(prefix);
         }
 }
 
+static void twitter_http_get_home_timeline(struct http_request *req);
+static void twitter_http_get_mentions(struct http_request *req);
+
+/**
+ * Get the timeline with optionally mentions
+ */
+void twitter_get_timeline(struct im_connection *ic, gint64 next_cursor)
+{
+        struct twitter_data *td = ic->proto_data;
+        gboolean include_mentions = set_getbool(&ic->acc->set, "include_mentions");
+
+        if (td->timeline_doing) {
+                return;
+        }
+
+        td->timeline_doing = TRUE;
+
+        twitter_get_home_timeline(ic, next_cursor);
+
+        if (include_mentions) {
+                twitter_get_mentions(ic, next_cursor);
+        }
+}
+
+void twitter_flush_timeline(struct im_connection *ic)
+{
+        struct twitter_data *td = ic->proto_data;
+        gboolean include_mentions = set_getbool(&ic->acc->set, "include_mentions");
+        struct twitter_xml_list *home_timeline = td->home_timeline_obj;
+        struct twitter_xml_list *mentions = td->mentions_obj;
+        GSList *output = NULL;
+        GSList *l;
+
+        if (!td->home_timeline_done) {
+                return;
+        }
+
+        if (include_mentions && !td->mentions_done) {
+                return;
+        }
+
+        if (home_timeline && home_timeline->list) {
+                for (l = home_timeline->list; l; l = g_slist_next(l)) {
+                        output = g_slist_insert_sorted(output, l->data, twitter_compare_elements);
+                }
+        }
+
+        if (include_mentions && mentions && mentions->list) {
+                for (l = mentions->list; l; l = g_slist_next(l)) {
+                        if (output && twitter_compare_elements(l->data, output->data) < 0) {
+                                continue;
+                        }
+
+                        output = g_slist_insert_sorted(output, l->data, twitter_compare_elements);
+                }
+        }
+        // See if the user wants to see the messages in a groupchat window or as private messages.
+        if (g_strcasecmp(set_getstr(&ic->acc->set, "mode"), "chat") == 0)
+                twitter_groupchat(ic, output);
+        else
+                twitter_private_message_chat(ic, output);
+
+        g_slist_free(output);
+
+        if (home_timeline && home_timeline->list) {
+                txl_free(home_timeline);
+        }
+
+        if (mentions && mentions->list) {
+                txl_free(mentions);
+        }
+
+        td->home_timeline_done = FALSE;
+        td->mentions_done = FALSE;
+        td->timeline_doing = FALSE;
+}
+
+/**
+ * Get the timeline.
+ */
+void twitter_get_home_timeline(struct im_connection *ic, gint64 next_cursor)
+{
+        struct twitter_data *td = ic->proto_data;
+
+        td->home_timeline_obj = NULL;
+        td->home_timeline_done = FALSE;
+
+        char *args[4];
+        args[0] = "cursor";
+        args[1] = g_strdup_printf("%lld", (long long) next_cursor);
+        if (td->timeline_id) {
+                args[2] = "since_id";
+                args[3] = g_strdup_printf("%llu", (long long unsigned int) td->timeline_id);
+        }
+
+        twitter_http(ic, TWITTER_HOME_TIMELINE_URL, twitter_http_get_home_timeline, ic, 0, args,
+                     td->timeline_id ? 4 : 2);
+
+        g_free(args[1]);
+        if (td->timeline_id) {
+                g_free(args[3]);
+        }
+}
+
+/**
+ * Get mentions.
+ */
+void twitter_get_mentions(struct im_connection *ic, gint64 next_cursor)
+{
+        struct twitter_data *td = ic->proto_data;
+
+        td->mentions_obj = NULL;
+        td->mentions_done = FALSE;
+
+        char *args[4];
+        args[0] = "cursor";
+        args[1] = g_strdup_printf("%lld", (long long) next_cursor);
+        if (td->timeline_id) {
+                args[2] = "since_id";
+                args[3] = g_strdup_printf("%llu", (long long unsigned int) td->timeline_id);
+        }
+
+        twitter_http(ic, TWITTER_MENTIONS_URL, twitter_http_get_mentions, ic, 0, args,
+                     td->timeline_id ? 4 : 2);
+
+        g_free(args[1]);
+        if (td->timeline_id) {
+                g_free(args[3]);
+        }
+}
+
 /**
  * Callback for getting the home timeline.
  */
@@ -629 +770 @@
         } else if (req->status_code == 401) {
                 imcb_error(ic, "Authentication failure");
                 imc_logout(ic, FALSE);
-                return;
+                goto end;
         } else {
                 // It didn't go well, output the error and return.
                 if (++td->http_fails >= 5)
                         imcb_error(ic, "Could not retrieve " TWITTER_HOME_TIMELINE_URL ": %s",
                                    twitter_parse_error(req));
 
+                goto end;
+        }
+
+        txl = g_new0(struct twitter_xml_list, 1);
+        txl->list = NULL;
+
+        // Parse the data.
+        parser = xt_new(NULL, txl);
+        xt_feed(parser, req->reply_body, req->body_size);
+        // The root <statuses> node should hold the list of statuses <status>
+        twitter_xt_get_status_list(ic, parser->root, txl);
+        xt_free(parser);
+
+        td->home_timeline_obj = txl;
+
+      end:
+        td->home_timeline_done = TRUE;
+
+        twitter_flush_timeline(ic);
+}
+
+/**
+ * Callback for getting mentions.
+ */
+static void twitter_http_get_mentions(struct http_request *req)
+{
+        struct im_connection *ic = req->data;
+        struct twitter_data *td;
+        struct xt_parser *parser;
+        struct twitter_xml_list *txl;
+
+        // Check if the connection is still active.
+        if (!g_slist_find(twitter_connections, ic))
                 return;
+
+        td = ic->proto_data;
+
+        // Check if the HTTP request went well.
+        if (req->status_code == 200) {
+                td->http_fails = 0;
+                if (!(ic->flags & OPT_LOGGED_IN))
+                        imcb_connected(ic);
+        } else if (req->status_code == 401) {
+                imcb_error(ic, "Authentication failure");
+                imc_logout(ic, FALSE);
+                goto end;
+        } else {
+                // It didn't go well, output the error and return.
+                if (++td->http_fails >= 5)
+                        imcb_error(ic, "Could not retrieve " TWITTER_MENTIONS_URL ": %s",
+                                   twitter_parse_error(req));
+
+                goto end;
         }
 
         txl = g_new0(struct twitter_xml_list, 1);
@@ -649 +842 @@
         twitter_xt_get_status_list(ic, parser->root, txl);
         xt_free(parser);
 
-        // See if the user wants to see the messages in a groupchat window or as private messages.
-        if (txl->list == NULL);
-        else if (g_strcasecmp(set_getstr(&ic->acc->set, "mode"), "chat") == 0)
-                twitter_groupchat(ic, txl->list);
-        else
-                twitter_private_message_chat(ic, txl->list);
+        td->mentions_obj = txl;
 
-        // Free the structure.  
-        txl_free(txl);
+      end:
+        td->mentions_done = TRUE;
+
+        twitter_flush_timeline(ic);
 }
 
 /**
@@ -697 +887 @@
                 td->http_fails = 0;
         }
 
-        if (!td->home_timeline_gc && g_strcasecmp(set_getstr(&ic->acc->set, "mode"), "chat") == 0)
+        if (!td->timeline_gc && g_strcasecmp(set_getstr(&ic->acc->set, "mode"), "chat") == 0)
                 twitter_groupchat_init(ic);
 
         txl = g_new0(struct twitter_xml_list, 1);

twitter_lib.h

@@ -77 +77 @@
 #define TWITTER_BLOCKS_CREATE_URL "/blocks/create/"
 #define TWITTER_BLOCKS_DESTROY_URL "/blocks/destroy/"
 
+void twitter_get_timeline(struct im_connection *ic, gint64 next_cursor);
 void twitter_get_friends_ids(struct im_connection *ic, gint64 next_cursor);
 void twitter_get_home_timeline(struct im_connection *ic, gint64 next_cursor);
+void twitter_get_mentions(struct im_connection *ic, gint64 next_cursor);
 void twitter_get_statuses_friends(struct im_connection *ic, gint64 next_cursor);
 
 void twitter_post_status(struct im_connection *ic, char *msg, guint64 in_reply_to);