source: protocols/twitter/twitter_lib.c @ c148701

Last change on this file since c148701 was 733f607, checked in by Wilmer van der Gaast <wilmer@…>, at 2011-10-18T03:58:14Z

Stupid work-around for bug #838. The troublesome condition is known, I just
don't know exactly how BitlBee gets into it. Any more info from people who
see this problem often would be useful.

  • 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 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                return;
738        }
739
740        td->flags |= TWITTER_DOING_TIMELINE;
741
742        twitter_get_home_timeline(ic, next_cursor);
743
744        if (include_mentions) {
745                twitter_get_mentions(ic, next_cursor);
746        }
747}
748
749/**
750 * Call this one after receiving timeline/mentions. Show to user once we have
751 * both.
752 */
753void twitter_flush_timeline(struct im_connection *ic)
754{
755        struct twitter_data *td = ic->proto_data;
756        gboolean include_mentions = set_getbool(&ic->acc->set, "fetch_mentions");
757        gboolean show_old_mentions = set_getbool(&ic->acc->set, "show_old_mentions");
758        struct twitter_xml_list *home_timeline = td->home_timeline_obj;
759        struct twitter_xml_list *mentions = td->mentions_obj;
760        GSList *output = NULL;
761        GSList *l;
762
763        if (!(td->flags & TWITTER_GOT_TIMELINE)) {
764                return;
765        }
766
767        if (include_mentions && !(td->flags & TWITTER_GOT_MENTIONS)) {
768                return;
769        }
770
771        if (home_timeline && home_timeline->list) {
772                for (l = home_timeline->list; l; l = g_slist_next(l)) {
773                        output = g_slist_insert_sorted(output, l->data, twitter_compare_elements);
774                }
775        }
776
777        if (include_mentions && mentions && mentions->list) {
778                for (l = mentions->list; l; l = g_slist_next(l)) {
779                        if (!show_old_mentions && output && twitter_compare_elements(l->data, output->data) < 0) {
780                                continue;
781                        }
782
783                        output = g_slist_insert_sorted(output, l->data, twitter_compare_elements);
784                }
785        }
786
787        // See if the user wants to see the messages in a groupchat window or as private messages.
788        if (g_strcasecmp(set_getstr(&ic->acc->set, "mode"), "chat") == 0)
789                twitter_groupchat(ic, output);
790        else
791                twitter_private_message_chat(ic, output);
792
793        g_slist_free(output);
794
795        if (home_timeline && home_timeline->list) {
796                txl_free(home_timeline);
797        }
798
799        if (mentions && mentions->list) {
800                txl_free(mentions);
801        }
802
803        td->flags &= ~(TWITTER_DOING_TIMELINE | TWITTER_GOT_TIMELINE | TWITTER_GOT_MENTIONS);
804}
805
806/**
807 * Get the timeline.
808 */
809void twitter_get_home_timeline(struct im_connection *ic, gint64 next_cursor)
810{
811        struct twitter_data *td = ic->proto_data;
812
813        td->home_timeline_obj = NULL;
814        td->flags &= ~TWITTER_GOT_TIMELINE;
815
816        char *args[6];
817        args[0] = "cursor";
818        args[1] = g_strdup_printf("%lld", (long long) next_cursor);
819        args[2] = "include_entities";
820        args[3] = "true";
821        if (td->timeline_id) {
822                args[4] = "since_id";
823                args[5] = g_strdup_printf("%llu", (long long unsigned int) td->timeline_id);
824        }
825
826        twitter_http(ic, TWITTER_HOME_TIMELINE_URL, twitter_http_get_home_timeline, ic, 0, args,
827                     td->timeline_id ? 6 : 4);
828
829        g_free(args[1]);
830        if (td->timeline_id) {
831                g_free(args[5]);
832        }
833}
834
835/**
836 * Get mentions.
837 */
838void twitter_get_mentions(struct im_connection *ic, gint64 next_cursor)
839{
840        struct twitter_data *td = ic->proto_data;
841
842        td->mentions_obj = NULL;
843        td->flags &= ~TWITTER_GOT_MENTIONS;
844
845        char *args[6];
846        args[0] = "cursor";
847        args[1] = g_strdup_printf("%lld", (long long) next_cursor);
848        args[2] = "include_entities";
849        args[3] = "true";
850        if (td->timeline_id) {
851                args[4] = "since_id";
852                args[5] = g_strdup_printf("%llu", (long long unsigned int) td->timeline_id);
853        }
854
855        twitter_http(ic, TWITTER_MENTIONS_URL, twitter_http_get_mentions, ic, 0, args,
856                     td->timeline_id ? 6 : 4);
857
858        g_free(args[1]);
859        if (td->timeline_id) {
860                g_free(args[5]);
861        }
862}
863
864/**
865 * Callback for getting the home timeline.
866 */
867static void twitter_http_get_home_timeline(struct http_request *req)
868{
869        struct im_connection *ic = req->data;
870        struct twitter_data *td;
871        struct xt_parser *parser;
872        struct twitter_xml_list *txl;
873
874        // Check if the connection is still active.
875        if (!g_slist_find(twitter_connections, ic))
876                return;
877
878        td = ic->proto_data;
879
880        // Check if the HTTP request went well.
881        if (req->status_code == 200) {
882                td->http_fails = 0;
883                if (!(ic->flags & OPT_LOGGED_IN))
884                        imcb_connected(ic);
885        } else if (req->status_code == 401) {
886                imcb_error(ic, "Authentication failure");
887                imc_logout(ic, FALSE);
888                goto end;
889        } else {
890                // It didn't go well, output the error and return.
891                if (++td->http_fails >= 5)
892                        imcb_error(ic, "Could not retrieve %s: %s",
893                                   TWITTER_HOME_TIMELINE_URL, twitter_parse_error(req));
894
895                goto end;
896        }
897
898        txl = g_new0(struct twitter_xml_list, 1);
899        txl->list = NULL;
900
901        // Parse the data.
902        parser = xt_new(NULL, txl);
903        xt_feed(parser, req->reply_body, req->body_size);
904        // The root <statuses> node should hold the list of statuses <status>
905        twitter_xt_get_status_list(ic, parser->root, txl);
906        xt_free(parser);
907
908        td->home_timeline_obj = txl;
909
910      end:
911        td->flags |= TWITTER_GOT_TIMELINE;
912
913        twitter_flush_timeline(ic);
914}
915
916/**
917 * Callback for getting mentions.
918 */
919static void twitter_http_get_mentions(struct http_request *req)
920{
921        struct im_connection *ic = req->data;
922        struct twitter_data *td;
923        struct xt_parser *parser;
924        struct twitter_xml_list *txl;
925
926        // Check if the connection is still active.
927        if (!g_slist_find(twitter_connections, ic))
928                return;
929
930        td = ic->proto_data;
931
932        // Check if the HTTP request went well.
933        if (req->status_code == 200) {
934                td->http_fails = 0;
935                if (!(ic->flags & OPT_LOGGED_IN))
936                        imcb_connected(ic);
937        } else if (req->status_code == 401) {
938                imcb_error(ic, "Authentication failure");
939                imc_logout(ic, FALSE);
940                goto end;
941        } else {
942                // It didn't go well, output the error and return.
943                if (++td->http_fails >= 5)
944                        imcb_error(ic, "Could not retrieve " TWITTER_MENTIONS_URL ": %s",
945                                   twitter_parse_error(req));
946
947                goto end;
948        }
949
950        txl = g_new0(struct twitter_xml_list, 1);
951        txl->list = NULL;
952
953        // Parse the data.
954        parser = xt_new(NULL, txl);
955        xt_feed(parser, req->reply_body, req->body_size);
956        // The root <statuses> node should hold the list of statuses <status>
957        twitter_xt_get_status_list(ic, parser->root, txl);
958        xt_free(parser);
959
960        td->mentions_obj = txl;
961
962      end:
963        td->flags |= TWITTER_GOT_MENTIONS;
964
965        twitter_flush_timeline(ic);
966}
967
968/**
969 * Callback to use after sending a POST request to twitter.
970 * (Generic, used for a few kinds of queries.)
971 */
972static void twitter_http_post(struct http_request *req)
973{
974        struct im_connection *ic = req->data;
975        struct twitter_data *td;
976
977        // Check if the connection is still active.
978        if (!g_slist_find(twitter_connections, ic))
979                return;
980
981        td = ic->proto_data;
982        td->last_status_id = 0;
983
984        // Check if the HTTP request went well.
985        if (req->status_code != 200) {
986                // It didn't go well, output the error and return.
987                imcb_error(ic, "HTTP error: %s", twitter_parse_error(req));
988                return;
989        }
990
991        if (req->body_size > 0) {
992                struct xt_parser *xp = NULL;
993                struct xt_node *node;
994
995                xp = xt_new(NULL, NULL);
996                xt_feed(xp, req->reply_body, req->body_size);
997
998                if ((node = xt_find_node(xp->root, "status")) &&
999                    (node = xt_find_node(node->children, "id")) && node->text)
1000                        td->last_status_id = g_ascii_strtoull(node->text, NULL, 10);
1001
1002                xt_free(xp);
1003        }
1004}
1005
1006/**
1007 * Function to POST a new status to twitter.
1008 */
1009void twitter_post_status(struct im_connection *ic, char *msg, guint64 in_reply_to)
1010{
1011        char *args[4] = {
1012                "status", msg,
1013                "in_reply_to_status_id",
1014                g_strdup_printf("%llu", (unsigned long long) in_reply_to)
1015        };
1016        twitter_http(ic, TWITTER_STATUS_UPDATE_URL, twitter_http_post, ic, 1,
1017                     args, in_reply_to ? 4 : 2);
1018        g_free(args[3]);
1019}
1020
1021
1022/**
1023 * Function to POST a new message to twitter.
1024 */
1025void twitter_direct_messages_new(struct im_connection *ic, char *who, char *msg)
1026{
1027        char *args[4];
1028        args[0] = "screen_name";
1029        args[1] = who;
1030        args[2] = "text";
1031        args[3] = msg;
1032        // Use the same callback as for twitter_post_status, since it does basically the same.
1033        twitter_http(ic, TWITTER_DIRECT_MESSAGES_NEW_URL, twitter_http_post, ic, 1, args, 4);
1034}
1035
1036void twitter_friendships_create_destroy(struct im_connection *ic, char *who, int create)
1037{
1038        char *args[2];
1039        args[0] = "screen_name";
1040        args[1] = who;
1041        twitter_http(ic, create ? TWITTER_FRIENDSHIPS_CREATE_URL : TWITTER_FRIENDSHIPS_DESTROY_URL,
1042                     twitter_http_post, ic, 1, args, 2);
1043}
1044
1045void twitter_status_destroy(struct im_connection *ic, guint64 id)
1046{
1047        char *url;
1048        url = g_strdup_printf("%s%llu%s", TWITTER_STATUS_DESTROY_URL,
1049                              (unsigned long long) id, ".xml");
1050        twitter_http(ic, url, twitter_http_post, ic, 1, NULL, 0);
1051        g_free(url);
1052}
1053
1054void twitter_status_retweet(struct im_connection *ic, guint64 id)
1055{
1056        char *url;
1057        url = g_strdup_printf("%s%llu%s", TWITTER_STATUS_RETWEET_URL,
1058                              (unsigned long long) id, ".xml");
1059        twitter_http(ic, url, twitter_http_post, ic, 1, NULL, 0);
1060        g_free(url);
1061}
Note: See TracBrowser for help on using the repository browser.