source: protocols/twitter/twitter.c @ 1201fcb

Last change on this file since 1201fcb was 1201fcb, checked in by dequis <dx@…>, at 2015-06-08T03:42:11Z

twitter: show full url in the url command, with username

By asking the server for the username.

Storing the username somewhere would have made sense, but this command
isn't going to be used very often, so, whatever.

  • Property mode set to 100644
File size: 28.6 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-2013 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
34static int twitter_filter_cmp(struct twitter_filter *tf1,
35                              struct twitter_filter *tf2)
36{
37        int i1 = 0;
38        int i2 = 0;
39        int i;
40
41        static const twitter_filter_type_t types[] = {
42                /* Order of the types */
43                TWITTER_FILTER_TYPE_FOLLOW,
44                TWITTER_FILTER_TYPE_TRACK
45        };
46
47        for (i = 0; i < G_N_ELEMENTS(types); i++) {
48                if (types[i] == tf1->type) {
49                        i1 = i + 1;
50                        break;
51                }
52        }
53
54        for (i = 0; i < G_N_ELEMENTS(types); i++) {
55                if (types[i] == tf2->type) {
56                        i2 = i + 1;
57                        break;
58                }
59        }
60
61        if (i1 != i2) {
62                /* With different types, return their difference */
63                return i1 - i2;
64        }
65
66        /* With the same type, return the text comparison */
67        return g_strcasecmp(tf1->text, tf2->text);
68}
69
70static gboolean twitter_filter_update(gpointer data, gint fd,
71                                      b_input_condition cond)
72{
73        struct im_connection *ic = data;
74        struct twitter_data *td = ic->proto_data;
75
76        if (td->filters) {
77                twitter_open_filter_stream(ic);
78        } else if (td->filter_stream) {
79                http_close(td->filter_stream);
80                td->filter_stream = NULL;
81        }
82
83        td->filter_update_id = 0;
84        return FALSE;
85}
86
87static struct twitter_filter *twitter_filter_get(struct groupchat *c,
88                                                 twitter_filter_type_t type,
89                                                 const char *text)
90{
91        struct twitter_data *td = c->ic->proto_data;
92        struct twitter_filter *tf = NULL;
93        struct twitter_filter tfc = { type, (char *) text };
94        GSList *l;
95
96        for (l = td->filters; l; l = g_slist_next(l)) {
97                tf = l->data;
98
99                if (twitter_filter_cmp(tf, &tfc) == 0) {
100                        break;
101                }
102
103                tf = NULL;
104        }
105
106        if (!tf) {
107                tf = g_new0(struct twitter_filter, 1);
108                tf->type = type;
109                tf->text = g_strdup(text);
110                td->filters = g_slist_prepend(td->filters, tf);
111        }
112
113        if (!g_slist_find(tf->groupchats, c)) {
114                tf->groupchats = g_slist_prepend(tf->groupchats, c);
115        }
116
117        if (td->filter_update_id > 0) {
118                b_event_remove(td->filter_update_id);
119        }
120
121        /* Wait for other possible filter changes to avoid request spam */
122        td->filter_update_id = b_timeout_add(TWITTER_FILTER_UPDATE_WAIT,
123                                             twitter_filter_update, c->ic);
124        return tf;
125}
126
127static void twitter_filter_free(struct twitter_filter *tf)
128{
129        g_slist_free(tf->groupchats);
130        g_free(tf->text);
131        g_free(tf);
132}
133
134static void twitter_filter_remove(struct groupchat *c)
135{
136        struct twitter_data *td = c->ic->proto_data;
137        struct twitter_filter *tf;
138        GSList *l = td->filters;
139        GSList *p;
140
141        while (l != NULL) {
142                tf = l->data;
143                tf->groupchats = g_slist_remove(tf->groupchats, c);
144
145                p = l;
146                l = g_slist_next(l);
147
148                if (!tf->groupchats) {
149                        twitter_filter_free(tf);
150                        td->filters = g_slist_delete_link(td->filters, p);
151                }
152        }
153
154        if (td->filter_update_id > 0) {
155                b_event_remove(td->filter_update_id);
156        }
157
158        /* Wait for other possible filter changes to avoid request spam */
159        td->filter_update_id = b_timeout_add(TWITTER_FILTER_UPDATE_WAIT,
160                                             twitter_filter_update, c->ic);
161}
162
163static void twitter_filter_remove_all(struct im_connection *ic)
164{
165        struct twitter_data *td = ic->proto_data;
166        GSList *chats = NULL;
167        struct twitter_filter *tf;
168        GSList *l = td->filters;
169        GSList *p;
170
171        while (l != NULL) {
172                tf = l->data;
173
174                /* Build up a list of groupchats to be freed */
175                for (p = tf->groupchats; p; p = g_slist_next(p)) {
176                        if (!g_slist_find(chats, p->data)) {
177                                chats = g_slist_prepend(chats, p->data);
178                        }
179                }
180
181                p = l;
182                l = g_slist_next(l);
183                twitter_filter_free(p->data);
184                td->filters = g_slist_delete_link(td->filters, p);
185        }
186
187        l = chats;
188
189        while (l != NULL) {
190                p = l;
191                l = g_slist_next(l);
192
193                /* Freed each remaining groupchat */
194                imcb_chat_free(p->data);
195                chats = g_slist_delete_link(chats, p);
196        }
197
198        if (td->filter_stream) {
199                http_close(td->filter_stream);
200                td->filter_stream = NULL;
201        }
202}
203
204static GSList *twitter_filter_parse(struct groupchat *c, const char *text)
205{
206        char **fs = g_strsplit(text, ";", 0);
207        GSList *ret = NULL;
208        struct twitter_filter *tf;
209        char **f;
210        char *v;
211        int i;
212        int t;
213
214        static const twitter_filter_type_t types[] = {
215                TWITTER_FILTER_TYPE_FOLLOW,
216                TWITTER_FILTER_TYPE_TRACK
217        };
218
219        static const char *typestrs[] = {
220                "follow",
221                "track"
222        };
223
224        for (f = fs; *f; f++) {
225                if ((v = strchr(*f, ':')) == NULL) {
226                        continue;
227                }
228
229                *(v++) = 0;
230
231                for (t = -1, i = 0; i < G_N_ELEMENTS(types); i++) {
232                        if (g_strcasecmp(typestrs[i], *f) == 0) {
233                                t = i;
234                                break;
235                        }
236                }
237
238                if (t < 0 || strlen(v) == 0) {
239                        continue;
240                }
241
242                tf = twitter_filter_get(c, types[t], v);
243                ret = g_slist_prepend(ret, tf);
244        }
245
246        g_strfreev(fs);
247        return ret;
248}
249
250/**
251 * Main loop function
252 */
253gboolean twitter_main_loop(gpointer data, gint fd, b_input_condition cond)
254{
255        struct im_connection *ic = data;
256
257        // Check if we are still logged in...
258        if (!g_slist_find(twitter_connections, ic)) {
259                return FALSE;
260        }
261
262        // Do stuff..
263        return twitter_get_timeline(ic, -1) &&
264               ((ic->flags & OPT_LOGGED_IN) == OPT_LOGGED_IN);
265}
266
267static void twitter_main_loop_start(struct im_connection *ic)
268{
269        struct twitter_data *td = ic->proto_data;
270
271        char *last_tweet = set_getstr(&ic->acc->set, "_last_tweet");
272
273        if (last_tweet) {
274                td->timeline_id = g_ascii_strtoull(last_tweet, NULL, 0);
275        }
276
277        /* Create the room now that we "logged in". */
278        if (td->flags & TWITTER_MODE_CHAT) {
279                twitter_groupchat_init(ic);
280        }
281
282        imcb_log(ic, "Getting initial statuses");
283
284        // Run this once. After this queue the main loop function (or open the
285        // stream if available).
286        twitter_main_loop(ic, -1, 0);
287
288        if (set_getbool(&ic->acc->set, "stream")) {
289                /* That fetch was just to get backlog, the stream will give
290                   us the rest. \o/ */
291                twitter_open_stream(ic);
292
293                /* Stream sends keepalives (empty lines) or actual data at
294                   least twice a minute. Disconnect if this stops. */
295                ic->flags |= OPT_PONGS;
296        } else {
297                /* Not using the streaming API, so keep polling the old-
298                   fashioned way. :-( */
299                td->main_loop_id =
300                        b_timeout_add(set_getint(&ic->acc->set, "fetch_interval") * 1000,
301                                      twitter_main_loop, ic);
302        }
303}
304
305struct groupchat *twitter_groupchat_init(struct im_connection *ic)
306{
307        char *name_hint;
308        struct groupchat *gc;
309        struct twitter_data *td = ic->proto_data;
310        GSList *l;
311
312        if (td->timeline_gc) {
313                return td->timeline_gc;
314        }
315
316        td->timeline_gc = gc = imcb_chat_new(ic, "twitter/timeline");
317
318        name_hint = g_strdup_printf("%s_%s", td->prefix, ic->acc->user);
319        imcb_chat_name_hint(gc, name_hint);
320        g_free(name_hint);
321
322        for (l = ic->bee->users; l; l = l->next) {
323                bee_user_t *bu = l->data;
324                if (bu->ic == ic) {
325                        imcb_chat_add_buddy(gc, bu->handle);
326                }
327        }
328        imcb_chat_add_buddy(gc, ic->acc->user);
329
330        return gc;
331}
332
333static void twitter_oauth_start(struct im_connection *ic);
334
335void twitter_login_finish(struct im_connection *ic)
336{
337        struct twitter_data *td = ic->proto_data;
338
339        td->flags &= ~TWITTER_DOING_TIMELINE;
340
341        if (set_getbool(&ic->acc->set, "oauth") && !td->oauth_info) {
342                twitter_oauth_start(ic);
343        } else if (!(td->flags & TWITTER_MODE_ONE) &&
344                   !(td->flags & TWITTER_HAVE_FRIENDS)) {
345                imcb_log(ic, "Getting contact list");
346                twitter_get_friends_ids(ic, -1);
347        } else {
348                twitter_main_loop_start(ic);
349        }
350}
351
352static const struct oauth_service twitter_oauth = {
353        "https://api.twitter.com/oauth/request_token",
354        "https://api.twitter.com/oauth/access_token",
355        "https://api.twitter.com/oauth/authorize",
356        .consumer_key = "xsDNKJuNZYkZyMcu914uEA",
357        .consumer_secret = "FCxqcr0pXKzsF9ajmP57S3VQ8V6Drk4o2QYtqMcOszo",
358};
359
360static const struct oauth_service identica_oauth = {
361        "https://identi.ca/api/oauth/request_token",
362        "https://identi.ca/api/oauth/access_token",
363        "https://identi.ca/api/oauth/authorize",
364        .consumer_key = "e147ff789fcbd8a5a07963afbb43f9da",
365        .consumer_secret = "c596267f277457ec0ce1ab7bb788d828",
366};
367
368static gboolean twitter_oauth_callback(struct oauth_info *info);
369
370static const struct oauth_service *get_oauth_service(struct im_connection *ic)
371{
372        struct twitter_data *td = ic->proto_data;
373
374        if (strstr(td->url_host, "identi.ca")) {
375                return &identica_oauth;
376        } else {
377                return &twitter_oauth;
378        }
379
380        /* Could add more services, or allow configuring your own base URL +
381           API keys. */
382}
383
384static void twitter_oauth_start(struct im_connection *ic)
385{
386        struct twitter_data *td = ic->proto_data;
387        const char *url = set_getstr(&ic->acc->set, "base_url");
388
389        imcb_log(ic, "Requesting OAuth request token");
390
391        if (!strstr(url, "twitter.com") && !strstr(url, "identi.ca")) {
392                imcb_log(ic, "Warning: OAuth only works with identi.ca and "
393                         "Twitter.");
394        }
395
396        td->oauth_info = oauth_request_token(get_oauth_service(ic), twitter_oauth_callback, ic);
397
398        /* We need help from the user to complete OAuth login, so don't time
399           out on this login. */
400        ic->flags |= OPT_SLOW_LOGIN;
401}
402
403static gboolean twitter_oauth_callback(struct oauth_info *info)
404{
405        struct im_connection *ic = info->data;
406        struct twitter_data *td;
407
408        if (!g_slist_find(twitter_connections, ic)) {
409                return FALSE;
410        }
411
412        td = ic->proto_data;
413        if (info->stage == OAUTH_REQUEST_TOKEN) {
414                char *name, *msg;
415
416                if (info->request_token == NULL) {
417                        imcb_error(ic, "OAuth error: %s", twitter_parse_error(info->http));
418                        imc_logout(ic, TRUE);
419                        return FALSE;
420                }
421
422                name = g_strdup_printf("%s_%s", td->prefix, ic->acc->user);
423                msg = g_strdup_printf("To finish OAuth authentication, please visit "
424                                      "%s and respond with the resulting PIN code.",
425                                      info->auth_url);
426                imcb_buddy_msg(ic, name, msg, 0, 0);
427                g_free(name);
428                g_free(msg);
429        } else if (info->stage == OAUTH_ACCESS_TOKEN) {
430                const char *sn;
431
432                if (info->token == NULL || info->token_secret == NULL) {
433                        imcb_error(ic, "OAuth error: %s", twitter_parse_error(info->http));
434                        imc_logout(ic, TRUE);
435                        return FALSE;
436                }
437
438                if ((sn = oauth_params_get(&info->params, "screen_name"))) {
439                        if (ic->acc->prpl->handle_cmp(sn, ic->acc->user) != 0) {
440                                imcb_log(ic, "Warning: You logged in via OAuth as %s "
441                                         "instead of %s.", sn, ic->acc->user);
442                        }
443                        g_free(td->user);
444                        td->user = g_strdup(sn);
445                }
446
447                /* IM mods didn't do this so far and it's ugly but I should
448                   be able to get away with it... */
449                g_free(ic->acc->pass);
450                ic->acc->pass = oauth_to_string(info);
451
452                twitter_login_finish(ic);
453        }
454
455        return TRUE;
456}
457
458int twitter_url_len_diff(gchar *msg, unsigned int target_len)
459{
460        int url_len_diff = 0;
461
462        static GRegex *regex = NULL;
463        GMatchInfo *match_info;
464
465        if (regex == NULL) {
466                regex = g_regex_new("(^|\\s)(http(s)?://[^\\s$]+)", 0, 0, NULL);
467        }
468
469        g_regex_match(regex, msg, 0, &match_info);
470        while (g_match_info_matches(match_info)) {
471                gchar *s, *url;
472
473                url = g_match_info_fetch(match_info, 2);
474                url_len_diff += target_len - g_utf8_strlen(url, -1);
475
476                /* Add another character for https://t.co/... URLs */
477                if ((s = g_match_info_fetch(match_info, 3))) {
478                        url_len_diff += 1;
479                        g_free(s);
480                }
481                g_free(url);
482                g_match_info_next(match_info, NULL);
483        }
484        g_match_info_free(match_info);
485
486        return url_len_diff;
487}
488
489int twitter_message_len(gchar *msg, int target_len)
490{
491        int url_len_diff = 0;
492
493        if (target_len > 0) {
494                url_len_diff = twitter_url_len_diff(msg, target_len);
495        }
496
497        return g_utf8_strlen(msg, -1) + url_len_diff;
498}
499
500static gboolean twitter_length_check(struct im_connection *ic, gchar * msg)
501{
502        int max = set_getint(&ic->acc->set, "message_length");
503        int target_len = set_getint(&ic->acc->set, "target_url_length");
504        int len = twitter_message_len(msg, target_len);
505
506        if (max == 0 || len <= max) {
507                return TRUE;
508        }
509
510        twitter_log(ic, "Maximum message length exceeded: %d > %d", len, max);
511
512        return FALSE;
513}
514
515static char *set_eval_commands(set_t * set, char *value)
516{
517        if (g_strcasecmp(value, "strict") == 0) {
518                return value;
519        } else {
520                return set_eval_bool(set, value);
521        }
522}
523
524static char *set_eval_mode(set_t * set, char *value)
525{
526        if (g_strcasecmp(value, "one") == 0 ||
527            g_strcasecmp(value, "many") == 0 || g_strcasecmp(value, "chat") == 0) {
528                return value;
529        } else {
530                return NULL;
531        }
532}
533
534static void twitter_init(account_t * acc)
535{
536        set_t *s;
537        char *def_url;
538        char *def_tul;
539        char *def_mentions;
540
541        if (strcmp(acc->prpl->name, "twitter") == 0) {
542                def_url = TWITTER_API_URL;
543                def_tul = "22";
544                def_mentions = "true";
545        } else {                /* if( strcmp( acc->prpl->name, "identica" ) == 0 ) */
546                def_url = IDENTICA_API_URL;
547                def_tul = "0";
548                def_mentions = "false";
549        }
550
551        s = set_add(&acc->set, "auto_reply_timeout", "10800", set_eval_int, acc);
552
553        s = set_add(&acc->set, "base_url", def_url, NULL, acc);
554        s->flags |= ACC_SET_OFFLINE_ONLY;
555
556        s = set_add(&acc->set, "commands", "true", set_eval_commands, acc);
557
558        s = set_add(&acc->set, "fetch_interval", "60", set_eval_int, acc);
559        s->flags |= ACC_SET_OFFLINE_ONLY;
560
561        s = set_add(&acc->set, "fetch_mentions", def_mentions, set_eval_bool, acc);
562
563        s = set_add(&acc->set, "message_length", "140", set_eval_int, acc);
564
565        s = set_add(&acc->set, "target_url_length", def_tul, set_eval_int, acc);
566
567        s = set_add(&acc->set, "mode", "chat", set_eval_mode, acc);
568        s->flags |= ACC_SET_OFFLINE_ONLY;
569
570        s = set_add(&acc->set, "oauth", "true", set_eval_oauth, acc);
571
572        s = set_add(&acc->set, "show_ids", "true", set_eval_bool, acc);
573
574        s = set_add(&acc->set, "show_old_mentions", "0", set_eval_int, acc);
575
576        s = set_add(&acc->set, "strip_newlines", "false", set_eval_bool, acc);
577
578        s = set_add(&acc->set, "_last_tweet", "0", NULL, acc);
579        s->flags |= SET_HIDDEN | SET_NOSAVE;
580
581        if (strcmp(acc->prpl->name, "twitter") == 0) {
582                s = set_add(&acc->set, "stream", "true", set_eval_bool, acc);
583                s->flags |= ACC_SET_OFFLINE_ONLY;
584        }
585}
586
587/**
588 * Login method. Since the twitter API works with separate HTTP request we
589 * only save the user and pass to the twitter_data object.
590 */
591static void twitter_login(account_t * acc)
592{
593        struct im_connection *ic = imcb_new(acc);
594        struct twitter_data *td;
595        char name[strlen(acc->user) + 9];
596        url_t url;
597        char *s;
598
599        if (!url_set(&url, set_getstr(&ic->acc->set, "base_url")) ||
600            (url.proto != PROTO_HTTP && url.proto != PROTO_HTTPS)) {
601                imcb_error(ic, "Incorrect API base URL: %s", set_getstr(&ic->acc->set, "base_url"));
602                imc_logout(ic, FALSE);
603                return;
604        }
605
606        if (!strstr(url.host, "twitter.com") &&
607            set_getbool(&ic->acc->set, "stream")) {
608                imcb_error(ic, "Warning: The streaming API is only supported by Twitter, "
609                           "and you seem to be connecting to a different service.");
610        }
611
612        imcb_log(ic, "Connecting");
613
614        twitter_connections = g_slist_append(twitter_connections, ic);
615        td = g_new0(struct twitter_data, 1);
616        ic->proto_data = td;
617        td->user = g_strdup(acc->user);
618
619        td->url_ssl = url.proto == PROTO_HTTPS;
620        td->url_port = url.port;
621        td->url_host = g_strdup(url.host);
622        if (strcmp(url.file, "/") != 0) {
623                td->url_path = g_strdup(url.file);
624        } else {
625                td->url_path = g_strdup("");
626                if (g_str_has_suffix(url.host, "twitter.com")) {
627                        /* May fire for people who turned on HTTPS. */
628                        imcb_error(ic, "Warning: Twitter requires a version number in API calls "
629                                   "now. Try resetting the base_url account setting.");
630                }
631        }
632
633        /* Hacky string mangling: Turn identi.ca into identi.ca and api.twitter.com
634           into twitter, and try to be sensible if we get anything else. */
635        td->prefix = g_strdup(url.host);
636        if (g_str_has_suffix(td->prefix, ".com")) {
637                td->prefix[strlen(url.host) - 4] = '\0';
638        }
639        if ((s = strrchr(td->prefix, '.')) && strlen(s) > 4) {
640                /* If we have at least 3 chars after the last dot, cut off the rest.
641                   (mostly a www/api prefix or sth) */
642                s = g_strdup(s + 1);
643                g_free(td->prefix);
644                td->prefix = s;
645        }
646
647        if (strstr(acc->pass, "oauth_token=")) {
648                td->oauth_info = oauth_from_string(acc->pass, get_oauth_service(ic));
649        }
650
651        sprintf(name, "%s_%s", td->prefix, acc->user);
652        imcb_add_buddy(ic, name, NULL);
653        imcb_buddy_status(ic, name, OPT_LOGGED_IN, NULL, NULL);
654
655        td->log = g_new0(struct twitter_log_data, TWITTER_LOG_LENGTH);
656        td->log_id = -1;
657
658        s = set_getstr(&ic->acc->set, "mode");
659        if (g_strcasecmp(s, "one") == 0) {
660                td->flags |= TWITTER_MODE_ONE;
661        } else if (g_strcasecmp(s, "many") == 0) {
662                td->flags |= TWITTER_MODE_MANY;
663        } else {
664                td->flags |= TWITTER_MODE_CHAT;
665        }
666
667        twitter_login_finish(ic);
668}
669
670/**
671 * Logout method. Just free the twitter_data.
672 */
673static void twitter_logout(struct im_connection *ic)
674{
675        struct twitter_data *td = ic->proto_data;
676
677        // Set the status to logged out.
678        ic->flags &= ~OPT_LOGGED_IN;
679
680        // Remove the main_loop function from the function queue.
681        b_event_remove(td->main_loop_id);
682
683        if (td->timeline_gc) {
684                imcb_chat_free(td->timeline_gc);
685        }
686
687        if (td) {
688                if (td->filter_update_id > 0) {
689                        b_event_remove(td->filter_update_id);
690                }
691
692                http_close(td->stream);
693                twitter_filter_remove_all(ic);
694                oauth_info_free(td->oauth_info);
695                g_free(td->user);
696                g_free(td->prefix);
697                g_free(td->url_host);
698                g_free(td->url_path);
699                g_free(td->log);
700                g_free(td);
701        }
702
703        twitter_connections = g_slist_remove(twitter_connections, ic);
704}
705
706static void twitter_handle_command(struct im_connection *ic, char *message);
707
708/**
709 *
710 */
711static int twitter_buddy_msg(struct im_connection *ic, char *who, char *message, int away)
712{
713        struct twitter_data *td = ic->proto_data;
714        int plen = strlen(td->prefix);
715
716        if (g_strncasecmp(who, td->prefix, plen) == 0 && who[plen] == '_' &&
717            g_strcasecmp(who + plen + 1, ic->acc->user) == 0) {
718                if (set_getbool(&ic->acc->set, "oauth") &&
719                    td->oauth_info && td->oauth_info->token == NULL) {
720                        char pin[strlen(message) + 1], *s;
721
722                        strcpy(pin, message);
723                        for (s = pin + sizeof(pin) - 2; s > pin && g_ascii_isspace(*s); s--) {
724                                *s = '\0';
725                        }
726                        for (s = pin; *s && g_ascii_isspace(*s); s++) {
727                        }
728
729                        if (!oauth_access_token(s, td->oauth_info)) {
730                                imcb_error(ic, "OAuth error: %s",
731                                           "Failed to send access token request");
732                                imc_logout(ic, TRUE);
733                                return FALSE;
734                        }
735                } else {
736                        twitter_handle_command(ic, message);
737                }
738        } else {
739                twitter_direct_messages_new(ic, who, message);
740        }
741        return (0);
742}
743
744static void twitter_get_info(struct im_connection *ic, char *who)
745{
746}
747
748static void twitter_add_buddy(struct im_connection *ic, char *who, char *group)
749{
750        twitter_friendships_create_destroy(ic, who, 1);
751}
752
753static void twitter_remove_buddy(struct im_connection *ic, char *who, char *group)
754{
755        twitter_friendships_create_destroy(ic, who, 0);
756}
757
758static void twitter_chat_msg(struct groupchat *c, char *message, int flags)
759{
760        if (c && message) {
761                twitter_handle_command(c->ic, message);
762        }
763}
764
765static void twitter_chat_invite(struct groupchat *c, char *who, char *message)
766{
767}
768
769static struct groupchat *twitter_chat_join(struct im_connection *ic,
770                                           const char *room, const char *nick,
771                                           const char *password, set_t **sets)
772{
773        struct groupchat *c = imcb_chat_new(ic, room);
774        GSList *fs = twitter_filter_parse(c, room);
775        GString *topic = g_string_new("");
776        struct twitter_filter *tf;
777        GSList *l;
778
779        fs = g_slist_sort(fs, (GCompareFunc) twitter_filter_cmp);
780
781        for (l = fs; l; l = g_slist_next(l)) {
782                tf = l->data;
783
784                if (topic->len > 0) {
785                        g_string_append(topic, ", ");
786                }
787
788                if (tf->type == TWITTER_FILTER_TYPE_FOLLOW) {
789                        g_string_append_c(topic, '@');
790                }
791
792                g_string_append(topic, tf->text);
793        }
794
795        if (topic->len > 0) {
796                g_string_prepend(topic, "Twitter Filter: ");
797        }
798
799        imcb_chat_topic(c, NULL, topic->str, 0);
800        imcb_chat_add_buddy(c, ic->acc->user);
801
802        if (topic->len == 0) {
803                imcb_error(ic, "Failed to handle any filters");
804                imcb_chat_free(c);
805                c = NULL;
806        }
807
808        g_string_free(topic, TRUE);
809        g_slist_free(fs);
810
811        return c;
812}
813
814static void twitter_chat_leave(struct groupchat *c)
815{
816        struct twitter_data *td = c->ic->proto_data;
817
818        if (c != td->timeline_gc) {
819                twitter_filter_remove(c);
820                imcb_chat_free(c);
821                return;
822        }
823
824        /* If the user leaves the channel: Fine. Rejoin him/her once new
825           tweets come in. */
826        imcb_chat_free(td->timeline_gc);
827        td->timeline_gc = NULL;
828}
829
830static void twitter_keepalive(struct im_connection *ic)
831{
832}
833
834static void twitter_add_permit(struct im_connection *ic, char *who)
835{
836}
837
838static void twitter_rem_permit(struct im_connection *ic, char *who)
839{
840}
841
842static void twitter_add_deny(struct im_connection *ic, char *who)
843{
844}
845
846static void twitter_rem_deny(struct im_connection *ic, char *who)
847{
848}
849
850//static char *twitter_set_display_name( set_t *set, char *value )
851//{
852//      return value;
853//}
854
855static void twitter_buddy_data_add(struct bee_user *bu)
856{
857        bu->data = g_new0(struct twitter_user_data, 1);
858}
859
860static void twitter_buddy_data_free(struct bee_user *bu)
861{
862        g_free(bu->data);
863}
864
865bee_user_t twitter_log_local_user;
866
867/** Convert the given bitlbee tweet ID, bitlbee username, or twitter tweet ID
868 *  into a twitter tweet ID.
869 *
870 *  Returns 0 if the user provides garbage.
871 */
872static guint64 twitter_message_id_from_command_arg(struct im_connection *ic, char *arg, bee_user_t **bu_)
873{
874        struct twitter_data *td = ic->proto_data;
875        struct twitter_user_data *tud;
876        bee_user_t *bu = NULL;
877        guint64 id = 0;
878
879        if (bu_) {
880                *bu_ = NULL;
881        }
882        if (!arg || !arg[0]) {
883                return 0;
884        }
885
886        if (arg[0] != '#' && (bu = bee_user_by_handle(ic->bee, ic, arg))) {
887                if ((tud = bu->data)) {
888                        id = tud->last_id;
889                }
890        } else {
891                if (arg[0] == '#') {
892                        arg++;
893                }
894                if (parse_int64(arg, 16, &id) && id < TWITTER_LOG_LENGTH) {
895                        bu = td->log[id].bu;
896                        id = td->log[id].id;
897                } else if (parse_int64(arg, 10, &id)) {
898                        /* Allow normal tweet IDs as well; not a very useful
899                           feature but it's always been there. Just ignore
900                           very low IDs to avoid accidents. */
901                        if (id < 1000000) {
902                                id = 0;
903                        }
904                }
905        }
906        if (bu_) {
907                if (bu == &twitter_log_local_user) {
908                        /* HACK alert. There's no bee_user object for the local
909                         * user so just fake one for the few cmds that need it. */
910                        twitter_log_local_user.handle = td->user;
911                } else {
912                        /* Beware of dangling pointers! */
913                        if (!g_slist_find(ic->bee->users, bu)) {
914                                bu = NULL;
915                        }
916                }
917                *bu_ = bu;
918        }
919        return id;
920}
921
922static void twitter_handle_command(struct im_connection *ic, char *message)
923{
924        struct twitter_data *td = ic->proto_data;
925        char *cmds, **cmd, *new = NULL;
926        guint64 in_reply_to = 0, id;
927        gboolean allow_post =
928                g_strcasecmp(set_getstr(&ic->acc->set, "commands"), "strict") != 0;
929        bee_user_t *bu = NULL;
930
931        cmds = g_strdup(message);
932        cmd = split_command_parts(cmds, 2);
933
934        if (cmd[0] == NULL) {
935                goto eof;
936        } else if (!set_getbool(&ic->acc->set, "commands") && allow_post) {
937                /* Not supporting commands if "commands" is set to true/strict. */
938        } else if (g_strcasecmp(cmd[0], "undo") == 0) {
939                if (cmd[1] == NULL) {
940                        twitter_status_destroy(ic, td->last_status_id);
941                } else if ((id = twitter_message_id_from_command_arg(ic, cmd[1], NULL))) {
942                        twitter_status_destroy(ic, id);
943                } else {
944                        twitter_log(ic, "Could not undo last action");
945                }
946
947                goto eof;
948        } else if ((g_strcasecmp(cmd[0], "favourite") == 0 ||
949                    g_strcasecmp(cmd[0], "favorite") == 0 ||
950                    g_strcasecmp(cmd[0], "fav") == 0) && cmd[1]) {
951                if ((id = twitter_message_id_from_command_arg(ic, cmd[1], NULL))) {
952                        twitter_favourite_tweet(ic, id);
953                } else {
954                        twitter_log(ic, "Please provide a message ID or username.");
955                }
956                goto eof;
957        } else if (g_strcasecmp(cmd[0], "follow") == 0 && cmd[1]) {
958                twitter_add_buddy(ic, cmd[1], NULL);
959                goto eof;
960        } else if (g_strcasecmp(cmd[0], "unfollow") == 0 && cmd[1]) {
961                twitter_remove_buddy(ic, cmd[1], NULL);
962                goto eof;
963        } else if ((g_strcasecmp(cmd[0], "report") == 0 ||
964                    g_strcasecmp(cmd[0], "spam") == 0) && cmd[1]) {
965                char *screen_name;
966
967                /* Report nominally works on users but look up the user who
968                   posted the given ID if the user wants to do it that way */
969                twitter_message_id_from_command_arg(ic, cmd[1], &bu);
970                if (bu) {
971                        screen_name = bu->handle;
972                } else {
973                        screen_name = cmd[1];
974                }
975
976                twitter_report_spam(ic, screen_name);
977                goto eof;
978        } else if (g_strcasecmp(cmd[0], "rt") == 0 && cmd[1]) {
979                id = twitter_message_id_from_command_arg(ic, cmd[1], NULL);
980
981                td->last_status_id = 0;
982                if (id) {
983                        twitter_status_retweet(ic, id);
984                } else {
985                        twitter_log(ic, "User `%s' does not exist or didn't "
986                                    "post any statuses recently", cmd[1]);
987                }
988
989                goto eof;
990        } else if (g_strcasecmp(cmd[0], "reply") == 0 && cmd[1] && cmd[2]) {
991                id = twitter_message_id_from_command_arg(ic, cmd[1], &bu);
992                if (!id || !bu) {
993                        twitter_log(ic, "User `%s' does not exist or didn't "
994                                    "post any statuses recently", cmd[1]);
995                        goto eof;
996                }
997                message = new = g_strdup_printf("@%s %s", bu->handle, cmd[2]);
998                in_reply_to = id;
999                allow_post = TRUE;
1000        } else if (g_strcasecmp(cmd[0], "rawreply") == 0 && cmd[1] && cmd[2]) {
1001                id = twitter_message_id_from_command_arg(ic, cmd[1], NULL);
1002                if (!id) {
1003                        twitter_log(ic, "Tweet `%s' does not exist", cmd[1]);
1004                        goto eof;
1005                }
1006                message = cmd[2];
1007                in_reply_to = id;
1008                allow_post = TRUE;
1009        } else if (g_strcasecmp(cmd[0], "url") == 0) {
1010                id = twitter_message_id_from_command_arg(ic, cmd[1], &bu);
1011                if (!id) {
1012                        twitter_log(ic, "Tweet `%s' does not exist", cmd[1]);
1013                } else {
1014                        twitter_status_show_url(ic, id);
1015                }
1016                goto eof;
1017
1018        } else if (g_strcasecmp(cmd[0], "post") == 0) {
1019                message += 5;
1020                allow_post = TRUE;
1021        }
1022
1023        if (allow_post) {
1024                char *s;
1025
1026                if (!twitter_length_check(ic, message)) {
1027                        goto eof;
1028                }
1029
1030                s = cmd[0] + strlen(cmd[0]) - 1;
1031                if (!new && s > cmd[0] && (*s == ':' || *s == ',')) {
1032                        *s = '\0';
1033
1034                        if ((bu = bee_user_by_handle(ic->bee, ic, cmd[0]))) {
1035                                struct twitter_user_data *tud = bu->data;
1036
1037                                new = g_strdup_printf("@%s %s", bu->handle,
1038                                                      message + (s - cmd[0]) + 2);
1039                                message = new;
1040
1041                                if (time(NULL) < tud->last_time +
1042                                    set_getint(&ic->acc->set, "auto_reply_timeout")) {
1043                                        in_reply_to = tud->last_id;
1044                                }
1045                        }
1046                }
1047
1048                /* If the user runs undo between this request and its response
1049                   this would delete the second-last Tweet. Prevent that. */
1050                td->last_status_id = 0;
1051                twitter_post_status(ic, message, in_reply_to);
1052        } else {
1053                twitter_log(ic, "Unknown command: %s", cmd[0]);
1054        }
1055eof:
1056        g_free(new);
1057        g_free(cmds);
1058}
1059
1060void twitter_log(struct im_connection *ic, char *format, ...)
1061{
1062        struct twitter_data *td = ic->proto_data;
1063        va_list params;
1064        char *text;
1065
1066        va_start(params, format);
1067        text = g_strdup_vprintf(format, params);
1068        va_end(params);
1069
1070        if (td->timeline_gc) {
1071                imcb_chat_log(td->timeline_gc, "%s", text);
1072        } else {
1073                imcb_log(ic, "%s", text);
1074        }
1075
1076        g_free(text);
1077}
1078
1079
1080void twitter_initmodule()
1081{
1082        struct prpl *ret = g_new0(struct prpl, 1);
1083
1084        ret->options = OPT_NOOTR;
1085        ret->name = "twitter";
1086        ret->login = twitter_login;
1087        ret->init = twitter_init;
1088        ret->logout = twitter_logout;
1089        ret->buddy_msg = twitter_buddy_msg;
1090        ret->get_info = twitter_get_info;
1091        ret->add_buddy = twitter_add_buddy;
1092        ret->remove_buddy = twitter_remove_buddy;
1093        ret->chat_msg = twitter_chat_msg;
1094        ret->chat_invite = twitter_chat_invite;
1095        ret->chat_join = twitter_chat_join;
1096        ret->chat_leave = twitter_chat_leave;
1097        ret->keepalive = twitter_keepalive;
1098        ret->add_permit = twitter_add_permit;
1099        ret->rem_permit = twitter_rem_permit;
1100        ret->add_deny = twitter_add_deny;
1101        ret->rem_deny = twitter_rem_deny;
1102        ret->buddy_data_add = twitter_buddy_data_add;
1103        ret->buddy_data_free = twitter_buddy_data_free;
1104        ret->handle_cmp = g_strcasecmp;
1105
1106        register_protocol(ret);
1107
1108        /* And an identi.ca variant: */
1109        ret = g_memdup(ret, sizeof(struct prpl));
1110        ret->name = "identica";
1111        register_protocol(ret);
1112}
Note: See TracBrowser for help on using the repository browser.