source: protocols/twitter/twitter_lib.c @ 32bea82

Last change on this file since 32bea82 was 32bea82, checked in by Wilmer van der Gaast <wilmer@…>, at 2011-10-20T02:59:57Z

changeset:devel,814 was silly and incomplete. This should fix that. Full
workaround for Twitter "hang" problem.

  • Property mode set to 100644
File size: 28.8 KB
Line 
1/***************************************************************************\
2*                                                                           *
3*  BitlBee - An IRC to IM gateway                                           *
4*  Simple module to facilitate twitter functionality.                       *
5*                                                                           *
6*  Copyright 2009 Geert Mulders <g.c.w.m.mulders@gmail.com>                 *
7*                                                                           *
8*  This library is free software; you can redistribute it and/or            *
9*  modify it under the terms of the GNU Lesser General Public               *
10*  License as published by the Free Software Foundation, version            *
11*  2.1.                                                                     *
12*                                                                           *
13*  This library is distributed in the hope that it will be useful,          *
14*  but WITHOUT ANY WARRANTY; without even the implied warranty of           *
15*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU        *
16*  Lesser General Public License for more details.                          *
17*                                                                           *
18*  You should have received a copy of the GNU Lesser General Public License *
19*  along with this library; if not, write to the Free Software Foundation,  *
20*  Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA           *
21*                                                                           *
22****************************************************************************/
23
24/* For strptime(): */
25#if(__sun)
26#else
27#define _XOPEN_SOURCE
28#endif
29
30#include "twitter_http.h"
31#include "twitter.h"
32#include "bitlbee.h"
33#include "url.h"
34#include "misc.h"
35#include "base64.h"
36#include "xmltree.h"
37#include "twitter_lib.h"
38#include <ctype.h>
39#include <errno.h>
40
41/* GLib < 2.12.0 doesn't have g_ascii_strtoll(), work around using system strtoll(). */
42/* GLib < 2.12.4 can be buggy: http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=488013 */
43#if !GLIB_CHECK_VERSION(2,12,5)
44#include <stdlib.h>
45#include <limits.h>
46#define g_ascii_strtoll strtoll
47#endif
48
49#define TXL_STATUS 1
50#define TXL_USER 2
51#define TXL_ID 3
52
53struct twitter_xml_list {
54        int type;
55        gint64 next_cursor;
56        GSList *list;
57};
58
59struct twitter_xml_user {
60        char *name;
61        char *screen_name;
62};
63
64struct twitter_xml_status {
65        time_t created_at;
66        char *text;
67        struct twitter_xml_user *user;
68        guint64 id, reply_to;
69};
70
71static void twitter_groupchat_init(struct im_connection *ic);
72
73/**
74 * Frees a twitter_xml_user struct.
75 */
76static void txu_free(struct twitter_xml_user *txu)
77{
78        if (txu == NULL)
79                return;
80
81        g_free(txu->name);
82        g_free(txu->screen_name);
83        g_free(txu);
84}
85
86/**
87 * Frees a twitter_xml_status struct.
88 */
89static void txs_free(struct twitter_xml_status *txs)
90{
91        if (txs == NULL)
92                return;
93
94        g_free(txs->text);
95        txu_free(txs->user);
96        g_free(txs);
97}
98
99/**
100 * Free a twitter_xml_list struct.
101 * type is the type of list the struct holds.
102 */
103static void txl_free(struct twitter_xml_list *txl)
104{
105        GSList *l;
106        if (txl == NULL)
107                return;
108
109        for (l = txl->list; l; l = g_slist_next(l)) {
110                if (txl->type == TXL_STATUS) {
111                        txs_free((struct twitter_xml_status *) l->data);
112                } else if (txl->type == TXL_ID) {
113                        g_free(l->data);
114                } else if (txl->type == TXL_USER) {
115                        txu_free(l->data);
116                }
117        }
118
119        g_slist_free(txl->list);
120        g_free(txl);
121}
122
123/**
124 * Compare status elements
125 */
126static gint twitter_compare_elements(gconstpointer a, gconstpointer b)
127{
128        struct twitter_xml_status *a_status = (struct twitter_xml_status *) a;
129        struct twitter_xml_status *b_status = (struct twitter_xml_status *) b;
130
131        if (a_status->created_at < b_status->created_at) {
132                return -1;
133        } else if (a_status->created_at > b_status->created_at) {
134                return 1;
135        } else {
136                return 0;
137        }
138}
139
140/**
141 * Add a buddy if it is not already added, set the status to logged in.
142 */
143static void twitter_add_buddy(struct im_connection *ic, char *name, const char *fullname)
144{
145        struct twitter_data *td = ic->proto_data;
146
147        // Check if the buddy is already in the buddy list.
148        if (!bee_user_by_handle(ic->bee, ic, name)) {
149                char *mode = set_getstr(&ic->acc->set, "mode");
150
151                // The buddy is not in the list, add the buddy and set the status to logged in.
152                imcb_add_buddy(ic, name, NULL);
153                imcb_rename_buddy(ic, name, fullname);
154                if (g_strcasecmp(mode, "chat") == 0) {
155                        /* Necessary so that nicks always get translated to the
156                           exact Twitter username. */
157                        imcb_buddy_nick_hint(ic, name, name);
158                        imcb_chat_add_buddy(td->timeline_gc, name);
159                } else if (g_strcasecmp(mode, "many") == 0)
160                        imcb_buddy_status(ic, name, OPT_LOGGED_IN, NULL, NULL);
161        }
162}
163
164/* Warning: May return a malloc()ed value, which will be free()d on the next
165   call. Only for short-term use. NOT THREADSAFE!  */
166char *twitter_parse_error(struct http_request *req)
167{
168        static char *ret = NULL;
169        struct xt_parser *xp = NULL;
170        struct xt_node *node, *err;
171
172        g_free(ret);
173        ret = NULL;
174
175        if (req->body_size > 0) {
176                xp = xt_new(NULL, NULL);
177                xt_feed(xp, req->reply_body, req->body_size);
178               
179                for (node = xp->root; node; node = node->next)
180                        if ((err = xt_find_node(node->children, "error")) && err->text_len > 0) {
181                                ret = g_strdup_printf("%s (%s)", req->status_string, err->text);
182                                break;
183                        }
184
185                xt_free(xp);
186        }
187
188        return ret ? ret : req->status_string;
189}
190
191static void twitter_http_get_friends_ids(struct http_request *req);
192
193/**
194 * Get the friends ids.
195 */
196void twitter_get_friends_ids(struct im_connection *ic, gint64 next_cursor)
197{
198        // Primitive, but hey! It works...     
199        char *args[2];
200        args[0] = "cursor";
201        args[1] = g_strdup_printf("%lld", (long long) next_cursor);
202        twitter_http(ic, TWITTER_FRIENDS_IDS_URL, twitter_http_get_friends_ids, ic, 0, args, 2);
203
204        g_free(args[1]);
205}
206
207/**
208 * Function to help fill a list.
209 */
210static xt_status twitter_xt_next_cursor(struct xt_node *node, struct twitter_xml_list *txl)
211{
212        char *end = NULL;
213
214        if (node->text)
215                txl->next_cursor = g_ascii_strtoll(node->text, &end, 10);
216        if (end == NULL)
217                txl->next_cursor = -1;
218
219        return XT_HANDLED;
220}
221
222/**
223 * Fill a list of ids.
224 */
225static xt_status twitter_xt_get_friends_id_list(struct xt_node *node, struct twitter_xml_list *txl)
226{
227        struct xt_node *child;
228
229        // Set the list type.
230        txl->type = TXL_ID;
231
232        // The root <statuses> node should hold the list of statuses <status>
233        // Walk over the nodes children.
234        for (child = node->children; child; child = child->next) {
235                if (g_strcasecmp("ids", child->name) == 0) {
236                        struct xt_node *idc;
237                        for (idc = child->children; idc; idc = idc->next)
238                                if (g_strcasecmp(idc->name, "id") == 0)
239                                        txl->list = g_slist_prepend(txl->list,
240                                                g_memdup(idc->text, idc->text_len + 1));
241                } else if (g_strcasecmp("next_cursor", child->name) == 0) {
242                        twitter_xt_next_cursor(child, txl);
243                }
244        }
245
246        return XT_HANDLED;
247}
248
249static void twitter_get_users_lookup(struct im_connection *ic);
250
251/**
252 * Callback for getting the friends ids.
253 */
254static void twitter_http_get_friends_ids(struct http_request *req)
255{
256        struct im_connection *ic;
257        struct xt_parser *parser;
258        struct twitter_xml_list *txl;
259        struct twitter_data *td;
260
261        ic = req->data;
262
263        // Check if the connection is still active.
264        if (!g_slist_find(twitter_connections, ic))
265                return;
266
267        td = ic->proto_data;
268
269        // Check if the HTTP request went well. More strict checks as this is
270        // the first request we do in a session.
271        if (req->status_code == 401) {
272                imcb_error(ic, "Authentication failure");
273                imc_logout(ic, FALSE);
274                return;
275        } else if (req->status_code != 200) {
276                // It didn't go well, output the error and return.
277                imcb_error(ic, "Could not retrieve %s: %s",
278                           TWITTER_FRIENDS_IDS_URL, twitter_parse_error(req));
279                imc_logout(ic, TRUE);
280                return;
281        } else {
282                td->http_fails = 0;
283        }
284
285        /* Create the room now that we "logged in". */
286        if (!td->timeline_gc && g_strcasecmp(set_getstr(&ic->acc->set, "mode"), "chat") == 0)
287                twitter_groupchat_init(ic);
288
289        txl = g_new0(struct twitter_xml_list, 1);
290        txl->list = td->follow_ids;
291
292        // Parse the data.
293        parser = xt_new(NULL, txl);
294        xt_feed(parser, req->reply_body, req->body_size);
295        twitter_xt_get_friends_id_list(parser->root, txl);
296        xt_free(parser);
297
298        td->follow_ids = txl->list;
299        if (txl->next_cursor)
300                /* These were just numbers. Up to 4000 in a response AFAIK so if we get here
301                   we may be using a spammer account. \o/ */
302                twitter_get_friends_ids(ic, txl->next_cursor);
303        else
304                /* Now to convert all those numbers into names.. */
305                twitter_get_users_lookup(ic);
306
307        txl->list = NULL;
308        txl_free(txl);
309}
310
311static xt_status twitter_xt_get_users(struct xt_node *node, struct twitter_xml_list *txl);
312static void twitter_http_get_users_lookup(struct http_request *req);
313
314static void twitter_get_users_lookup(struct im_connection *ic)
315{
316        struct twitter_data *td = ic->proto_data;
317        char *args[2] = {
318                "user_id",
319                NULL,
320        };
321        GString *ids = g_string_new("");
322        int i;
323       
324        /* We can request up to 100 users at a time. */
325        for (i = 0; i < 100 && td->follow_ids; i ++) {
326                g_string_append_printf(ids, ",%s", (char*) td->follow_ids->data);
327                g_free(td->follow_ids->data);
328                td->follow_ids = g_slist_remove(td->follow_ids, td->follow_ids->data);
329        }
330        if (ids->len > 0) {
331                args[1] = ids->str + 1;
332                /* POST, because I think ids can be up to 1KB long. */
333                twitter_http(ic, TWITTER_USERS_LOOKUP_URL, twitter_http_get_users_lookup, ic, 1, args, 2);
334        } else {
335                /* We have all users. Continue with login. (Get statuses.) */
336                td->flags |= TWITTER_HAVE_FRIENDS;
337                twitter_login_finish(ic);
338        }
339        g_string_free(ids, TRUE);
340}
341
342/**
343 * Callback for getting (twitter)friends...
344 *
345 * Be afraid, be very afraid! This function will potentially add hundreds of "friends". "Who has
346 * hundreds of friends?" you wonder? You probably not, since you are reading the source of
347 * BitlBee... Get a life and meet new people!
348 */
349static void twitter_http_get_users_lookup(struct http_request *req)
350{
351        struct im_connection *ic = req->data;
352        struct twitter_data *td;
353        struct xt_parser *parser;
354        struct twitter_xml_list *txl;
355        GSList *l = NULL;
356        struct twitter_xml_user *user;
357
358        // Check if the connection is still active.
359        if (!g_slist_find(twitter_connections, ic))
360                return;
361
362        td = ic->proto_data;
363
364        if (req->status_code != 200) {
365                // It didn't go well, output the error and return.
366                imcb_error(ic, "Could not retrieve %s: %s",
367                           TWITTER_USERS_LOOKUP_URL, twitter_parse_error(req));
368                imc_logout(ic, TRUE);
369                return;
370        } else {
371                td->http_fails = 0;
372        }
373
374        txl = g_new0(struct twitter_xml_list, 1);
375        txl->list = NULL;
376
377        // Parse the data.
378        parser = xt_new(NULL, txl);
379        xt_feed(parser, req->reply_body, req->body_size);
380
381        // Get the user list from the parsed xml feed.
382        twitter_xt_get_users(parser->root, txl);
383        xt_free(parser);
384
385        // Add the users as buddies.
386        for (l = txl->list; l; l = g_slist_next(l)) {
387                user = l->data;
388                twitter_add_buddy(ic, user->screen_name, user->name);
389        }
390
391        // Free the structure.
392        txl_free(txl);
393
394        twitter_get_users_lookup(ic);
395}
396
397/**
398 * Function to fill a twitter_xml_user struct.
399 * It sets:
400 *  - the name and
401 *  - the screen_name.
402 */
403static xt_status twitter_xt_get_user(struct xt_node *node, struct twitter_xml_user *txu)
404{
405        struct xt_node *child;
406
407        // Walk over the nodes children.
408        for (child = node->children; child; child = child->next) {
409                if (g_strcasecmp("name", child->name) == 0) {
410                        txu->name = g_memdup(child->text, child->text_len + 1);
411                } else if (g_strcasecmp("screen_name", child->name) == 0) {
412                        txu->screen_name = g_memdup(child->text, child->text_len + 1);
413                }
414        }
415        return XT_HANDLED;
416}
417
418/**
419 * Function to fill a twitter_xml_list struct.
420 * It sets:
421 *  - all <user>s from the <users> element.
422 */
423static xt_status twitter_xt_get_users(struct xt_node *node, struct twitter_xml_list *txl)
424{
425        struct twitter_xml_user *txu;
426        struct xt_node *child;
427
428        // Set the type of the list.
429        txl->type = TXL_USER;
430
431        // The root <users> node should hold the list of users <user>
432        // Walk over the nodes children.
433        for (child = node->children; child; child = child->next) {
434                if (g_strcasecmp("user", child->name) == 0) {
435                        txu = g_new0(struct twitter_xml_user, 1);
436                        twitter_xt_get_user(child, txu);
437                        // Put the item in the front of the list.
438                        txl->list = g_slist_prepend(txl->list, txu);
439                }
440        }
441
442        return XT_HANDLED;
443}
444
445#ifdef __GLIBC__
446#define TWITTER_TIME_FORMAT "%a %b %d %H:%M:%S %z %Y"
447#else
448#define TWITTER_TIME_FORMAT "%a %b %d %H:%M:%S +0000 %Y"
449#endif
450
451/**
452 * Function to fill a twitter_xml_status struct.
453 * It sets:
454 *  - the status text and
455 *  - the created_at timestamp and
456 *  - the status id and
457 *  - the user in a twitter_xml_user struct.
458 */
459static xt_status twitter_xt_get_status(struct xt_node *node, struct twitter_xml_status *txs)
460{
461        struct xt_node *child, *rt = NULL;
462
463        // Walk over the nodes children.
464        for (child = node->children; child; child = child->next) {
465                if (g_strcasecmp("text", child->name) == 0) {
466                        txs->text = g_memdup(child->text, child->text_len + 1);
467                } else if (g_strcasecmp("retweeted_status", child->name) == 0) {
468                        rt = child;
469                } else if (g_strcasecmp("created_at", child->name) == 0) {
470                        struct tm parsed;
471
472                        /* Very sensitive to changes to the formatting of
473                           this field. :-( Also assumes the timezone used
474                           is UTC since C time handling functions suck. */
475                        if (strptime(child->text, TWITTER_TIME_FORMAT, &parsed) != NULL)
476                                txs->created_at = mktime_utc(&parsed);
477                } else if (g_strcasecmp("user", child->name) == 0) {
478                        txs->user = g_new0(struct twitter_xml_user, 1);
479                        twitter_xt_get_user(child, txs->user);
480                } else if (g_strcasecmp("id", child->name) == 0) {
481                        txs->id = g_ascii_strtoull(child->text, NULL, 10);
482                } else if (g_strcasecmp("in_reply_to_status_id", child->name) == 0) {
483                        txs->reply_to = g_ascii_strtoull(child->text, NULL, 10);
484                }
485        }
486
487        /* If it's a (truncated) retweet, get the original. Even if the API claims it
488           wasn't truncated because it may be lying. */
489        if (rt) {
490                struct twitter_xml_status *rtxs = g_new0(struct twitter_xml_status, 1);
491                if (twitter_xt_get_status(rt, rtxs) != XT_HANDLED) {
492                        txs_free(rtxs);
493                        return XT_HANDLED;
494                }
495
496                g_free(txs->text);
497                txs->text = g_strdup_printf("RT @%s: %s", rtxs->user->screen_name, rtxs->text);
498                txs_free(rtxs);
499        } else {
500                struct xt_node *urls, *url;
501               
502                urls = xt_find_path(node, "entities/urls");
503                for (url = urls ? urls->children : NULL; url; url = url->next) {
504                        /* "short" is a reserved word. :-P */
505                        struct xt_node *kort = xt_find_node(url->children, "url");
506                        struct xt_node *disp = xt_find_node(url->children, "display_url");
507                        char *pos, *new;
508                       
509                        if (!kort || !kort->text || !disp || !disp->text ||
510                            !(pos = strstr(txs->text, kort->text)))
511                                continue;
512                       
513                        *pos = '\0';
514                        new = g_strdup_printf("%s%s &lt;%s&gt;%s", txs->text, kort->text,
515                                              disp->text, pos + strlen(kort->text));
516                       
517                        g_free(txs->text);
518                        txs->text = new;
519                }
520        }
521
522        return XT_HANDLED;
523}
524
525/**
526 * Function to fill a twitter_xml_list struct.
527 * It sets:
528 *  - all <status>es within the <status> element and
529 *  - the next_cursor.
530 */
531static xt_status twitter_xt_get_status_list(struct im_connection *ic, struct xt_node *node,
532                                            struct twitter_xml_list *txl)
533{
534        struct twitter_xml_status *txs;
535        struct xt_node *child;
536        bee_user_t *bu;
537
538        // Set the type of the list.
539        txl->type = TXL_STATUS;
540
541        // The root <statuses> node should hold the list of statuses <status>
542        // Walk over the nodes children.
543        for (child = node->children; child; child = child->next) {
544                if (g_strcasecmp("status", child->name) == 0) {
545                        txs = g_new0(struct twitter_xml_status, 1);
546                        twitter_xt_get_status(child, txs);
547                        // Put the item in the front of the list.
548                        txl->list = g_slist_prepend(txl->list, txs);
549
550                        if (txs->user && txs->user->screen_name &&
551                            (bu = bee_user_by_handle(ic->bee, ic, txs->user->screen_name))) {
552                                struct twitter_user_data *tud = bu->data;
553
554                                if (txs->id > tud->last_id) {
555                                        tud->last_id = txs->id;
556                                        tud->last_time = txs->created_at;
557                                }
558                        }
559                } else if (g_strcasecmp("next_cursor", child->name) == 0) {
560                        twitter_xt_next_cursor(child, txl);
561                }
562        }
563
564        return XT_HANDLED;
565}
566
567static char *twitter_msg_add_id(struct im_connection *ic,
568                                struct twitter_xml_status *txs, const char *prefix)
569{
570        struct twitter_data *td = ic->proto_data;
571        char *ret = NULL;
572
573        if (!set_getbool(&ic->acc->set, "show_ids")) {
574                if (*prefix)
575                        return g_strconcat(prefix, txs->text, NULL);
576                else
577                        return NULL;
578        }
579
580        td->log[td->log_id].id = txs->id;
581        td->log[td->log_id].bu = bee_user_by_handle(ic->bee, ic, txs->user->screen_name);
582        if (txs->reply_to) {
583                int i;
584                for (i = 0; i < TWITTER_LOG_LENGTH; i++)
585                        if (td->log[i].id == txs->reply_to) {
586                                ret = g_strdup_printf("\002[\002%02d->%02d\002]\002 %s%s",
587                                                      td->log_id, i, prefix, txs->text);
588                                break;
589                        }
590        }
591        if (ret == NULL)
592                ret = g_strdup_printf("\002[\002%02d\002]\002 %s%s", td->log_id, prefix, txs->text);
593        td->log_id = (td->log_id + 1) % TWITTER_LOG_LENGTH;
594
595        return ret;
596}
597
598static void twitter_groupchat_init(struct im_connection *ic)
599{
600        char *name_hint;
601        struct groupchat *gc;
602        struct twitter_data *td = ic->proto_data;
603        GSList *l;
604
605        td->timeline_gc = gc = imcb_chat_new(ic, "twitter/timeline");
606
607        name_hint = g_strdup_printf("%s_%s", td->prefix, ic->acc->user);
608        imcb_chat_name_hint(gc, name_hint);
609        g_free(name_hint);
610
611        for (l = ic->bee->users; l; l = l->next) {
612                bee_user_t *bu = l->data;
613                if (bu->ic == ic)
614                        imcb_chat_add_buddy(td->timeline_gc, bu->handle);
615        }
616}
617
618/**
619 * Function that is called to see the statuses in a groupchat window.
620 */
621static void twitter_groupchat(struct im_connection *ic, GSList * list)
622{
623        struct twitter_data *td = ic->proto_data;
624        GSList *l = NULL;
625        struct twitter_xml_status *status;
626        struct groupchat *gc;
627        guint64 last_id = 0;
628
629        // Create a new groupchat if it does not exsist.
630        if (!td->timeline_gc)
631                twitter_groupchat_init(ic);
632
633        gc = td->timeline_gc;
634        if (!gc->joined)
635                imcb_chat_add_buddy(gc, ic->acc->user);
636
637        for (l = list; l; l = g_slist_next(l)) {
638                char *msg;
639
640                status = l->data;
641                if (status->user == NULL || status->text == NULL || last_id == status->id)
642                        continue;
643
644                last_id = status->id;
645
646                strip_html(status->text);
647
648                msg = twitter_msg_add_id(ic, status, "");
649
650                // Say it!
651                if (g_strcasecmp(td->user, status->user->screen_name) == 0) {
652                        imcb_chat_log(gc, "You: %s", msg ? msg : status->text);
653                } else {
654                        twitter_add_buddy(ic, status->user->screen_name, status->user->name);
655
656                        imcb_chat_msg(gc, status->user->screen_name,
657                                      msg ? msg : status->text, 0, status->created_at);
658                }
659
660                g_free(msg);
661
662                // Update the timeline_id to hold the highest id, so that by the next request
663                // we won't pick up the updates already in the list.
664                td->timeline_id = MAX(td->timeline_id, status->id);
665        }
666}
667
668/**
669 * Function that is called to see statuses as private messages.
670 */
671static void twitter_private_message_chat(struct im_connection *ic, GSList * list)
672{
673        struct twitter_data *td = ic->proto_data;
674        GSList *l = NULL;
675        struct twitter_xml_status *status;
676        char from[MAX_STRING];
677        gboolean mode_one;
678        guint64 last_id = 0;
679
680        mode_one = g_strcasecmp(set_getstr(&ic->acc->set, "mode"), "one") == 0;
681
682        if (mode_one) {
683                g_snprintf(from, sizeof(from) - 1, "%s_%s", td->prefix, ic->acc->user);
684                from[MAX_STRING - 1] = '\0';
685        }
686
687        for (l = list; l; l = g_slist_next(l)) {
688                char *prefix = NULL, *text = NULL;
689
690                status = l->data;
691                if (status->user == NULL || status->text == NULL || last_id == status->id)
692                        continue;
693
694                last_id = status->id;
695
696                strip_html(status->text);
697                if (mode_one)
698                        prefix = g_strdup_printf("\002<\002%s\002>\002 ",
699                                                 status->user->screen_name);
700                else
701                        twitter_add_buddy(ic, status->user->screen_name, status->user->name);
702
703                text = twitter_msg_add_id(ic, status, prefix ? prefix : "");
704
705                imcb_buddy_msg(ic,
706                               mode_one ? from : status->user->screen_name,
707                               text ? text : status->text, 0, status->created_at);
708
709                // Update the timeline_id to hold the highest id, so that by the next request
710                // we won't pick up the updates already in the list.
711                td->timeline_id = MAX(td->timeline_id, status->id);
712
713                g_free(text);
714                g_free(prefix);
715        }
716}
717
718static void twitter_http_get_home_timeline(struct http_request *req);
719static void twitter_http_get_mentions(struct http_request *req);
720
721/**
722 * Get the timeline with optionally mentions
723 */
724void twitter_get_timeline(struct im_connection *ic, gint64 next_cursor)
725{
726        struct twitter_data *td = ic->proto_data;
727        gboolean include_mentions = set_getbool(&ic->acc->set, "fetch_mentions");
728
729        if ((td->flags & 0xf0000) == (TWITTER_DOING_TIMELINE | TWITTER_DOING_TIMELINE_SLOW)) {
730                imcb_log(ic, "Connection seems to have stalled again.\n"
731                             "This is a known bug, if you see this happen a lot "
732                             "please generate some traffic dumps.");
733                td->flags &= ~0xf0000;
734        }
735
736        if (td->flags & TWITTER_DOING_TIMELINE) {
737                /* This shouldn't normally happen at all but I'm currently hunting a bug
738                   where it does. Instead of having users suffer under it, have a work-
739                   around with a warning. */
740                td->flags |= TWITTER_DOING_TIMELINE_SLOW;
741                return;
742        }
743
744        td->flags |= TWITTER_DOING_TIMELINE;
745
746        twitter_get_home_timeline(ic, next_cursor);
747
748        if (include_mentions) {
749                twitter_get_mentions(ic, next_cursor);
750        }
751}
752
753/**
754 * Call this one after receiving timeline/mentions. Show to user once we have
755 * both.
756 */
757void twitter_flush_timeline(struct im_connection *ic)
758{
759        struct twitter_data *td = ic->proto_data;
760        gboolean include_mentions = set_getbool(&ic->acc->set, "fetch_mentions");
761        gboolean show_old_mentions = set_getbool(&ic->acc->set, "show_old_mentions");
762        struct twitter_xml_list *home_timeline = td->home_timeline_obj;
763        struct twitter_xml_list *mentions = td->mentions_obj;
764        GSList *output = NULL;
765        GSList *l;
766
767        if (!(td->flags & TWITTER_GOT_TIMELINE)) {
768                return;
769        }
770
771        if (include_mentions && !(td->flags & TWITTER_GOT_MENTIONS)) {
772                return;
773        }
774
775        if (home_timeline && home_timeline->list) {
776                for (l = home_timeline->list; l; l = g_slist_next(l)) {
777                        output = g_slist_insert_sorted(output, l->data, twitter_compare_elements);
778                }
779        }
780
781        if (include_mentions && mentions && mentions->list) {
782                for (l = mentions->list; l; l = g_slist_next(l)) {
783                        if (!show_old_mentions && output && twitter_compare_elements(l->data, output->data) < 0) {
784                                continue;
785                        }
786
787                        output = g_slist_insert_sorted(output, l->data, twitter_compare_elements);
788                }
789        }
790
791        // See if the user wants to see the messages in a groupchat window or as private messages.
792        if (g_strcasecmp(set_getstr(&ic->acc->set, "mode"), "chat") == 0)
793                twitter_groupchat(ic, output);
794        else
795                twitter_private_message_chat(ic, output);
796
797        g_slist_free(output);
798
799        if (home_timeline && home_timeline->list) {
800                txl_free(home_timeline);
801        }
802
803        if (mentions && mentions->list) {
804                txl_free(mentions);
805        }
806
807        td->flags &= ~(TWITTER_DOING_TIMELINE | TWITTER_GOT_TIMELINE | TWITTER_GOT_MENTIONS);
808}
809
810/**
811 * Get the timeline.
812 */
813void twitter_get_home_timeline(struct im_connection *ic, gint64 next_cursor)
814{
815        struct twitter_data *td = ic->proto_data;
816
817        td->home_timeline_obj = NULL;
818        td->flags &= ~TWITTER_GOT_TIMELINE;
819
820        char *args[6];
821        args[0] = "cursor";
822        args[1] = g_strdup_printf("%lld", (long long) next_cursor);
823        args[2] = "include_entities";
824        args[3] = "true";
825        if (td->timeline_id) {
826                args[4] = "since_id";
827                args[5] = g_strdup_printf("%llu", (long long unsigned int) td->timeline_id);
828        }
829
830        twitter_http(ic, TWITTER_HOME_TIMELINE_URL, twitter_http_get_home_timeline, ic, 0, args,
831                     td->timeline_id ? 6 : 4);
832
833        g_free(args[1]);
834        if (td->timeline_id) {
835                g_free(args[5]);
836        }
837}
838
839/**
840 * Get mentions.
841 */
842void twitter_get_mentions(struct im_connection *ic, gint64 next_cursor)
843{
844        struct twitter_data *td = ic->proto_data;
845
846        td->mentions_obj = NULL;
847        td->flags &= ~TWITTER_GOT_MENTIONS;
848
849        char *args[6];
850        args[0] = "cursor";
851        args[1] = g_strdup_printf("%lld", (long long) next_cursor);
852        args[2] = "include_entities";
853        args[3] = "true";
854        if (td->timeline_id) {
855                args[4] = "since_id";
856                args[5] = g_strdup_printf("%llu", (long long unsigned int) td->timeline_id);
857        }
858
859        twitter_http(ic, TWITTER_MENTIONS_URL, twitter_http_get_mentions, ic, 0, args,
860                     td->timeline_id ? 6 : 4);
861
862        g_free(args[1]);
863        if (td->timeline_id) {
864                g_free(args[5]);
865        }
866}
867
868/**
869 * Callback for getting the home timeline.
870 */
871static void twitter_http_get_home_timeline(struct http_request *req)
872{
873        struct im_connection *ic = req->data;
874        struct twitter_data *td;
875        struct xt_parser *parser;
876        struct twitter_xml_list *txl;
877
878        // Check if the connection is still active.
879        if (!g_slist_find(twitter_connections, ic))
880                return;
881
882        td = ic->proto_data;
883
884        // Check if the HTTP request went well.
885        if (req->status_code == 200) {
886                td->http_fails = 0;
887                if (!(ic->flags & OPT_LOGGED_IN))
888                        imcb_connected(ic);
889        } else if (req->status_code == 401) {
890                imcb_error(ic, "Authentication failure");
891                imc_logout(ic, FALSE);
892                goto end;
893        } else {
894                // It didn't go well, output the error and return.
895                if (++td->http_fails >= 5)
896                        imcb_error(ic, "Could not retrieve %s: %s",
897                                   TWITTER_HOME_TIMELINE_URL, twitter_parse_error(req));
898
899                goto end;
900        }
901
902        txl = g_new0(struct twitter_xml_list, 1);
903        txl->list = NULL;
904
905        // Parse the data.
906        parser = xt_new(NULL, txl);
907        xt_feed(parser, req->reply_body, req->body_size);
908        // The root <statuses> node should hold the list of statuses <status>
909        twitter_xt_get_status_list(ic, parser->root, txl);
910        xt_free(parser);
911
912        td->home_timeline_obj = txl;
913
914      end:
915        td->flags |= TWITTER_GOT_TIMELINE;
916
917        twitter_flush_timeline(ic);
918}
919
920/**
921 * Callback for getting mentions.
922 */
923static void twitter_http_get_mentions(struct http_request *req)
924{
925        struct im_connection *ic = req->data;
926        struct twitter_data *td;
927        struct xt_parser *parser;
928        struct twitter_xml_list *txl;
929
930        // Check if the connection is still active.
931        if (!g_slist_find(twitter_connections, ic))
932                return;
933
934        td = ic->proto_data;
935
936        // Check if the HTTP request went well.
937        if (req->status_code == 200) {
938                td->http_fails = 0;
939                if (!(ic->flags & OPT_LOGGED_IN))
940                        imcb_connected(ic);
941        } else if (req->status_code == 401) {
942                imcb_error(ic, "Authentication failure");
943                imc_logout(ic, FALSE);
944                goto end;
945        } else {
946                // It didn't go well, output the error and return.
947                if (++td->http_fails >= 5)
948                        imcb_error(ic, "Could not retrieve " TWITTER_MENTIONS_URL ": %s",
949                                   twitter_parse_error(req));
950
951                goto end;
952        }
953
954        txl = g_new0(struct twitter_xml_list, 1);
955        txl->list = NULL;
956
957        // Parse the data.
958        parser = xt_new(NULL, txl);
959        xt_feed(parser, req->reply_body, req->body_size);
960        // The root <statuses> node should hold the list of statuses <status>
961        twitter_xt_get_status_list(ic, parser->root, txl);
962        xt_free(parser);
963
964        td->mentions_obj = txl;
965
966      end:
967        td->flags |= TWITTER_GOT_MENTIONS;
968
969        twitter_flush_timeline(ic);
970}
971
972/**
973 * Callback to use after sending a POST request to twitter.
974 * (Generic, used for a few kinds of queries.)
975 */
976static void twitter_http_post(struct http_request *req)
977{
978        struct im_connection *ic = req->data;
979        struct twitter_data *td;
980
981        // Check if the connection is still active.
982        if (!g_slist_find(twitter_connections, ic))
983                return;
984
985        td = ic->proto_data;
986        td->last_status_id = 0;
987
988        // Check if the HTTP request went well.
989        if (req->status_code != 200) {
990                // It didn't go well, output the error and return.
991                imcb_error(ic, "HTTP error: %s", twitter_parse_error(req));
992                return;
993        }
994
995        if (req->body_size > 0) {
996                struct xt_parser *xp = NULL;
997                struct xt_node *node;
998
999                xp = xt_new(NULL, NULL);
1000                xt_feed(xp, req->reply_body, req->body_size);
1001
1002                if ((node = xt_find_node(xp->root, "status")) &&
1003                    (node = xt_find_node(node->children, "id")) && node->text)
1004                        td->last_status_id = g_ascii_strtoull(node->text, NULL, 10);
1005
1006                xt_free(xp);
1007        }
1008}
1009
1010/**
1011 * Function to POST a new status to twitter.
1012 */
1013void twitter_post_status(struct im_connection *ic, char *msg, guint64 in_reply_to)
1014{
1015        char *args[4] = {
1016                "status", msg,
1017                "in_reply_to_status_id",
1018                g_strdup_printf("%llu", (unsigned long long) in_reply_to)
1019        };
1020        twitter_http(ic, TWITTER_STATUS_UPDATE_URL, twitter_http_post, ic, 1,
1021                     args, in_reply_to ? 4 : 2);
1022        g_free(args[3]);
1023}
1024
1025
1026/**
1027 * Function to POST a new message to twitter.
1028 */
1029void twitter_direct_messages_new(struct im_connection *ic, char *who, char *msg)
1030{
1031        char *args[4];
1032        args[0] = "screen_name";
1033        args[1] = who;
1034        args[2] = "text";
1035        args[3] = msg;
1036        // Use the same callback as for twitter_post_status, since it does basically the same.
1037        twitter_http(ic, TWITTER_DIRECT_MESSAGES_NEW_URL, twitter_http_post, ic, 1, args, 4);
1038}
1039
1040void twitter_friendships_create_destroy(struct im_connection *ic, char *who, int create)
1041{
1042        char *args[2];
1043        args[0] = "screen_name";
1044        args[1] = who;
1045        twitter_http(ic, create ? TWITTER_FRIENDSHIPS_CREATE_URL : TWITTER_FRIENDSHIPS_DESTROY_URL,
1046                     twitter_http_post, ic, 1, args, 2);
1047}
1048
1049void twitter_status_destroy(struct im_connection *ic, guint64 id)
1050{
1051        char *url;
1052        url = g_strdup_printf("%s%llu%s", TWITTER_STATUS_DESTROY_URL,
1053                              (unsigned long long) id, ".xml");
1054        twitter_http(ic, url, twitter_http_post, ic, 1, NULL, 0);
1055        g_free(url);
1056}
1057
1058void twitter_status_retweet(struct im_connection *ic, guint64 id)
1059{
1060        char *url;
1061        url = g_strdup_printf("%s%llu%s", TWITTER_STATUS_RETWEET_URL,
1062                              (unsigned long long) id, ".xml");
1063        twitter_http(ic, url, twitter_http_post, ic, 1, NULL, 0);
1064        g_free(url);
1065}
Note: See TracBrowser for help on using the repository browser.