source: protocols/twitter/twitter_lib.c @ f539d6e

Last change on this file since f539d6e was e31e5b8, checked in by Wilmer van der Gaast <wilmer@…>, at 2013-04-20T13:05:55Z

Merging "storage" branch which I wrote long ago. It separates generation of
XML-formatted user configs from disk I/O so we can try to start using other
mechanisms to store them (a REST API or something, for example).

  • Property mode set to 100644
File size: 34.0 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/* For strptime(): */
26#if(__sun)
27#else
28#define _XOPEN_SOURCE
29#endif
30
31#include "twitter_http.h"
32#include "twitter.h"
33#include "bitlbee.h"
34#include "url.h"
35#include "misc.h"
36#include "base64.h"
37#include "twitter_lib.h"
38#include "json_util.h"
39#include <ctype.h>
40#include <errno.h>
41
42#define TXL_STATUS 1
43#define TXL_USER 2
44#define TXL_ID 3
45
46struct twitter_xml_list {
47        int type;
48        gint64 next_cursor;
49        GSList *list;
50};
51
52struct twitter_xml_user {
53        char *name;
54        char *screen_name;
55};
56
57struct twitter_xml_status {
58        time_t created_at;
59        char *text;
60        struct twitter_xml_user *user;
61        guint64 id, rt_id; /* Usually equal, with RTs id == *original* id */
62        guint64 reply_to;
63};
64
65/**
66 * Frees a twitter_xml_user struct.
67 */
68static void txu_free(struct twitter_xml_user *txu)
69{
70        if (txu == NULL)
71                return;
72
73        g_free(txu->name);
74        g_free(txu->screen_name);
75        g_free(txu);
76}
77
78/**
79 * Frees a twitter_xml_status struct.
80 */
81static void txs_free(struct twitter_xml_status *txs)
82{
83        if (txs == NULL)
84                return;
85
86        g_free(txs->text);
87        txu_free(txs->user);
88        g_free(txs);
89}
90
91/**
92 * Free a twitter_xml_list struct.
93 * type is the type of list the struct holds.
94 */
95static void txl_free(struct twitter_xml_list *txl)
96{
97        GSList *l;
98        if (txl == NULL)
99                return;
100
101        for (l = txl->list; l; l = g_slist_next(l)) {
102                if (txl->type == TXL_STATUS) {
103                        txs_free((struct twitter_xml_status *) l->data);
104                } else if (txl->type == TXL_ID) {
105                        g_free(l->data);
106                } else if (txl->type == TXL_USER) {
107                        txu_free(l->data);
108                }
109        }
110
111        g_slist_free(txl->list);
112        g_free(txl);
113}
114
115/**
116 * Compare status elements
117 */
118static gint twitter_compare_elements(gconstpointer a, gconstpointer b)
119{
120        struct twitter_xml_status *a_status = (struct twitter_xml_status *) a;
121        struct twitter_xml_status *b_status = (struct twitter_xml_status *) b;
122
123        if (a_status->created_at < b_status->created_at) {
124                return -1;
125        } else if (a_status->created_at > b_status->created_at) {
126                return 1;
127        } else {
128                return 0;
129        }
130}
131
132/**
133 * Add a buddy if it is not already added, set the status to logged in.
134 */
135static void twitter_add_buddy(struct im_connection *ic, char *name, const char *fullname)
136{
137        struct twitter_data *td = ic->proto_data;
138
139        // Check if the buddy is already in the buddy list.
140        if (!bee_user_by_handle(ic->bee, ic, name)) {
141                // The buddy is not in the list, add the buddy and set the status to logged in.
142                imcb_add_buddy(ic, name, NULL);
143                imcb_rename_buddy(ic, name, fullname);
144                if (td->flags & TWITTER_MODE_CHAT) {
145                        /* Necessary so that nicks always get translated to the
146                           exact Twitter username. */
147                        imcb_buddy_nick_hint(ic, name, name);
148                        if (td->timeline_gc)
149                                imcb_chat_add_buddy(td->timeline_gc, name);
150                } else if (td->flags & TWITTER_MODE_MANY)
151                        imcb_buddy_status(ic, name, OPT_LOGGED_IN, NULL, NULL);
152        }
153}
154
155/* Warning: May return a malloc()ed value, which will be free()d on the next
156   call. Only for short-term use. NOT THREADSAFE!  */
157char *twitter_parse_error(struct http_request *req)
158{
159        static char *ret = NULL;
160        json_value *root, *err;
161
162        g_free(ret);
163        ret = NULL;
164
165        if (req->body_size > 0) {
166                root = json_parse(req->reply_body);
167                err = json_o_get(root, "errors");
168                if (err && err->type == json_array && (err = err->u.array.values[0]) &&
169                    err->type == json_object) {
170                        const char *msg = json_o_str(err, "message");
171                        if (msg)
172                                ret = g_strdup_printf("%s (%s)", req->status_string, msg);
173                }
174                json_value_free(root);
175        }
176
177        return ret ? ret : req->status_string;
178}
179
180/* WATCH OUT: This function might or might not destroy your connection.
181   Sub-optimal indeed, but just be careful when this returns NULL! */
182static json_value *twitter_parse_response(struct im_connection *ic, struct http_request *req)
183{
184        gboolean logging_in = !(ic->flags & OPT_LOGGED_IN);
185        gboolean periodic;
186        struct twitter_data *td = ic->proto_data;
187        json_value *ret;
188        char path[64] = "", *s;
189       
190        if ((s = strchr(req->request, ' '))) {
191                path[sizeof(path)-1] = '\0';
192                strncpy(path, s + 1, sizeof(path) - 1);
193                if ((s = strchr(path, '?')) || (s = strchr(path, ' ')))
194                        *s = '\0';
195        }
196       
197        /* Kinda nasty. :-( Trying to suppress error messages, but only
198           for periodic (i.e. mentions/timeline) queries. */
199        periodic = strstr(path, "timeline") || strstr(path, "mentions");
200       
201        if (req->status_code == 401 && logging_in) {
202                /* IIRC Twitter once had an outage where they were randomly
203                   throwing 401s so I'll keep treating this one as fatal
204                   only during login. */
205                imcb_error(ic, "Authentication failure (%s)",
206                               twitter_parse_error(req));
207                imc_logout(ic, FALSE);
208                return NULL;
209        } else if (req->status_code != 200) {
210                // It didn't go well, output the error and return.
211                if (!periodic || logging_in || ++td->http_fails >= 5)
212                        twitter_log(ic, "Error: Could not retrieve %s: %s",
213                                    path, twitter_parse_error(req));
214               
215                if (logging_in)
216                        imc_logout(ic, TRUE);
217                return NULL;
218        } else {
219                td->http_fails = 0;
220        }
221
222        if ((ret = json_parse(req->reply_body)) == NULL) {
223                imcb_error(ic, "Could not retrieve %s: %s",
224                           path, "XML parse error");
225        }
226        return ret;
227}
228
229static void twitter_http_get_friends_ids(struct http_request *req);
230
231/**
232 * Get the friends ids.
233 */
234void twitter_get_friends_ids(struct im_connection *ic, gint64 next_cursor)
235{
236        // Primitive, but hey! It works...     
237        char *args[2];
238        args[0] = "cursor";
239        args[1] = g_strdup_printf("%lld", (long long) next_cursor);
240        twitter_http(ic, TWITTER_FRIENDS_IDS_URL, twitter_http_get_friends_ids, ic, 0, args, 2);
241
242        g_free(args[1]);
243}
244
245/**
246 * Fill a list of ids.
247 */
248static gboolean twitter_xt_get_friends_id_list(json_value *node, struct twitter_xml_list *txl)
249{
250        json_value *c;
251        int i;
252
253        // Set the list type.
254        txl->type = TXL_ID;
255
256        c = json_o_get(node, "ids");
257        if (!c || c->type != json_array)
258                return FALSE;
259
260        for (i = 0; i < c->u.array.length; i ++) {
261                if (c->u.array.values[i]->type != json_integer)
262                        continue;
263               
264                txl->list = g_slist_prepend(txl->list,
265                        g_strdup_printf("%lld", c->u.array.values[i]->u.integer));
266        }
267       
268        c = json_o_get(node, "next_cursor");
269        if (c && c->type == json_integer)
270                txl->next_cursor = c->u.integer;
271        else
272                txl->next_cursor = -1;
273       
274        return TRUE;
275}
276
277static void twitter_get_users_lookup(struct im_connection *ic);
278
279/**
280 * Callback for getting the friends ids.
281 */
282static void twitter_http_get_friends_ids(struct http_request *req)
283{
284        struct im_connection *ic;
285        json_value *parsed;
286        struct twitter_xml_list *txl;
287        struct twitter_data *td;
288
289        ic = req->data;
290
291        // Check if the connection is still active.
292        if (!g_slist_find(twitter_connections, ic))
293                return;
294
295        td = ic->proto_data;
296
297        txl = g_new0(struct twitter_xml_list, 1);
298        txl->list = td->follow_ids;
299
300        // Parse the data.
301        if (!(parsed = twitter_parse_response(ic, req)))
302                return;
303       
304        twitter_xt_get_friends_id_list(parsed, txl);
305        json_value_free(parsed);
306
307        td->follow_ids = txl->list;
308        if (txl->next_cursor)
309                /* These were just numbers. Up to 4000 in a response AFAIK so if we get here
310                   we may be using a spammer account. \o/ */
311                twitter_get_friends_ids(ic, txl->next_cursor);
312        else
313                /* Now to convert all those numbers into names.. */
314                twitter_get_users_lookup(ic);
315
316        txl->list = NULL;
317        txl_free(txl);
318}
319
320static gboolean twitter_xt_get_users(json_value *node, struct twitter_xml_list *txl);
321static void twitter_http_get_users_lookup(struct http_request *req);
322
323static void twitter_get_users_lookup(struct im_connection *ic)
324{
325        struct twitter_data *td = ic->proto_data;
326        char *args[2] = {
327                "user_id",
328                NULL,
329        };
330        GString *ids = g_string_new("");
331        int i;
332       
333        /* We can request up to 100 users at a time. */
334        for (i = 0; i < 100 && td->follow_ids; i ++) {
335                g_string_append_printf(ids, ",%s", (char*) td->follow_ids->data);
336                g_free(td->follow_ids->data);
337                td->follow_ids = g_slist_remove(td->follow_ids, td->follow_ids->data);
338        }
339        if (ids->len > 0) {
340                args[1] = ids->str + 1;
341                /* POST, because I think ids can be up to 1KB long. */
342                twitter_http(ic, TWITTER_USERS_LOOKUP_URL, twitter_http_get_users_lookup, ic, 1, args, 2);
343        } else {
344                /* We have all users. Continue with login. (Get statuses.) */
345                td->flags |= TWITTER_HAVE_FRIENDS;
346                twitter_login_finish(ic);
347        }
348        g_string_free(ids, TRUE);
349}
350
351/**
352 * Callback for getting (twitter)friends...
353 *
354 * Be afraid, be very afraid! This function will potentially add hundreds of "friends". "Who has
355 * hundreds of friends?" you wonder? You probably not, since you are reading the source of
356 * BitlBee... Get a life and meet new people!
357 */
358static void twitter_http_get_users_lookup(struct http_request *req)
359{
360        struct im_connection *ic = req->data;
361        json_value *parsed;
362        struct twitter_xml_list *txl;
363        GSList *l = NULL;
364        struct twitter_xml_user *user;
365
366        // Check if the connection is still active.
367        if (!g_slist_find(twitter_connections, ic))
368                return;
369
370        txl = g_new0(struct twitter_xml_list, 1);
371        txl->list = NULL;
372
373        // Get the user list from the parsed xml feed.
374        if (!(parsed = twitter_parse_response(ic, req)))
375                return;
376        twitter_xt_get_users(parsed, txl);
377        json_value_free(parsed);
378
379        // Add the users as buddies.
380        for (l = txl->list; l; l = g_slist_next(l)) {
381                user = l->data;
382                twitter_add_buddy(ic, user->screen_name, user->name);
383        }
384
385        // Free the structure.
386        txl_free(txl);
387
388        twitter_get_users_lookup(ic);
389}
390
391struct twitter_xml_user *twitter_xt_get_user(const json_value *node)
392{
393        struct twitter_xml_user *txu;
394       
395        txu = g_new0(struct twitter_xml_user, 1);
396        txu->name = g_strdup(json_o_str(node, "name"));
397        txu->screen_name = g_strdup(json_o_str(node, "screen_name"));
398       
399        return txu;
400}
401
402/**
403 * Function to fill a twitter_xml_list struct.
404 * It sets:
405 *  - all <user>s from the <users> element.
406 */
407static gboolean twitter_xt_get_users(json_value *node, struct twitter_xml_list *txl)
408{
409        struct twitter_xml_user *txu;
410        int i;
411
412        // Set the type of the list.
413        txl->type = TXL_USER;
414
415        if (!node || node->type != json_array)
416                return FALSE;
417
418        // The root <users> node should hold the list of users <user>
419        // Walk over the nodes children.
420        for (i = 0; i < node->u.array.length; i ++) {
421                txu = twitter_xt_get_user(node->u.array.values[i]);
422                if (txu)
423                        txl->list = g_slist_prepend(txl->list, txu);
424        }
425
426        return TRUE;
427}
428
429#ifdef __GLIBC__
430#define TWITTER_TIME_FORMAT "%a %b %d %H:%M:%S %z %Y"
431#else
432#define TWITTER_TIME_FORMAT "%a %b %d %H:%M:%S +0000 %Y"
433#endif
434
435static char* expand_entities(char* text, const json_value *entities);
436
437/**
438 * Function to fill a twitter_xml_status struct.
439 * It sets:
440 *  - the status text and
441 *  - the created_at timestamp and
442 *  - the status id and
443 *  - the user in a twitter_xml_user struct.
444 */
445static struct twitter_xml_status *twitter_xt_get_status(const json_value *node)
446{
447        struct twitter_xml_status *txs;
448        const json_value *rt = NULL, *entities = NULL;
449       
450        if (node->type != json_object)
451                return FALSE;
452        txs = g_new0(struct twitter_xml_status, 1);
453
454        JSON_O_FOREACH (node, k, v) {
455                if (strcmp("text", k) == 0 && v->type == json_string) {
456                        txs->text = g_memdup(v->u.string.ptr, v->u.string.length + 1);
457                        strip_html(txs->text);
458                } else if (strcmp("retweeted_status", k) == 0 && v->type == json_object) {
459                        rt = v;
460                } else if (strcmp("created_at", k) == 0 && v->type == json_string) {
461                        struct tm parsed;
462
463                        /* Very sensitive to changes to the formatting of
464                           this field. :-( Also assumes the timezone used
465                           is UTC since C time handling functions suck. */
466                        if (strptime(v->u.string.ptr, TWITTER_TIME_FORMAT, &parsed) != NULL)
467                                txs->created_at = mktime_utc(&parsed);
468                } else if (strcmp("user", k) == 0 && v->type == json_object) {
469                        txs->user = twitter_xt_get_user(v);
470                } else if (strcmp("id", k) == 0 && v->type == json_integer) {
471                        txs->rt_id = txs->id = v->u.integer;
472                } else if (strcmp("in_reply_to_status_id", k) == 0 && v->type == json_integer) {
473                        txs->reply_to = v->u.integer;
474                } else if (strcmp("entities", k) == 0 && v->type == json_object) {
475                        entities = v;
476                }
477        }
478
479        /* If it's a (truncated) retweet, get the original. Even if the API claims it
480           wasn't truncated because it may be lying. */
481        if (rt) {
482                struct twitter_xml_status *rtxs = twitter_xt_get_status(rt);
483                if (rtxs) {
484                        g_free(txs->text);
485                        txs->text = g_strdup_printf("RT @%s: %s", rtxs->user->screen_name, rtxs->text);
486                        txs->id = rtxs->id;
487                        txs_free(rtxs);
488                }
489        } else if (entities) {
490                txs->text = expand_entities(txs->text, entities);
491        }
492
493        if (txs->text && txs->user && txs->id)
494                return txs;
495       
496        txs_free(txs);
497        return NULL;
498}
499
500/**
501 * Function to fill a twitter_xml_status struct (DM variant).
502 */
503static struct twitter_xml_status *twitter_xt_get_dm(const json_value *node)
504{
505        struct twitter_xml_status *txs;
506        const json_value *entities = NULL;
507       
508        if (node->type != json_object)
509                return FALSE;
510        txs = g_new0(struct twitter_xml_status, 1);
511
512        JSON_O_FOREACH (node, k, v) {
513                if (strcmp("text", k) == 0 && v->type == json_string) {
514                        txs->text = g_memdup(v->u.string.ptr, v->u.string.length + 1);
515                        strip_html(txs->text);
516                } else if (strcmp("created_at", k) == 0 && v->type == json_string) {
517                        struct tm parsed;
518
519                        /* Very sensitive to changes to the formatting of
520                           this field. :-( Also assumes the timezone used
521                           is UTC since C time handling functions suck. */
522                        if (strptime(v->u.string.ptr, TWITTER_TIME_FORMAT, &parsed) != NULL)
523                                txs->created_at = mktime_utc(&parsed);
524                } else if (strcmp("sender", k) == 0 && v->type == json_object) {
525                        txs->user = twitter_xt_get_user(v);
526                } else if (strcmp("id", k) == 0 && v->type == json_integer) {
527                        txs->id = v->u.integer;
528                }
529        }
530
531        if (entities) {
532                txs->text = expand_entities(txs->text, entities);
533        }
534
535        if (txs->text && txs->user && txs->id)
536                return txs;
537       
538        txs_free(txs);
539        return NULL;
540}
541
542static char* expand_entities(char* text, const json_value *entities) {
543        JSON_O_FOREACH (entities, k, v) {
544                int i;
545               
546                if (v->type != json_array)
547                        continue;
548                if (strcmp(k, "urls") != 0 && strcmp(k, "media") != 0)
549                        continue;
550               
551                for (i = 0; i < v->u.array.length; i ++) {
552                        if (v->u.array.values[i]->type != json_object)
553                                continue;
554                       
555                        const char *kort = json_o_str(v->u.array.values[i], "url");
556                        const char *disp = json_o_str(v->u.array.values[i], "display_url");
557                        char *pos, *new;
558                       
559                        if (!kort || !disp || !(pos = strstr(text, kort)))
560                                continue;
561                       
562                        *pos = '\0';
563                        new = g_strdup_printf("%s%s <%s>%s", text, kort,
564                                              disp, pos + strlen(kort));
565                       
566                        g_free(text);
567                        text = new;
568                }
569        }
570       
571        return text;
572}
573
574/**
575 * Function to fill a twitter_xml_list struct.
576 * It sets:
577 *  - all <status>es within the <status> element and
578 *  - the next_cursor.
579 */
580static gboolean twitter_xt_get_status_list(struct im_connection *ic, const json_value *node,
581                                           struct twitter_xml_list *txl)
582{
583        struct twitter_xml_status *txs;
584        int i;
585
586        // Set the type of the list.
587        txl->type = TXL_STATUS;
588       
589        if (node->type != json_array)
590                return FALSE;
591
592        // The root <statuses> node should hold the list of statuses <status>
593        // Walk over the nodes children.
594        for (i = 0; i < node->u.array.length; i ++) {
595                txs = twitter_xt_get_status(node->u.array.values[i]);
596                if (!txs)
597                        continue;
598               
599                txl->list = g_slist_prepend(txl->list, txs);
600        }
601
602        return TRUE;
603}
604
605/* Will log messages either way. Need to keep track of IDs for stream deduping.
606   Plus, show_ids is on by default and I don't see why anyone would disable it. */
607static char *twitter_msg_add_id(struct im_connection *ic,
608                                struct twitter_xml_status *txs, const char *prefix)
609{
610        struct twitter_data *td = ic->proto_data;
611        int reply_to = -1;
612        bee_user_t *bu;
613
614        if (txs->reply_to) {
615                int i;
616                for (i = 0; i < TWITTER_LOG_LENGTH; i++)
617                        if (td->log[i].id == txs->reply_to) {
618                                reply_to = i;
619                                break;
620                        }
621        }
622
623        if (txs->user && txs->user->screen_name &&
624            (bu = bee_user_by_handle(ic->bee, ic, txs->user->screen_name))) {
625                struct twitter_user_data *tud = bu->data;
626
627                if (txs->id > tud->last_id) {
628                        tud->last_id = txs->id;
629                        tud->last_time = txs->created_at;
630                }
631        }
632       
633        td->log_id = (td->log_id + 1) % TWITTER_LOG_LENGTH;
634        td->log[td->log_id].id = txs->id;
635        td->log[td->log_id].bu = bee_user_by_handle(ic->bee, ic, txs->user->screen_name);
636       
637        /* This is all getting hairy. :-( If we RT'ed something ourselves,
638           remember OUR id instead so undo will work. In other cases, the
639           original tweet's id should be remembered for deduplicating. */
640        if (strcmp(txs->user->screen_name, td->user) == 0)
641                td->log[td->log_id].id = txs->rt_id;
642       
643        if (set_getbool(&ic->acc->set, "show_ids")) {
644                if (reply_to != -1)
645                        return g_strdup_printf("\002[\002%02x->%02x\002]\002 %s%s",
646                                               td->log_id, reply_to, prefix, txs->text);
647                else
648                        return g_strdup_printf("\002[\002%02x\002]\002 %s%s",
649                                               td->log_id, prefix, txs->text);
650        } else {
651                if (*prefix)
652                        return g_strconcat(prefix, txs->text, NULL);
653                else
654                        return NULL;
655        }
656}
657
658/**
659 * Function that is called to see the statuses in a groupchat window.
660 */
661static void twitter_status_show_chat(struct im_connection *ic, struct twitter_xml_status *status)
662{
663        struct twitter_data *td = ic->proto_data;
664        struct groupchat *gc;
665        gboolean me = g_strcasecmp(td->user, status->user->screen_name) == 0;
666        char *msg;
667
668        // Create a new groupchat if it does not exsist.
669        gc = twitter_groupchat_init(ic);
670
671        if (!me)
672                /* MUST be done before twitter_msg_add_id() to avoid #872. */
673                twitter_add_buddy(ic, status->user->screen_name, status->user->name);
674        msg = twitter_msg_add_id(ic, status, "");
675       
676        // Say it!
677        if (me) {
678                imcb_chat_log(gc, "You: %s", msg ? msg : status->text);
679        } else {
680                imcb_chat_msg(gc, status->user->screen_name,
681                              msg ? msg : status->text, 0, status->created_at);
682        }
683
684        g_free(msg);
685}
686
687/**
688 * Function that is called to see statuses as private messages.
689 */
690static void twitter_status_show_msg(struct im_connection *ic, struct twitter_xml_status *status)
691{
692        struct twitter_data *td = ic->proto_data;
693        char from[MAX_STRING] = "";
694        char *prefix = NULL, *text = NULL;
695        gboolean me = g_strcasecmp(td->user, status->user->screen_name) == 0;
696
697        if (td->flags & TWITTER_MODE_ONE) {
698                g_snprintf(from, sizeof(from) - 1, "%s_%s", td->prefix, ic->acc->user);
699                from[MAX_STRING - 1] = '\0';
700        }
701
702        if (td->flags & TWITTER_MODE_ONE)
703                prefix = g_strdup_printf("\002<\002%s\002>\002 ",
704                                         status->user->screen_name);
705        else if (!me)
706                twitter_add_buddy(ic, status->user->screen_name, status->user->name);
707        else
708                prefix = g_strdup("You: ");
709
710        text = twitter_msg_add_id(ic, status, prefix ? prefix : "");
711
712        imcb_buddy_msg(ic,
713                       *from ? from : status->user->screen_name,
714                       text ? text : status->text, 0, status->created_at);
715
716        g_free(text);
717        g_free(prefix);
718}
719
720static void twitter_status_show(struct im_connection *ic, struct twitter_xml_status *status)
721{
722        struct twitter_data *td = ic->proto_data;
723       
724        if (status->user == NULL || status->text == NULL)
725                return;
726       
727        /* Grrrr. Would like to do this during parsing, but can't access
728           settings from there. */
729        if (set_getbool(&ic->acc->set, "strip_newlines"))
730                strip_newlines(status->text);
731       
732        if (td->flags & TWITTER_MODE_CHAT)
733                twitter_status_show_chat(ic, status);
734        else
735                twitter_status_show_msg(ic, status);
736
737        // Update the timeline_id to hold the highest id, so that by the next request
738        // we won't pick up the updates already in the list.
739        td->timeline_id = MAX(td->timeline_id, status->rt_id);
740}
741
742static gboolean twitter_stream_handle_object(struct im_connection *ic, json_value *o);
743
744static void twitter_http_stream(struct http_request *req)
745{
746        struct im_connection *ic = req->data;
747        struct twitter_data *td;
748        json_value *parsed;
749        int len = 0;
750        char c, *nl;
751       
752        if (!g_slist_find(twitter_connections, ic))
753                return;
754       
755        ic->flags |= OPT_PONGED;
756        td = ic->proto_data;
757       
758        if ((req->flags & HTTPC_EOF) || !req->reply_body) {
759                td->stream = NULL;
760                imcb_error(ic, "Stream closed (%s)", req->status_string);
761                imc_logout(ic, TRUE);
762                return;
763        }
764       
765        /* MUST search for CRLF, not just LF:
766           https://dev.twitter.com/docs/streaming-apis/processing#Parsing_responses */
767        if (!(nl = strstr(req->reply_body, "\r\n")))
768                return;
769       
770        len = nl - req->reply_body;
771        if (len > 0) {
772                c = req->reply_body[len];
773                req->reply_body[len] = '\0';
774               
775                if ((parsed = json_parse(req->reply_body))) {
776                        twitter_stream_handle_object(ic, parsed);
777                }
778                json_value_free(parsed);
779                req->reply_body[len] = c;
780        }
781       
782        http_flush_bytes(req, len + 2);
783       
784        /* One notification might bring multiple events! */
785        if (req->body_size > 0)
786                twitter_http_stream(req);
787}
788
789static gboolean twitter_stream_handle_event(struct im_connection *ic, json_value *o);
790static gboolean twitter_stream_handle_status(struct im_connection *ic, struct twitter_xml_status *txs);
791
792static gboolean twitter_stream_handle_object(struct im_connection *ic, json_value *o)
793{
794        struct twitter_data *td = ic->proto_data;
795        struct twitter_xml_status *txs;
796        json_value *c;
797       
798        if ((txs = twitter_xt_get_status(o))) {
799                gboolean ret = twitter_stream_handle_status(ic, txs);
800                txs_free(txs);
801                return ret;
802        } else if ((c = json_o_get(o, "direct_message")) &&
803                   (txs = twitter_xt_get_dm(c))) {
804                if (strcmp(txs->user->screen_name, td->user) != 0)
805                        imcb_buddy_msg(ic, txs->user->screen_name,
806                                       txs->text, 0, txs->created_at);
807                txs_free(txs);
808                return TRUE;
809        } else if ((c = json_o_get(o, "event")) && c->type == json_string) {
810                twitter_stream_handle_event(ic, o);
811                return TRUE;
812        } else if ((c = json_o_get(o, "disconnect")) && c->type == json_object) {
813                /* HACK: Because we're inside an event handler, we can't just
814                   disconnect here. Instead, just change the HTTP status string
815                   into a Twitter status string. */
816                char *reason = json_o_strdup(c, "reason");
817                if (reason) {
818                        g_free(td->stream->status_string);
819                        td->stream->status_string = reason;
820                }
821                return TRUE;
822        }
823        return FALSE;
824}
825
826static gboolean twitter_stream_handle_status(struct im_connection *ic, struct twitter_xml_status *txs)
827{
828        struct twitter_data *td = ic->proto_data;
829        int i;
830       
831        for (i = 0; i < TWITTER_LOG_LENGTH; i++) {
832                if (td->log[i].id == txs->id) {
833                        /* Got a duplicate (RT, probably). Drop it. */
834                        return TRUE;
835                }
836        }
837       
838        if (!(strcmp(txs->user->screen_name, td->user) == 0 ||
839              set_getbool(&ic->acc->set, "fetch_mentions") ||
840              bee_user_by_handle(ic->bee, ic, txs->user->screen_name))) {
841                /* Tweet is from an unknown person and the user does not want
842                   to see @mentions, so drop it. twitter_stream_handle_event()
843                   picks up new follows so this simple filter should be safe. */
844                /* TODO: The streaming API seems to do poor @mention matching.
845                   I.e. I'm getting mentions for @WilmerSomething, not just for
846                   @Wilmer. But meh. You want spam, you get spam. */
847                return TRUE;
848        }
849       
850        twitter_status_show(ic, txs);
851       
852        return TRUE;
853}
854
855static gboolean twitter_stream_handle_event(struct im_connection *ic, json_value *o)
856{
857        struct twitter_data *td = ic->proto_data;
858        json_value *source = json_o_get(o, "source");
859        json_value *target = json_o_get(o, "target");
860        const char *type = json_o_str(o, "event");
861       
862        if (!type || !source || source->type != json_object
863                  || !target || target->type != json_object) {
864                return FALSE;
865        }
866       
867        if (strcmp(type, "follow") == 0) {
868                struct twitter_xml_user *us = twitter_xt_get_user(source);
869                struct twitter_xml_user *ut = twitter_xt_get_user(target);
870                if (strcmp(us->screen_name, td->user) == 0) {
871                        twitter_add_buddy(ic, ut->screen_name, ut->name);
872                }
873                txu_free(us);
874                txu_free(ut);
875        }
876       
877        return TRUE;
878}
879
880gboolean twitter_open_stream(struct im_connection *ic)
881{
882        struct twitter_data *td = ic->proto_data;
883        char *args[2] = {"with", "followings"};
884       
885        if ((td->stream = twitter_http(ic, TWITTER_USER_STREAM_URL,
886                                       twitter_http_stream, ic, 0, args, 2))) {
887                /* This flag must be enabled or we'll get no data until EOF
888                   (which err, kind of, defeats the purpose of a streaming API). */
889                td->stream->flags |= HTTPC_STREAMING;
890                return TRUE;
891        }
892       
893        return FALSE;
894}
895
896static void twitter_get_home_timeline(struct im_connection *ic, gint64 next_cursor);
897static void twitter_get_mentions(struct im_connection *ic, gint64 next_cursor);
898
899/**
900 * Get the timeline with optionally mentions
901 */
902void twitter_get_timeline(struct im_connection *ic, gint64 next_cursor)
903{
904        struct twitter_data *td = ic->proto_data;
905        gboolean include_mentions = set_getbool(&ic->acc->set, "fetch_mentions");
906
907        if (td->flags & TWITTER_DOING_TIMELINE) {
908                if (++td->http_fails >= 5) {
909                        imcb_error(ic, "Fetch timeout (%d)", td->flags);
910                        imc_logout(ic, TRUE);
911                }
912        }
913
914        td->flags |= TWITTER_DOING_TIMELINE;
915
916        twitter_get_home_timeline(ic, next_cursor);
917
918        if (include_mentions) {
919                twitter_get_mentions(ic, next_cursor);
920        }
921}
922
923/**
924 * Call this one after receiving timeline/mentions. Show to user once we have
925 * both.
926 */
927void twitter_flush_timeline(struct im_connection *ic)
928{
929        struct twitter_data *td = ic->proto_data;
930        gboolean include_mentions = set_getbool(&ic->acc->set, "fetch_mentions");
931        int show_old_mentions = set_getint(&ic->acc->set, "show_old_mentions");
932        struct twitter_xml_list *home_timeline = td->home_timeline_obj;
933        struct twitter_xml_list *mentions = td->mentions_obj;
934        guint64 last_id = 0;
935        GSList *output = NULL;
936        GSList *l;
937
938        imcb_connected(ic);
939       
940        if (!(td->flags & TWITTER_GOT_TIMELINE)) {
941                return;
942        }
943
944        if (include_mentions && !(td->flags & TWITTER_GOT_MENTIONS)) {
945                return;
946        }
947
948        if (home_timeline && home_timeline->list) {
949                for (l = home_timeline->list; l; l = g_slist_next(l)) {
950                        output = g_slist_insert_sorted(output, l->data, twitter_compare_elements);
951                }
952        }
953
954        if (include_mentions && mentions && mentions->list) {
955                for (l = mentions->list; l; l = g_slist_next(l)) {
956                        if (show_old_mentions < 1 && output && twitter_compare_elements(l->data, output->data) < 0) {
957                                continue;
958                        }
959
960                        output = g_slist_insert_sorted(output, l->data, twitter_compare_elements);
961                }
962        }
963
964        // See if the user wants to see the messages in a groupchat window or as private messages.
965        while (output) {
966                struct twitter_xml_status *txs = output->data;
967                if (txs->id != last_id)
968                        twitter_status_show(ic, txs);
969                last_id = txs->id;
970                output = g_slist_remove(output, txs);
971        }
972
973        txl_free(home_timeline);
974        txl_free(mentions);
975
976        td->flags &= ~(TWITTER_DOING_TIMELINE | TWITTER_GOT_TIMELINE | TWITTER_GOT_MENTIONS);
977        td->home_timeline_obj = td->mentions_obj = NULL;
978}
979
980static void twitter_http_get_home_timeline(struct http_request *req);
981static void twitter_http_get_mentions(struct http_request *req);
982
983/**
984 * Get the timeline.
985 */
986static void twitter_get_home_timeline(struct im_connection *ic, gint64 next_cursor)
987{
988        struct twitter_data *td = ic->proto_data;
989
990        txl_free(td->home_timeline_obj);
991        td->home_timeline_obj = NULL;
992        td->flags &= ~TWITTER_GOT_TIMELINE;
993
994        char *args[6];
995        args[0] = "cursor";
996        args[1] = g_strdup_printf("%lld", (long long) next_cursor);
997        args[2] = "include_entities";
998        args[3] = "true";
999        if (td->timeline_id) {
1000                args[4] = "since_id";
1001                args[5] = g_strdup_printf("%llu", (long long unsigned int) td->timeline_id);
1002        }
1003
1004        if (twitter_http(ic, TWITTER_HOME_TIMELINE_URL, twitter_http_get_home_timeline, ic, 0, args,
1005                     td->timeline_id ? 6 : 4) == NULL) {
1006                if (++td->http_fails >= 5)
1007                        imcb_error(ic, "Could not retrieve %s: %s",
1008                                   TWITTER_HOME_TIMELINE_URL, "connection failed");
1009                td->flags |= TWITTER_GOT_TIMELINE;
1010                twitter_flush_timeline(ic);
1011        }
1012
1013        g_free(args[1]);
1014        if (td->timeline_id) {
1015                g_free(args[5]);
1016        }
1017}
1018
1019/**
1020 * Get mentions.
1021 */
1022static void twitter_get_mentions(struct im_connection *ic, gint64 next_cursor)
1023{
1024        struct twitter_data *td = ic->proto_data;
1025
1026        txl_free(td->mentions_obj);
1027        td->mentions_obj = NULL;
1028        td->flags &= ~TWITTER_GOT_MENTIONS;
1029
1030        char *args[6];
1031        args[0] = "cursor";
1032        args[1] = g_strdup_printf("%lld", (long long) next_cursor);
1033        args[2] = "include_entities";
1034        args[3] = "true";
1035        if (td->timeline_id) {
1036                args[4] = "since_id";
1037                args[5] = g_strdup_printf("%llu", (long long unsigned int) td->timeline_id);
1038        } else {
1039                args[4] = "count";
1040                args[5] = g_strdup_printf("%d", set_getint(&ic->acc->set, "show_old_mentions"));
1041        }
1042
1043        if (twitter_http(ic, TWITTER_MENTIONS_URL, twitter_http_get_mentions,
1044                         ic, 0, args, 6) == NULL) {
1045                if (++td->http_fails >= 5)
1046                        imcb_error(ic, "Could not retrieve %s: %s",
1047                                   TWITTER_MENTIONS_URL, "connection failed");
1048                td->flags |= TWITTER_GOT_MENTIONS;
1049                twitter_flush_timeline(ic);
1050        }
1051
1052        g_free(args[1]);
1053        g_free(args[5]);
1054}
1055
1056/**
1057 * Callback for getting the home timeline.
1058 */
1059static void twitter_http_get_home_timeline(struct http_request *req)
1060{
1061        struct im_connection *ic = req->data;
1062        struct twitter_data *td;
1063        json_value *parsed;
1064        struct twitter_xml_list *txl;
1065
1066        // Check if the connection is still active.
1067        if (!g_slist_find(twitter_connections, ic))
1068                return;
1069
1070        td = ic->proto_data;
1071
1072        txl = g_new0(struct twitter_xml_list, 1);
1073        txl->list = NULL;
1074
1075        // The root <statuses> node should hold the list of statuses <status>
1076        if (!(parsed = twitter_parse_response(ic, req)))
1077                goto end;
1078        twitter_xt_get_status_list(ic, parsed, txl);
1079        json_value_free(parsed);
1080
1081        td->home_timeline_obj = txl;
1082
1083      end:
1084        if (!g_slist_find(twitter_connections, ic))
1085                return;
1086
1087        td->flags |= TWITTER_GOT_TIMELINE;
1088
1089        twitter_flush_timeline(ic);
1090}
1091
1092/**
1093 * Callback for getting mentions.
1094 */
1095static void twitter_http_get_mentions(struct http_request *req)
1096{
1097        struct im_connection *ic = req->data;
1098        struct twitter_data *td;
1099        json_value *parsed;
1100        struct twitter_xml_list *txl;
1101
1102        // Check if the connection is still active.
1103        if (!g_slist_find(twitter_connections, ic))
1104                return;
1105
1106        td = ic->proto_data;
1107
1108        txl = g_new0(struct twitter_xml_list, 1);
1109        txl->list = NULL;
1110
1111        // The root <statuses> node should hold the list of statuses <status>
1112        if (!(parsed = twitter_parse_response(ic, req)))
1113                goto end;
1114        twitter_xt_get_status_list(ic, parsed, txl);
1115        json_value_free(parsed);
1116
1117        td->mentions_obj = txl;
1118
1119      end:
1120        if (!g_slist_find(twitter_connections, ic))
1121                return;
1122
1123        td->flags |= TWITTER_GOT_MENTIONS;
1124
1125        twitter_flush_timeline(ic);
1126}
1127
1128/**
1129 * Callback to use after sending a POST request to twitter.
1130 * (Generic, used for a few kinds of queries.)
1131 */
1132static void twitter_http_post(struct http_request *req)
1133{
1134        struct im_connection *ic = req->data;
1135        struct twitter_data *td;
1136        json_value *parsed, *id;
1137
1138        // Check if the connection is still active.
1139        if (!g_slist_find(twitter_connections, ic))
1140                return;
1141
1142        td = ic->proto_data;
1143        td->last_status_id = 0;
1144
1145        if (!(parsed = twitter_parse_response(ic, req)))
1146                return;
1147       
1148        if ((id = json_o_get(parsed, "id")) && id->type == json_integer) {
1149                td->last_status_id = id->u.integer;
1150        }
1151       
1152        json_value_free(parsed);
1153       
1154        if (req->flags & TWITTER_HTTP_USER_ACK)
1155                twitter_log(ic, "Command processed successfully");
1156}
1157
1158/**
1159 * Function to POST a new status to twitter.
1160 */
1161void twitter_post_status(struct im_connection *ic, char *msg, guint64 in_reply_to)
1162{
1163        char *args[4] = {
1164                "status", msg,
1165                "in_reply_to_status_id",
1166                g_strdup_printf("%llu", (unsigned long long) in_reply_to)
1167        };
1168        twitter_http(ic, TWITTER_STATUS_UPDATE_URL, twitter_http_post, ic, 1,
1169                     args, in_reply_to ? 4 : 2);
1170        g_free(args[3]);
1171}
1172
1173
1174/**
1175 * Function to POST a new message to twitter.
1176 */
1177void twitter_direct_messages_new(struct im_connection *ic, char *who, char *msg)
1178{
1179        char *args[4];
1180        args[0] = "screen_name";
1181        args[1] = who;
1182        args[2] = "text";
1183        args[3] = msg;
1184        // Use the same callback as for twitter_post_status, since it does basically the same.
1185        twitter_http(ic, TWITTER_DIRECT_MESSAGES_NEW_URL, twitter_http_post, ic, 1, args, 4);
1186}
1187
1188void twitter_friendships_create_destroy(struct im_connection *ic, char *who, int create)
1189{
1190        char *args[2];
1191        args[0] = "screen_name";
1192        args[1] = who;
1193        twitter_http(ic, create ? TWITTER_FRIENDSHIPS_CREATE_URL : TWITTER_FRIENDSHIPS_DESTROY_URL,
1194                     twitter_http_post, ic, 1, args, 2);
1195}
1196
1197void twitter_status_destroy(struct im_connection *ic, guint64 id)
1198{
1199        char *url;
1200        url = g_strdup_printf("%s%llu%s", TWITTER_STATUS_DESTROY_URL,
1201                              (unsigned long long) id, ".json");
1202        twitter_http_f(ic, url, twitter_http_post, ic, 1, NULL, 0,
1203                       TWITTER_HTTP_USER_ACK);
1204        g_free(url);
1205}
1206
1207void twitter_status_retweet(struct im_connection *ic, guint64 id)
1208{
1209        char *url;
1210        url = g_strdup_printf("%s%llu%s", TWITTER_STATUS_RETWEET_URL,
1211                              (unsigned long long) id, ".json");
1212        twitter_http_f(ic, url, twitter_http_post, ic, 1, NULL, 0,
1213                       TWITTER_HTTP_USER_ACK);
1214        g_free(url);
1215}
1216
1217/**
1218 * Report a user for sending spam.
1219 */
1220void twitter_report_spam(struct im_connection *ic, char *screen_name)
1221{
1222        char *args[2] = {
1223                "screen_name",
1224                NULL,
1225        };
1226        args[1] = screen_name;
1227        twitter_http_f(ic, TWITTER_REPORT_SPAM_URL, twitter_http_post,
1228                       ic, 1, args, 2, TWITTER_HTTP_USER_ACK);
1229}
1230
1231/**
1232 * Favourite a tweet.
1233 */
1234void twitter_favourite_tweet(struct im_connection *ic, guint64 id)
1235{
1236        char *args[2] = {
1237                "id",
1238                NULL,
1239        };
1240        args[1] = g_strdup_printf("%llu", (unsigned long long) id);
1241        twitter_http_f(ic, TWITTER_FAVORITE_CREATE_URL, twitter_http_post,
1242                       ic, 1, args, 2, TWITTER_HTTP_USER_ACK);
1243        g_free(args[1]);
1244}
Note: See TracBrowser for help on using the repository browser.