source: protocols/twitter/twitter.c @ 29f72b7

Last change on this file since 29f72b7 was 29f72b7, checked in by Wilmer van der Gaast <wilmer@…>, at 2012-11-25T17:43:13Z

Finally cleaned up the show-tweet functions.

  • Property mode set to 100644
File size: 21.5 KB
Line 
1/***************************************************************************\
2*                                                                           *
3*  BitlBee - An IRC to IM gateway                                           *
4*  Simple module to facilitate twitter functionality.                       *
5*                                                                           *
6*  Copyright 2009-2010 Geert Mulders <g.c.w.m.mulders@gmail.com>            *
7*  Copyright 2010-2012 Wilmer van der Gaast <wilmer@gaast.net>              *
8*                                                                           *
9*  This library is free software; you can redistribute it and/or            *
10*  modify it under the terms of the GNU Lesser General Public               *
11*  License as published by the Free Software Foundation, version            *
12*  2.1.                                                                     *
13*                                                                           *
14*  This library is distributed in the hope that it will be useful,          *
15*  but WITHOUT ANY WARRANTY; without even the implied warranty of           *
16*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU        *
17*  Lesser General Public License for more details.                          *
18*                                                                           *
19*  You should have received a copy of the GNU Lesser General Public License *
20*  along with this library; if not, write to the Free Software Foundation,  *
21*  Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA           *
22*                                                                           *
23****************************************************************************/
24
25#include "nogaim.h"
26#include "oauth.h"
27#include "twitter.h"
28#include "twitter_http.h"
29#include "twitter_lib.h"
30#include "url.h"
31
32GSList *twitter_connections = NULL;
33/**
34 * Main loop function
35 */
36gboolean twitter_main_loop(gpointer data, gint fd, b_input_condition cond)
37{
38        struct im_connection *ic = data;
39
40        // Check if we are still logged in...
41        if (!g_slist_find(twitter_connections, ic))
42                return 0;
43
44        // Do stuff..
45        twitter_get_timeline(ic, -1);
46
47        // If we are still logged in run this function again after timeout.
48        return (ic->flags & OPT_LOGGED_IN) == OPT_LOGGED_IN;
49}
50
51static void twitter_main_loop_start(struct im_connection *ic)
52{
53        struct twitter_data *td = ic->proto_data;
54
55        /* Create the room now that we "logged in". */
56        if (td->flags & TWITTER_MODE_CHAT)
57                twitter_groupchat_init(ic);
58
59        imcb_log(ic, "Getting initial statuses");
60
61        // Run this once. After this queue the main loop function (or open the
62        // stream if available).
63        twitter_main_loop(ic, -1, 0);
64       
65        if (set_getbool(&ic->acc->set, "stream")) {
66                /* That fetch was just to get backlog, the stream will give
67                   us the rest. \o/ */
68                twitter_open_stream(ic);
69               
70                /* Stream sends keepalives (empty lines) or actual data at
71                   least twice a minute. Disconnect if this stops. */
72                ic->flags |= OPT_PONGS;
73        } else {
74                /* Not using the streaming API, so keep polling the old-
75                   fashioned way. :-( */
76                td->main_loop_id =
77                    b_timeout_add(set_getint(&ic->acc->set, "fetch_interval") * 1000,
78                                  twitter_main_loop, ic);
79        }
80}
81
82struct groupchat *twitter_groupchat_init(struct im_connection *ic)
83{
84        char *name_hint;
85        struct groupchat *gc;
86        struct twitter_data *td = ic->proto_data;
87        GSList *l;
88
89        if (td->timeline_gc)
90                return td->timeline_gc;
91
92        td->timeline_gc = gc = imcb_chat_new(ic, "twitter/timeline");
93
94        name_hint = g_strdup_printf("%s_%s", td->prefix, ic->acc->user);
95        imcb_chat_name_hint(gc, name_hint);
96        g_free(name_hint);
97
98        for (l = ic->bee->users; l; l = l->next) {
99                bee_user_t *bu = l->data;
100                if (bu->ic == ic)
101                        imcb_chat_add_buddy(gc, bu->handle);
102        }
103        imcb_chat_add_buddy(gc, ic->acc->user);
104       
105        return gc;
106}
107
108static void twitter_oauth_start(struct im_connection *ic);
109
110void twitter_login_finish(struct im_connection *ic)
111{
112        struct twitter_data *td = ic->proto_data;
113
114        td->flags &= ~TWITTER_DOING_TIMELINE;
115
116        if (set_getbool(&ic->acc->set, "oauth") && !td->oauth_info)
117                twitter_oauth_start(ic);
118        else if (!(td->flags & TWITTER_MODE_ONE) &&
119                 !(td->flags & TWITTER_HAVE_FRIENDS)) {
120                imcb_log(ic, "Getting contact list");
121                twitter_get_friends_ids(ic, -1);
122        } else
123                twitter_main_loop_start(ic);
124}
125
126static const struct oauth_service twitter_oauth = {
127        "https://api.twitter.com/oauth/request_token",
128        "https://api.twitter.com/oauth/access_token",
129        "https://api.twitter.com/oauth/authorize",
130        .consumer_key = "xsDNKJuNZYkZyMcu914uEA",
131        .consumer_secret = "FCxqcr0pXKzsF9ajmP57S3VQ8V6Drk4o2QYtqMcOszo",
132};
133
134static const struct oauth_service identica_oauth = {
135        "https://identi.ca/api/oauth/request_token",
136        "https://identi.ca/api/oauth/access_token",
137        "https://identi.ca/api/oauth/authorize",
138        .consumer_key = "e147ff789fcbd8a5a07963afbb43f9da",
139        .consumer_secret = "c596267f277457ec0ce1ab7bb788d828",
140};
141
142static gboolean twitter_oauth_callback(struct oauth_info *info);
143
144static const struct oauth_service *get_oauth_service(struct im_connection *ic)
145{
146        struct twitter_data *td = ic->proto_data;
147
148        if (strstr(td->url_host, "identi.ca"))
149                return &identica_oauth;
150        else
151                return &twitter_oauth;
152
153        /* Could add more services, or allow configuring your own base URL +
154           API keys. */
155}
156
157static void twitter_oauth_start(struct im_connection *ic)
158{
159        struct twitter_data *td = ic->proto_data;
160
161        imcb_log(ic, "Requesting OAuth request token");
162
163        td->oauth_info = oauth_request_token(get_oauth_service(ic), twitter_oauth_callback, ic);
164
165        /* We need help from the user to complete OAuth login, so don't time
166           out on this login. */
167        ic->flags |= OPT_SLOW_LOGIN;
168}
169
170static gboolean twitter_oauth_callback(struct oauth_info *info)
171{
172        struct im_connection *ic = info->data;
173        struct twitter_data *td;
174
175        if (!g_slist_find(twitter_connections, ic))
176                return FALSE;
177
178        td = ic->proto_data;
179        if (info->stage == OAUTH_REQUEST_TOKEN) {
180                char name[strlen(ic->acc->user) + 9], *msg;
181
182                if (info->request_token == NULL) {
183                        imcb_error(ic, "OAuth error: %s", twitter_parse_error(info->http));
184                        imc_logout(ic, TRUE);
185                        return FALSE;
186                }
187
188                sprintf(name, "%s_%s", td->prefix, ic->acc->user);
189                msg = g_strdup_printf("To finish OAuth authentication, please visit "
190                                      "%s and respond with the resulting PIN code.",
191                                      info->auth_url);
192                imcb_buddy_msg(ic, name, msg, 0, 0);
193                g_free(msg);
194        } else if (info->stage == OAUTH_ACCESS_TOKEN) {
195                if (info->token == NULL || info->token_secret == NULL) {
196                        imcb_error(ic, "OAuth error: %s", twitter_parse_error(info->http));
197                        imc_logout(ic, TRUE);
198                        return FALSE;
199                } else {
200                        const char *sn = oauth_params_get(&info->params, "screen_name");
201
202                        if (sn != NULL && ic->acc->prpl->handle_cmp(sn, ic->acc->user) != 0) {
203                                imcb_log(ic, "Warning: You logged in via OAuth as %s "
204                                         "instead of %s.", sn, ic->acc->user);
205                        }
206                        g_free(td->user);
207                        td->user = g_strdup(sn);
208                }
209
210                /* IM mods didn't do this so far and it's ugly but I should
211                   be able to get away with it... */
212                g_free(ic->acc->pass);
213                ic->acc->pass = oauth_to_string(info);
214
215                twitter_login_finish(ic);
216        }
217
218        return TRUE;
219}
220
221
222static char *set_eval_mode(set_t * set, char *value)
223{
224        if (g_strcasecmp(value, "one") == 0 ||
225            g_strcasecmp(value, "many") == 0 || g_strcasecmp(value, "chat") == 0)
226                return value;
227        else
228                return NULL;
229}
230
231int twitter_url_len_diff(gchar *msg, unsigned int target_len)
232{
233        int url_len_diff = 0;
234
235        static GRegex *regex = NULL;
236        GMatchInfo *match_info;
237
238        if (regex == NULL)
239                regex = g_regex_new("(^|\\s)(http(s)?://[^\\s$]+)", 0, 0, NULL);
240       
241        g_regex_match(regex, msg, 0, &match_info);
242        while (g_match_info_matches(match_info)) {
243                gchar *url = g_match_info_fetch(match_info, 2);
244                url_len_diff += target_len - g_utf8_strlen(url, -1);
245                if (g_match_info_fetch(match_info, 3) != NULL)
246                        url_len_diff += 1;
247                g_free(url);
248                g_match_info_next(match_info, NULL);
249        }
250        g_match_info_free(match_info);
251
252        return url_len_diff;
253}
254
255static gboolean twitter_length_check(struct im_connection *ic, gchar * msg)
256{
257        int max = set_getint(&ic->acc->set, "message_length"), len;
258        int target_len = set_getint(&ic->acc->set, "target_url_length");
259        int url_len_diff = 0;
260   
261        if (target_len > 0)
262                url_len_diff = twitter_url_len_diff(msg, target_len);
263
264        if (max == 0 || (len = g_utf8_strlen(msg, -1) + url_len_diff) <= max)
265                return TRUE;
266
267        twitter_log(ic, "Maximum message length exceeded: %d > %d", len, max);
268
269        return FALSE;
270}
271
272static void twitter_init(account_t * acc)
273{
274        set_t *s;
275        char *def_url;
276        char *def_tul;
277
278        if (strcmp(acc->prpl->name, "twitter") == 0) {
279                def_url = TWITTER_API_URL;
280                def_tul = "20";
281        } else {                /* if( strcmp( acc->prpl->name, "identica" ) == 0 ) */
282                def_url = IDENTICA_API_URL;
283                def_tul = "0";
284        }
285
286        s = set_add(&acc->set, "auto_reply_timeout", "10800", set_eval_int, acc);
287
288        s = set_add(&acc->set, "base_url", def_url, NULL, acc);
289        s->flags |= ACC_SET_OFFLINE_ONLY;
290
291        s = set_add(&acc->set, "commands", "true", set_eval_bool, acc);
292
293        s = set_add(&acc->set, "fetch_interval", "60", set_eval_int, acc);
294        s->flags |= ACC_SET_OFFLINE_ONLY;
295
296        s = set_add(&acc->set, "fetch_mentions", "true", set_eval_bool, acc);
297
298        s = set_add(&acc->set, "message_length", "140", set_eval_int, acc);
299
300        s = set_add(&acc->set, "target_url_length", def_tul, set_eval_int, acc);
301
302        s = set_add(&acc->set, "mode", "chat", set_eval_mode, acc);
303        s->flags |= ACC_SET_OFFLINE_ONLY;
304
305        s = set_add(&acc->set, "oauth", "true", set_eval_oauth, acc);
306
307        s = set_add(&acc->set, "show_ids", "true", set_eval_bool, acc);
308
309        s = set_add(&acc->set, "show_old_mentions", "20", set_eval_int, acc);
310
311        s = set_add(&acc->set, "strip_newlines", "false", set_eval_bool, acc);
312       
313        if (strcmp(acc->prpl->name, "twitter") == 0) {
314                s = set_add(&acc->set, "stream", "true", set_eval_bool, acc);
315                s->flags |= ACC_SET_OFFLINE_ONLY;
316        }
317}
318
319/**
320 * Login method. Since the twitter API works with separate HTTP request we
321 * only save the user and pass to the twitter_data object.
322 */
323static void twitter_login(account_t * acc)
324{
325        struct im_connection *ic = imcb_new(acc);
326        struct twitter_data *td;
327        char name[strlen(acc->user) + 9];
328        url_t url;
329        char *s;
330       
331        if (!url_set(&url, set_getstr(&ic->acc->set, "base_url")) ||
332            (url.proto != PROTO_HTTP && url.proto != PROTO_HTTPS)) {
333                imcb_error(ic, "Incorrect API base URL: %s", set_getstr(&ic->acc->set, "base_url"));
334                imc_logout(ic, FALSE);
335                return;
336        }
337
338        if (!strstr(url.host, "twitter.com") &&
339            set_getbool(&ic->acc->set, "stream")) {
340                imcb_error(ic, "Warning: The streaming API is only supported by Twitter, "
341                               "and you seem to be connecting to a different service.");
342        }
343
344        imcb_log(ic, "Connecting");
345
346        twitter_connections = g_slist_append(twitter_connections, ic);
347        td = g_new0(struct twitter_data, 1);
348        ic->proto_data = td;
349        td->user = g_strdup(acc->user);
350
351        td->url_ssl = url.proto == PROTO_HTTPS;
352        td->url_port = url.port;
353        td->url_host = g_strdup(url.host);
354        if (strcmp(url.file, "/") != 0)
355                td->url_path = g_strdup(url.file);
356        else {
357                td->url_path = g_strdup("");
358                if (g_str_has_suffix(url.host, "twitter.com"))
359                        /* May fire for people who turned on HTTPS. */
360                        imcb_error(ic, "Warning: Twitter requires a version number in API calls "
361                                       "now. Try resetting the base_url account setting.");
362        }
363       
364        /* Hacky string mangling: Turn identi.ca into identi.ca and api.twitter.com
365           into twitter, and try to be sensible if we get anything else. */
366        td->prefix = g_strdup(url.host);
367        if (g_str_has_suffix(td->prefix, ".com"))
368                td->prefix[strlen(url.host) - 4] = '\0';
369        if ((s = strrchr(td->prefix, '.')) && strlen(s) > 4) {
370                /* If we have at least 3 chars after the last dot, cut off the rest.
371                   (mostly a www/api prefix or sth) */
372                s = g_strdup(s + 1);
373                g_free(td->prefix);
374                td->prefix = s;
375        }
376       
377        if (strstr(acc->pass, "oauth_token="))
378                td->oauth_info = oauth_from_string(acc->pass, get_oauth_service(ic));
379
380        sprintf(name, "%s_%s", td->prefix, acc->user);
381        imcb_add_buddy(ic, name, NULL);
382        imcb_buddy_status(ic, name, OPT_LOGGED_IN, NULL, NULL);
383
384        td->log = g_new0(struct twitter_log_data, TWITTER_LOG_LENGTH);
385        td->log_id = -1;
386       
387        s = set_getstr(&ic->acc->set, "mode");
388        if (g_strcasecmp(s, "one") == 0)
389                td->flags |= TWITTER_MODE_ONE;
390        else if (g_strcasecmp(s, "many") == 0)
391                td->flags |= TWITTER_MODE_MANY;
392        else
393                td->flags |= TWITTER_MODE_CHAT;
394
395        twitter_login_finish(ic);
396}
397
398/**
399 * Logout method. Just free the twitter_data.
400 */
401static void twitter_logout(struct im_connection *ic)
402{
403        struct twitter_data *td = ic->proto_data;
404
405        // Set the status to logged out.
406        ic->flags &= ~OPT_LOGGED_IN;
407
408        // Remove the main_loop function from the function queue.
409        b_event_remove(td->main_loop_id);
410
411        if (td->timeline_gc)
412                imcb_chat_free(td->timeline_gc);
413
414        if (td) {
415                http_close(td->stream);
416                oauth_info_free(td->oauth_info);
417                g_free(td->user);
418                g_free(td->prefix);
419                g_free(td->url_host);
420                g_free(td->url_path);
421                g_free(td->log);
422                g_free(td);
423        }
424
425        twitter_connections = g_slist_remove(twitter_connections, ic);
426}
427
428static void twitter_handle_command(struct im_connection *ic, char *message);
429
430/**
431 *
432 */
433static int twitter_buddy_msg(struct im_connection *ic, char *who, char *message, int away)
434{
435        struct twitter_data *td = ic->proto_data;
436        int plen = strlen(td->prefix);
437
438        if (g_strncasecmp(who, td->prefix, plen) == 0 && who[plen] == '_' &&
439            g_strcasecmp(who + plen + 1, ic->acc->user) == 0) {
440                if (set_getbool(&ic->acc->set, "oauth") &&
441                    td->oauth_info && td->oauth_info->token == NULL) {
442                        char pin[strlen(message) + 1], *s;
443
444                        strcpy(pin, message);
445                        for (s = pin + sizeof(pin) - 2; s > pin && isspace(*s); s--)
446                                *s = '\0';
447                        for (s = pin; *s && isspace(*s); s++) {
448                        }
449
450                        if (!oauth_access_token(s, td->oauth_info)) {
451                                imcb_error(ic, "OAuth error: %s",
452                                           "Failed to send access token request");
453                                imc_logout(ic, TRUE);
454                                return FALSE;
455                        }
456                } else
457                        twitter_handle_command(ic, message);
458        } else {
459                twitter_direct_messages_new(ic, who, message);
460        }
461        return (0);
462}
463
464/**
465 *
466 */
467static void twitter_set_my_name(struct im_connection *ic, char *info)
468{
469}
470
471static void twitter_get_info(struct im_connection *ic, char *who)
472{
473}
474
475static void twitter_add_buddy(struct im_connection *ic, char *who, char *group)
476{
477        twitter_friendships_create_destroy(ic, who, 1);
478}
479
480static void twitter_remove_buddy(struct im_connection *ic, char *who, char *group)
481{
482        twitter_friendships_create_destroy(ic, who, 0);
483}
484
485static void twitter_chat_msg(struct groupchat *c, char *message, int flags)
486{
487        if (c && message)
488                twitter_handle_command(c->ic, message);
489}
490
491static void twitter_chat_invite(struct groupchat *c, char *who, char *message)
492{
493}
494
495static void twitter_chat_leave(struct groupchat *c)
496{
497        struct twitter_data *td = c->ic->proto_data;
498
499        if (c != td->timeline_gc)
500                return;         /* WTF? */
501
502        /* If the user leaves the channel: Fine. Rejoin him/her once new
503           tweets come in. */
504        imcb_chat_free(td->timeline_gc);
505        td->timeline_gc = NULL;
506}
507
508static void twitter_keepalive(struct im_connection *ic)
509{
510}
511
512static void twitter_add_permit(struct im_connection *ic, char *who)
513{
514}
515
516static void twitter_rem_permit(struct im_connection *ic, char *who)
517{
518}
519
520static void twitter_add_deny(struct im_connection *ic, char *who)
521{
522}
523
524static void twitter_rem_deny(struct im_connection *ic, char *who)
525{
526}
527
528//static char *twitter_set_display_name( set_t *set, char *value )
529//{
530//      return value;
531//}
532
533static void twitter_buddy_data_add(struct bee_user *bu)
534{
535        bu->data = g_new0(struct twitter_user_data, 1);
536}
537
538static void twitter_buddy_data_free(struct bee_user *bu)
539{
540        g_free(bu->data);
541}
542
543/** Convert the given bitlbee tweet ID, bitlbee username, or twitter tweet ID
544 *  into a twitter tweet ID.
545 *
546 *  Returns 0 if the user provides garbage.
547 */
548static guint64 twitter_message_id_from_command_arg(struct im_connection *ic, struct twitter_data *td, char *arg) {
549        struct twitter_user_data *tud;
550        bee_user_t *bu;
551        guint64 id = 0;
552        if (g_str_has_prefix(arg, "#") &&
553                sscanf(arg + 1, "%" G_GUINT64_FORMAT, &id) == 1) {
554                if (id < TWITTER_LOG_LENGTH && td->log)
555                        id = td->log[id].id;
556        } else if ((bu = bee_user_by_handle(ic->bee, ic, arg)) &&
557                (tud = bu->data) && tud->last_id)
558                id = tud->last_id;
559        else if (sscanf(arg, "%" G_GUINT64_FORMAT, &id) == 1){
560                if (id < TWITTER_LOG_LENGTH && td->log)
561                        id = td->log[id].id;
562        }
563        return id;
564}
565
566static void twitter_handle_command(struct im_connection *ic, char *message)
567{
568        struct twitter_data *td = ic->proto_data;
569        char *cmds, **cmd, *new = NULL;
570        guint64 in_reply_to = 0;
571
572        cmds = g_strdup(message);
573        cmd = split_command_parts(cmds);
574
575        if (cmd[0] == NULL) {
576                g_free(cmds);
577                return;
578        } else if (!set_getbool(&ic->acc->set, "commands")) {
579                /* Not supporting commands. */
580        } else if (g_strcasecmp(cmd[0], "undo") == 0) {
581                guint64 id;
582
583                if (cmd[1] == NULL)
584                        twitter_status_destroy(ic, td->last_status_id);
585                else if (sscanf(cmd[1], "%" G_GUINT64_FORMAT, &id) == 1) {
586                        if (id < TWITTER_LOG_LENGTH && td->log)
587                                id = td->log[id].id;
588                       
589                        twitter_status_destroy(ic, id);
590                } else
591                        twitter_log(ic, "Could not undo last action");
592
593                g_free(cmds);
594                return;
595        } else if (g_strcasecmp(cmd[0], "favourite") == 0 && cmd[1]) {
596                guint64 id;
597                if ((id = twitter_message_id_from_command_arg(ic, td, cmd[1]))) {
598                        twitter_favourite_tweet(ic, id);
599                } else {
600                        twitter_log(ic, "Please provide a message ID or username.");
601                }
602                g_free(cmds);
603                return;
604        } else if (g_strcasecmp(cmd[0], "follow") == 0 && cmd[1]) {
605                twitter_add_buddy(ic, cmd[1], NULL);
606                g_free(cmds);
607                return;
608        } else if (g_strcasecmp(cmd[0], "unfollow") == 0 && cmd[1]) {
609                twitter_remove_buddy(ic, cmd[1], NULL);
610                g_free(cmds);
611                return;
612        } else if ((g_strcasecmp(cmd[0], "report") == 0 ||
613                    g_strcasecmp(cmd[0], "spam") == 0) && cmd[1]) {
614                char * screen_name;
615                guint64 id;
616                screen_name = cmd[1];
617                /* Report nominally works on users but look up the user who
618                   posted the given ID if the user wants to do it that way */
619                if (g_str_has_prefix(cmd[1], "#") &&
620                    sscanf(cmd[1] + 1, "%" G_GUINT64_FORMAT, &id) == 1) {
621                        if (id < TWITTER_LOG_LENGTH && td->log) {
622                                if (g_slist_find(ic->bee->users, td->log[id].bu)) {
623                                        screen_name = td->log[id].bu->handle;
624                                }
625                        }
626                }
627                twitter_report_spam(ic, screen_name);
628                g_free(cmds);
629                return;
630        } else if (g_strcasecmp(cmd[0], "rt") == 0 && cmd[1]) {
631                guint64 id = twitter_message_id_from_command_arg(ic, td, cmd[1]);
632
633                td->last_status_id = 0;
634                if (id)
635                        twitter_status_retweet(ic, id);
636                else
637                        twitter_log(ic, "User `%s' does not exist or didn't "
638                                    "post any statuses recently", cmd[1]);
639
640                g_free(cmds);
641                return;
642        } else if (g_strcasecmp(cmd[0], "reply") == 0 && cmd[1] && cmd[2]) {
643                struct twitter_user_data *tud;
644                bee_user_t *bu = NULL;
645                guint64 id = 0;
646
647                if (g_str_has_prefix(cmd[1], "#") &&
648                    sscanf(cmd[1] + 1, "%" G_GUINT64_FORMAT, &id) == 1 &&
649                    (id < TWITTER_LOG_LENGTH) && td->log) {
650                        bu = td->log[id].bu;
651                        if (g_slist_find(ic->bee->users, bu))
652                                id = td->log[id].id;
653                        else
654                                bu = NULL;
655                } else if ((bu = bee_user_by_handle(ic->bee, ic, cmd[1])) &&
656                    (tud = bu->data) && tud->last_id) {
657                        id = tud->last_id;
658                } else if (sscanf(cmd[1], "%" G_GUINT64_FORMAT, &id) == 1 &&
659                           (id < TWITTER_LOG_LENGTH) && td->log) {
660                        bu = td->log[id].bu;
661                        if (g_slist_find(ic->bee->users, bu))
662                                id = td->log[id].id;
663                        else
664                                bu = NULL;
665                }
666
667                if (!id || !bu) {
668                        twitter_log(ic, "User `%s' does not exist or didn't "
669                                    "post any statuses recently", cmd[1]);
670                        g_free(cmds);
671                        return;
672                }
673                message = new = g_strdup_printf("@%s %s", bu->handle, message + (cmd[2] - cmd[0]));
674                in_reply_to = id;
675        } else if (g_strcasecmp(cmd[0], "post") == 0) {
676                message += 5;
677        }
678
679        {
680                char *s;
681                bee_user_t *bu;
682
683                if (!twitter_length_check(ic, message)) {
684                        g_free(new);
685                        g_free(cmds);
686                        return;
687                }
688
689                s = cmd[0] + strlen(cmd[0]) - 1;
690                if (!new && s > cmd[0] && (*s == ':' || *s == ',')) {
691                        *s = '\0';
692
693                        if ((bu = bee_user_by_handle(ic->bee, ic, cmd[0]))) {
694                                struct twitter_user_data *tud = bu->data;
695
696                                new = g_strdup_printf("@%s %s", bu->handle,
697                                                      message + (s - cmd[0]) + 2);
698                                message = new;
699
700                                if (time(NULL) < tud->last_time +
701                                    set_getint(&ic->acc->set, "auto_reply_timeout"))
702                                        in_reply_to = tud->last_id;
703                        }
704                }
705
706                /* If the user runs undo between this request and its response
707                   this would delete the second-last Tweet. Prevent that. */
708                td->last_status_id = 0;
709                twitter_post_status(ic, message, in_reply_to);
710                g_free(new);
711        }
712        g_free(cmds);
713}
714
715void twitter_log(struct im_connection *ic, char *format, ... )
716{
717        struct twitter_data *td = ic->proto_data;
718        va_list params;
719        char *text;
720       
721        va_start(params, format);
722        text = g_strdup_vprintf(format, params);
723        va_end(params);
724       
725        if (td->timeline_gc)
726                imcb_chat_log(td->timeline_gc, "%s", text);
727        else
728                imcb_log(ic, "%s", text);
729       
730        g_free(text);
731}
732
733
734void twitter_initmodule()
735{
736        struct prpl *ret = g_new0(struct prpl, 1);
737
738        ret->options = OPT_NOOTR;
739        ret->name = "twitter";
740        ret->login = twitter_login;
741        ret->init = twitter_init;
742        ret->logout = twitter_logout;
743        ret->buddy_msg = twitter_buddy_msg;
744        ret->get_info = twitter_get_info;
745        ret->set_my_name = twitter_set_my_name;
746        ret->add_buddy = twitter_add_buddy;
747        ret->remove_buddy = twitter_remove_buddy;
748        ret->chat_msg = twitter_chat_msg;
749        ret->chat_invite = twitter_chat_invite;
750        ret->chat_leave = twitter_chat_leave;
751        ret->keepalive = twitter_keepalive;
752        ret->add_permit = twitter_add_permit;
753        ret->rem_permit = twitter_rem_permit;
754        ret->add_deny = twitter_add_deny;
755        ret->rem_deny = twitter_rem_deny;
756        ret->buddy_data_add = twitter_buddy_data_add;
757        ret->buddy_data_free = twitter_buddy_data_free;
758        ret->handle_cmp = g_strcasecmp;
759
760        register_protocol(ret);
761
762        /* And an identi.ca variant: */
763        ret = g_memdup(ret, sizeof(struct prpl));
764        ret->name = "identica";
765        register_protocol(ret);
766}
Note: See TracBrowser for help on using the repository browser.