source: protocols/twitter/twitter_lib.c @ 90fc864

Last change on this file since 90fc864 was 90fc864, checked in by Wilmer van der Gaast <wilmer@…>, at 2011-11-24T08:18:04Z

Hopefully this fixed #838. Patch from Artem Savkov, thanks! The problem was
HTTP failures caused by (most likely) DNS resolution problems. Yes, ignoring
return values is still bad, kids!

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