source: protocols/twitter/twitter_lib.c @ 81d40fe

Last change on this file since 81d40fe was c43146d, checked in by Wilmer van der Gaast <wilmer@…>, at 2015-05-03T16:47:19Z

Make replies to self work in Twitter.

Difficult because there's no bee_user struct pointing at the user themselves
so instead just fake one for very limited use.

  • Property mode set to 100644
File size: 40.4 KB
Line 
1/***************************************************************************\
2*                                                                           *
3*  BitlBee - An IRC to IM gateway                                           *
4*  Simple module to facilitate twitter functionality.                       *
5*                                                                           *
6*  Copyright 2009-2010 Geert Mulders <g.c.w.m.mulders@gmail.com>            *
7*  Copyright 2010-2013 Wilmer van der Gaast <wilmer@gaast.net>              *
8*                                                                           *
9*  This library is free software; you can redistribute it and/or            *
10*  modify it under the terms of the GNU Lesser General Public               *
11*  License as published by the Free Software Foundation, version            *
12*  2.1.                                                                     *
13*                                                                           *
14*  This library is distributed in the hope that it will be useful,          *
15*  but WITHOUT ANY WARRANTY; without even the implied warranty of           *
16*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU        *
17*  Lesser General Public License for more details.                          *
18*                                                                           *
19*  You should have received a copy of the GNU Lesser General Public License *
20*  along with this library; if not, write to the Free Software Foundation,  *
21*  Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA           *
22*                                                                           *
23****************************************************************************/
24
25/* For strptime(): */
26#if (__sun)
27#else
28#define _XOPEN_SOURCE
29#endif
30
31#include "twitter_http.h"
32#include "twitter.h"
33#include "bitlbee.h"
34#include "url.h"
35#include "misc.h"
36#include "base64.h"
37#include "twitter_lib.h"
38#include "json_util.h"
39#include <ctype.h>
40#include <errno.h>
41
42#define TXL_STATUS 1
43#define TXL_USER 2
44#define TXL_ID 3
45
46struct twitter_xml_list {
47        int type;
48        gint64 next_cursor;
49        GSList *list;
50};
51
52struct twitter_xml_user {
53        guint64 uid;
54        char *name;
55        char *screen_name;
56};
57
58struct twitter_xml_status {
59        time_t created_at;
60        char *text;
61        struct twitter_xml_user *user;
62        guint64 id, rt_id; /* Usually equal, with RTs id == *original* id */
63        guint64 reply_to;
64        gboolean from_filter;
65};
66
67/**
68 * Frees a twitter_xml_user struct.
69 */
70static void txu_free(struct twitter_xml_user *txu)
71{
72        if (txu == NULL) {
73                return;
74        }
75
76        g_free(txu->name);
77        g_free(txu->screen_name);
78        g_free(txu);
79}
80
81/**
82 * Frees a twitter_xml_status struct.
83 */
84static void txs_free(struct twitter_xml_status *txs)
85{
86        if (txs == NULL) {
87                return;
88        }
89
90        g_free(txs->text);
91        txu_free(txs->user);
92        g_free(txs);
93}
94
95/**
96 * Free a twitter_xml_list struct.
97 * type is the type of list the struct holds.
98 */
99static void txl_free(struct twitter_xml_list *txl)
100{
101        GSList *l;
102
103        if (txl == NULL) {
104                return;
105        }
106
107        for (l = txl->list; l; l = g_slist_next(l)) {
108                if (txl->type == TXL_STATUS) {
109                        txs_free((struct twitter_xml_status *) l->data);
110                } else if (txl->type == TXL_ID) {
111                        g_free(l->data);
112                } else if (txl->type == TXL_USER) {
113                        txu_free(l->data);
114                }
115        }
116
117        g_slist_free(txl->list);
118        g_free(txl);
119}
120
121/**
122 * Compare status elements
123 */
124static gint twitter_compare_elements(gconstpointer a, gconstpointer b)
125{
126        struct twitter_xml_status *a_status = (struct twitter_xml_status *) a;
127        struct twitter_xml_status *b_status = (struct twitter_xml_status *) b;
128
129        if (a_status->created_at < b_status->created_at) {
130                return -1;
131        } else if (a_status->created_at > b_status->created_at) {
132                return 1;
133        } else {
134                return 0;
135        }
136}
137
138/**
139 * Add a buddy if it is not already added, set the status to logged in.
140 */
141static void twitter_add_buddy(struct im_connection *ic, char *name, const char *fullname)
142{
143        struct twitter_data *td = ic->proto_data;
144
145        // Check if the buddy is already in the buddy list.
146        if (!bee_user_by_handle(ic->bee, ic, name)) {
147                // The buddy is not in the list, add the buddy and set the status to logged in.
148                imcb_add_buddy(ic, name, NULL);
149                imcb_rename_buddy(ic, name, fullname);
150                if (td->flags & TWITTER_MODE_CHAT) {
151                        /* Necessary so that nicks always get translated to the
152                           exact Twitter username. */
153                        imcb_buddy_nick_hint(ic, name, name);
154                        if (td->timeline_gc) {
155                                imcb_chat_add_buddy(td->timeline_gc, name);
156                        }
157                } else if (td->flags & TWITTER_MODE_MANY) {
158                        imcb_buddy_status(ic, name, OPT_LOGGED_IN, NULL, NULL);
159                }
160        }
161}
162
163/* Warning: May return a malloc()ed value, which will be free()d on the next
164   call. Only for short-term use. NOT THREADSAFE!  */
165char *twitter_parse_error(struct http_request *req)
166{
167        static char *ret = NULL;
168        json_value *root, *err;
169
170        g_free(ret);
171        ret = NULL;
172
173        if (req->body_size > 0) {
174                root = json_parse(req->reply_body, req->body_size);
175                err = json_o_get(root, "errors");
176                if (err && err->type == json_array && (err = err->u.array.values[0]) &&
177                    err->type == json_object) {
178                        const char *msg = json_o_str(err, "message");
179                        if (msg) {
180                                ret = g_strdup_printf("%s (%s)", req->status_string, msg);
181                        }
182                }
183                json_value_free(root);
184        }
185
186        return ret ? ret : req->status_string;
187}
188
189/* WATCH OUT: This function might or might not destroy your connection.
190   Sub-optimal indeed, but just be careful when this returns NULL! */
191static json_value *twitter_parse_response(struct im_connection *ic, struct http_request *req)
192{
193        gboolean logging_in = !(ic->flags & OPT_LOGGED_IN);
194        gboolean periodic;
195        struct twitter_data *td = ic->proto_data;
196        json_value *ret;
197        char path[64] = "", *s;
198
199        if ((s = strchr(req->request, ' '))) {
200                path[sizeof(path) - 1] = '\0';
201                strncpy(path, s + 1, sizeof(path) - 1);
202                if ((s = strchr(path, '?')) || (s = strchr(path, ' '))) {
203                        *s = '\0';
204                }
205        }
206
207        /* Kinda nasty. :-( Trying to suppress error messages, but only
208           for periodic (i.e. mentions/timeline) queries. */
209        periodic = strstr(path, "timeline") || strstr(path, "mentions");
210
211        if (req->status_code == 401 && logging_in) {
212                /* IIRC Twitter once had an outage where they were randomly
213                   throwing 401s so I'll keep treating this one as fatal
214                   only during login. */
215                imcb_error(ic, "Authentication failure (%s)",
216                           twitter_parse_error(req));
217                imc_logout(ic, FALSE);
218                return NULL;
219        } else if (req->status_code != 200) {
220                // It didn't go well, output the error and return.
221                if (!periodic || logging_in || ++td->http_fails >= 5) {
222                        twitter_log(ic, "Error: Could not retrieve %s: %s",
223                                    path, twitter_parse_error(req));
224                }
225
226                if (logging_in) {
227                        imc_logout(ic, TRUE);
228                }
229                return NULL;
230        } else {
231                td->http_fails = 0;
232        }
233
234        if ((ret = json_parse(req->reply_body, req->body_size)) == NULL) {
235                imcb_error(ic, "Could not retrieve %s: %s",
236                           path, "XML parse error");
237        }
238        return ret;
239}
240
241static void twitter_http_get_friends_ids(struct http_request *req);
242
243/**
244 * Get the friends ids.
245 */
246void twitter_get_friends_ids(struct im_connection *ic, gint64 next_cursor)
247{
248        // Primitive, but hey! It works...
249        char *args[2];
250
251        args[0] = "cursor";
252        args[1] = g_strdup_printf("%" G_GINT64_FORMAT, next_cursor);
253        twitter_http(ic, TWITTER_FRIENDS_IDS_URL, twitter_http_get_friends_ids, ic, 0, args, 2);
254
255        g_free(args[1]);
256}
257
258/**
259 * Fill a list of ids.
260 */
261static gboolean twitter_xt_get_friends_id_list(json_value *node, struct twitter_xml_list *txl)
262{
263        json_value *c;
264        int i;
265
266        // Set the list type.
267        txl->type = TXL_ID;
268
269        c = json_o_get(node, "ids");
270        if (!c || c->type != json_array) {
271                return FALSE;
272        }
273
274        for (i = 0; i < c->u.array.length; i++) {
275                if (c->u.array.values[i]->type != json_integer) {
276                        continue;
277                }
278
279                txl->list = g_slist_prepend(txl->list,
280                                            g_strdup_printf("%" PRIu64, c->u.array.values[i]->u.integer));
281        }
282
283        c = json_o_get(node, "next_cursor");
284        if (c && c->type == json_integer) {
285                txl->next_cursor = c->u.integer;
286        } else {
287                txl->next_cursor = -1;
288        }
289
290        return TRUE;
291}
292
293static void twitter_get_users_lookup(struct im_connection *ic);
294
295/**
296 * Callback for getting the friends ids.
297 */
298static void twitter_http_get_friends_ids(struct http_request *req)
299{
300        struct im_connection *ic;
301        json_value *parsed;
302        struct twitter_xml_list *txl;
303        struct twitter_data *td;
304
305        ic = req->data;
306
307        // Check if the connection is still active.
308        if (!g_slist_find(twitter_connections, ic)) {
309                return;
310        }
311
312        td = ic->proto_data;
313
314        txl = g_new0(struct twitter_xml_list, 1);
315        txl->list = td->follow_ids;
316
317        // Parse the data.
318        if (!(parsed = twitter_parse_response(ic, req))) {
319                return;
320        }
321
322        twitter_xt_get_friends_id_list(parsed, txl);
323        json_value_free(parsed);
324
325        td->follow_ids = txl->list;
326        if (txl->next_cursor) {
327                /* These were just numbers. Up to 4000 in a response AFAIK so if we get here
328                   we may be using a spammer account. \o/ */
329                twitter_get_friends_ids(ic, txl->next_cursor);
330        } else {
331                /* Now to convert all those numbers into names.. */
332                twitter_get_users_lookup(ic);
333        }
334
335        txl->list = NULL;
336        txl_free(txl);
337}
338
339static gboolean twitter_xt_get_users(json_value *node, struct twitter_xml_list *txl);
340static void twitter_http_get_users_lookup(struct http_request *req);
341
342static void twitter_get_users_lookup(struct im_connection *ic)
343{
344        struct twitter_data *td = ic->proto_data;
345        char *args[2] = {
346                "user_id",
347                NULL,
348        };
349        GString *ids = g_string_new("");
350        int i;
351
352        /* We can request up to 100 users at a time. */
353        for (i = 0; i < 100 && td->follow_ids; i++) {
354                g_string_append_printf(ids, ",%s", (char *) td->follow_ids->data);
355                g_free(td->follow_ids->data);
356                td->follow_ids = g_slist_remove(td->follow_ids, td->follow_ids->data);
357        }
358        if (ids->len > 0) {
359                args[1] = ids->str + 1;
360                /* POST, because I think ids can be up to 1KB long. */
361                twitter_http(ic, TWITTER_USERS_LOOKUP_URL, twitter_http_get_users_lookup, ic, 1, args, 2);
362        } else {
363                /* We have all users. Continue with login. (Get statuses.) */
364                td->flags |= TWITTER_HAVE_FRIENDS;
365                twitter_login_finish(ic);
366        }
367        g_string_free(ids, TRUE);
368}
369
370/**
371 * Callback for getting (twitter)friends...
372 *
373 * Be afraid, be very afraid! This function will potentially add hundreds of "friends". "Who has
374 * hundreds of friends?" you wonder? You probably not, since you are reading the source of
375 * BitlBee... Get a life and meet new people!
376 */
377static void twitter_http_get_users_lookup(struct http_request *req)
378{
379        struct im_connection *ic = req->data;
380        json_value *parsed;
381        struct twitter_xml_list *txl;
382        GSList *l = NULL;
383        struct twitter_xml_user *user;
384
385        // Check if the connection is still active.
386        if (!g_slist_find(twitter_connections, ic)) {
387                return;
388        }
389
390        txl = g_new0(struct twitter_xml_list, 1);
391        txl->list = NULL;
392
393        // Get the user list from the parsed xml feed.
394        if (!(parsed = twitter_parse_response(ic, req))) {
395                return;
396        }
397        twitter_xt_get_users(parsed, txl);
398        json_value_free(parsed);
399
400        // Add the users as buddies.
401        for (l = txl->list; l; l = g_slist_next(l)) {
402                user = l->data;
403                twitter_add_buddy(ic, user->screen_name, user->name);
404        }
405
406        // Free the structure.
407        txl_free(txl);
408
409        twitter_get_users_lookup(ic);
410}
411
412struct twitter_xml_user *twitter_xt_get_user(const json_value *node)
413{
414        struct twitter_xml_user *txu;
415        json_value *jv;
416
417        txu = g_new0(struct twitter_xml_user, 1);
418        txu->name = g_strdup(json_o_str(node, "name"));
419        txu->screen_name = g_strdup(json_o_str(node, "screen_name"));
420
421        jv = json_o_get(node, "id");
422        txu->uid = jv->u.integer;
423
424        return txu;
425}
426
427/**
428 * Function to fill a twitter_xml_list struct.
429 * It sets:
430 *  - all <user>s from the <users> element.
431 */
432static gboolean twitter_xt_get_users(json_value *node, struct twitter_xml_list *txl)
433{
434        struct twitter_xml_user *txu;
435        int i;
436
437        // Set the type of the list.
438        txl->type = TXL_USER;
439
440        if (!node || node->type != json_array) {
441                return FALSE;
442        }
443
444        // The root <users> node should hold the list of users <user>
445        // Walk over the nodes children.
446        for (i = 0; i < node->u.array.length; i++) {
447                txu = twitter_xt_get_user(node->u.array.values[i]);
448                if (txu) {
449                        txl->list = g_slist_prepend(txl->list, txu);
450                }
451        }
452
453        return TRUE;
454}
455
456#ifdef __GLIBC__
457#define TWITTER_TIME_FORMAT "%a %b %d %H:%M:%S %z %Y"
458#else
459#define TWITTER_TIME_FORMAT "%a %b %d %H:%M:%S +0000 %Y"
460#endif
461
462static void expand_entities(char **text, const json_value *node);
463
464/**
465 * Function to fill a twitter_xml_status struct.
466 * It sets:
467 *  - the status text and
468 *  - the created_at timestamp and
469 *  - the status id and
470 *  - the user in a twitter_xml_user struct.
471 */
472static struct twitter_xml_status *twitter_xt_get_status(const json_value *node)
473{
474        struct twitter_xml_status *txs;
475        const json_value *rt = NULL;
476
477        if (node->type != json_object) {
478                return FALSE;
479        }
480        txs = g_new0(struct twitter_xml_status, 1);
481
482        JSON_O_FOREACH(node, k, v) {
483                if (strcmp("text", k) == 0 && v->type == json_string) {
484                        txs->text = g_memdup(v->u.string.ptr, v->u.string.length + 1);
485                        strip_html(txs->text);
486                } else if (strcmp("retweeted_status", k) == 0 && v->type == json_object) {
487                        rt = v;
488                } else if (strcmp("created_at", k) == 0 && v->type == json_string) {
489                        struct tm parsed;
490
491                        /* Very sensitive to changes to the formatting of
492                           this field. :-( Also assumes the timezone used
493                           is UTC since C time handling functions suck. */
494                        if (strptime(v->u.string.ptr, TWITTER_TIME_FORMAT, &parsed) != NULL) {
495                                txs->created_at = mktime_utc(&parsed);
496                        }
497                } else if (strcmp("user", k) == 0 && v->type == json_object) {
498                        txs->user = twitter_xt_get_user(v);
499                } else if (strcmp("id", k) == 0 && v->type == json_integer) {
500                        txs->rt_id = txs->id = v->u.integer;
501                } else if (strcmp("in_reply_to_status_id", k) == 0 && v->type == json_integer) {
502                        txs->reply_to = v->u.integer;
503                }
504        }
505
506        /* If it's a (truncated) retweet, get the original. Even if the API claims it
507           wasn't truncated because it may be lying. */
508        if (rt) {
509                struct twitter_xml_status *rtxs = twitter_xt_get_status(rt);
510                if (rtxs) {
511                        g_free(txs->text);
512                        txs->text = g_strdup_printf("RT @%s: %s", rtxs->user->screen_name, rtxs->text);
513                        txs->id = rtxs->id;
514                        txs_free(rtxs);
515                }
516        } else {
517                expand_entities(&txs->text, node);
518        }
519
520        if (txs->text && txs->user && txs->id) {
521                return txs;
522        }
523
524        txs_free(txs);
525        return NULL;
526}
527
528/**
529 * Function to fill a twitter_xml_status struct (DM variant).
530 */
531static struct twitter_xml_status *twitter_xt_get_dm(const json_value *node)
532{
533        struct twitter_xml_status *txs;
534
535        if (node->type != json_object) {
536                return FALSE;
537        }
538        txs = g_new0(struct twitter_xml_status, 1);
539
540        JSON_O_FOREACH(node, k, v) {
541                if (strcmp("text", k) == 0 && v->type == json_string) {
542                        txs->text = g_memdup(v->u.string.ptr, v->u.string.length + 1);
543                        strip_html(txs->text);
544                } else if (strcmp("created_at", k) == 0 && v->type == json_string) {
545                        struct tm parsed;
546
547                        /* Very sensitive to changes to the formatting of
548                           this field. :-( Also assumes the timezone used
549                           is UTC since C time handling functions suck. */
550                        if (strptime(v->u.string.ptr, TWITTER_TIME_FORMAT, &parsed) != NULL) {
551                                txs->created_at = mktime_utc(&parsed);
552                        }
553                } else if (strcmp("sender", k) == 0 && v->type == json_object) {
554                        txs->user = twitter_xt_get_user(v);
555                } else if (strcmp("id", k) == 0 && v->type == json_integer) {
556                        txs->id = v->u.integer;
557                }
558        }
559
560        expand_entities(&txs->text, node);
561
562        if (txs->text && txs->user && txs->id) {
563                return txs;
564        }
565
566        txs_free(txs);
567        return NULL;
568}
569
570static void expand_entities(char **text, const json_value *node)
571{
572        json_value *entities, *quoted;
573        char *quote_url = NULL, *quote_text = NULL;
574
575        if (!((entities = json_o_get(node, "entities")) && entities->type == json_object))
576                return;
577        if ((quoted = json_o_get(node, "quoted_status")) && quoted->type == json_object) {
578                /* New "retweets with comments" feature. Note that this info
579                 * seems to be included in the streaming API only! Grab the
580                 * full message and try to insert it when we run into the
581                 * Tweet entity. */
582                struct twitter_xml_status *txs = twitter_xt_get_status(quoted);
583                quote_text = g_strdup_printf("@%s: %s", txs->user->screen_name, txs->text);
584                quote_url = g_strdup_printf("%s/status/%" G_GUINT64_FORMAT, txs->user->screen_name, txs->id);
585                txs_free(txs);
586        } else {
587                quoted = NULL;
588        }
589
590        JSON_O_FOREACH(entities, k, v) {
591                int i;
592
593                if (v->type != json_array) {
594                        continue;
595                }
596                if (strcmp(k, "urls") != 0 && strcmp(k, "media") != 0) {
597                        continue;
598                }
599
600                for (i = 0; i < v->u.array.length; i++) {
601                        const char *format = "%s%s <%s>%s";
602
603                        if (v->u.array.values[i]->type != json_object) {
604                                continue;
605                        }
606
607                        const char *kort = json_o_str(v->u.array.values[i], "url");
608                        const char *disp = json_o_str(v->u.array.values[i], "display_url");
609                        const char *full = json_o_str(v->u.array.values[i], "expanded_url");
610                        char *pos, *new;
611
612                        if (!kort || !disp || !(pos = strstr(*text, kort))) {
613                                continue;
614                        }
615                        if (quote_url && strstr(full, quote_url)) {
616                                format = "%s<%s> [%s]%s";
617                                disp = quote_text;
618                        }
619
620                        *pos = '\0';
621                        new = g_strdup_printf(format, *text, kort,
622                                              disp, pos + strlen(kort));
623
624                        g_free(*text);
625                        *text = new;
626                }
627        }
628        g_free(quote_text);
629        g_free(quote_url);
630}
631
632/**
633 * Function to fill a twitter_xml_list struct.
634 * It sets:
635 *  - all <status>es within the <status> element and
636 *  - the next_cursor.
637 */
638static gboolean twitter_xt_get_status_list(struct im_connection *ic, const json_value *node,
639                                           struct twitter_xml_list *txl)
640{
641        struct twitter_xml_status *txs;
642        int i;
643
644        // Set the type of the list.
645        txl->type = TXL_STATUS;
646
647        if (node->type != json_array) {
648                return FALSE;
649        }
650
651        // The root <statuses> node should hold the list of statuses <status>
652        // Walk over the nodes children.
653        for (i = 0; i < node->u.array.length; i++) {
654                txs = twitter_xt_get_status(node->u.array.values[i]);
655                if (!txs) {
656                        continue;
657                }
658
659                txl->list = g_slist_prepend(txl->list, txs);
660        }
661
662        return TRUE;
663}
664
665/* Will log messages either way. Need to keep track of IDs for stream deduping.
666   Plus, show_ids is on by default and I don't see why anyone would disable it. */
667static char *twitter_msg_add_id(struct im_connection *ic,
668                                struct twitter_xml_status *txs, const char *prefix)
669{
670        struct twitter_data *td = ic->proto_data;
671        int reply_to = -1;
672        bee_user_t *bu;
673
674        if (txs->reply_to) {
675                int i;
676                for (i = 0; i < TWITTER_LOG_LENGTH; i++) {
677                        if (td->log[i].id == txs->reply_to) {
678                                reply_to = i;
679                                break;
680                        }
681                }
682        }
683
684        if (txs->user && txs->user->screen_name &&
685            (bu = bee_user_by_handle(ic->bee, ic, txs->user->screen_name))) {
686                struct twitter_user_data *tud = bu->data;
687
688                if (txs->id > tud->last_id) {
689                        tud->last_id = txs->id;
690                        tud->last_time = txs->created_at;
691                }
692        }
693
694        td->log_id = (td->log_id + 1) % TWITTER_LOG_LENGTH;
695        td->log[td->log_id].id = txs->id;
696        td->log[td->log_id].bu = bee_user_by_handle(ic->bee, ic, txs->user->screen_name);
697
698        /* This is all getting hairy. :-( If we RT'ed something ourselves,
699           remember OUR id instead so undo will work. In other cases, the
700           original tweet's id should be remembered for deduplicating. */
701        if (g_strcasecmp(txs->user->screen_name, td->user) == 0) {
702                td->log[td->log_id].id = txs->rt_id;
703                /* More useful than NULL. */
704                td->log[td->log_id].bu = &twitter_log_local_user;
705        }
706
707        if (set_getbool(&ic->acc->set, "show_ids")) {
708                if (reply_to != -1) {
709                        return g_strdup_printf("\002[\002%02x->%02x\002]\002 %s%s",
710                                               td->log_id, reply_to, prefix, txs->text);
711                } else {
712                        return g_strdup_printf("\002[\002%02x\002]\002 %s%s",
713                                               td->log_id, prefix, txs->text);
714                }
715        } else {
716                if (*prefix) {
717                        return g_strconcat(prefix, txs->text, NULL);
718                } else {
719                        return NULL;
720                }
721        }
722}
723
724/**
725 * Function that is called to see the filter statuses in groupchat windows.
726 */
727static void twitter_status_show_filter(struct im_connection *ic, struct twitter_xml_status *status)
728{
729        struct twitter_data *td = ic->proto_data;
730        char *msg = twitter_msg_add_id(ic, status, "");
731        struct twitter_filter *tf;
732        GSList *f;
733        GSList *l;
734
735        for (f = td->filters; f; f = g_slist_next(f)) {
736                tf = f->data;
737
738                switch (tf->type) {
739                case TWITTER_FILTER_TYPE_FOLLOW:
740                        if (status->user->uid != tf->uid) {
741                                continue;
742                        }
743                        break;
744
745                case TWITTER_FILTER_TYPE_TRACK:
746                        if (strcasestr(status->text, tf->text) == NULL) {
747                                continue;
748                        }
749                        break;
750
751                default:
752                        continue;
753                }
754
755                for (l = tf->groupchats; l; l = g_slist_next(l)) {
756                        imcb_chat_msg(l->data, status->user->screen_name,
757                                      msg ? msg : status->text, 0, 0);
758                }
759        }
760
761        g_free(msg);
762}
763
764/**
765 * Function that is called to see the statuses in a groupchat window.
766 */
767static void twitter_status_show_chat(struct im_connection *ic, struct twitter_xml_status *status)
768{
769        struct twitter_data *td = ic->proto_data;
770        struct groupchat *gc;
771        gboolean me = g_strcasecmp(td->user, status->user->screen_name) == 0;
772        char *msg;
773
774        // Create a new groupchat if it does not exsist.
775        gc = twitter_groupchat_init(ic);
776
777        if (!me) {
778                /* MUST be done before twitter_msg_add_id() to avoid #872. */
779                twitter_add_buddy(ic, status->user->screen_name, status->user->name);
780        }
781        msg = twitter_msg_add_id(ic, status, "");
782
783        // Say it!
784        if (me) {
785                imcb_chat_log(gc, "You: %s", msg ? msg : status->text);
786        } else {
787                imcb_chat_msg(gc, status->user->screen_name,
788                              msg ? msg : status->text, 0, status->created_at);
789        }
790
791        g_free(msg);
792}
793
794/**
795 * Function that is called to see statuses as private messages.
796 */
797static void twitter_status_show_msg(struct im_connection *ic, struct twitter_xml_status *status)
798{
799        struct twitter_data *td = ic->proto_data;
800        char from[MAX_STRING] = "";
801        char *prefix = NULL, *text = NULL;
802        gboolean me = g_strcasecmp(td->user, status->user->screen_name) == 0;
803
804        if (td->flags & TWITTER_MODE_ONE) {
805                g_snprintf(from, sizeof(from) - 1, "%s_%s", td->prefix, ic->acc->user);
806                from[MAX_STRING - 1] = '\0';
807        }
808
809        if (td->flags & TWITTER_MODE_ONE) {
810                prefix = g_strdup_printf("\002<\002%s\002>\002 ",
811                                         status->user->screen_name);
812        } else if (!me) {
813                twitter_add_buddy(ic, status->user->screen_name, status->user->name);
814        } else {
815                prefix = g_strdup("You: ");
816        }
817
818        text = twitter_msg_add_id(ic, status, prefix ? prefix : "");
819
820        imcb_buddy_msg(ic,
821                       *from ? from : status->user->screen_name,
822                       text ? text : status->text, 0, status->created_at);
823
824        g_free(text);
825        g_free(prefix);
826}
827
828static void twitter_status_show(struct im_connection *ic, struct twitter_xml_status *status)
829{
830        struct twitter_data *td = ic->proto_data;
831        char *last_id_str;
832
833        if (status->user == NULL || status->text == NULL) {
834                return;
835        }
836
837        /* Grrrr. Would like to do this during parsing, but can't access
838           settings from there. */
839        if (set_getbool(&ic->acc->set, "strip_newlines")) {
840                strip_newlines(status->text);
841        }
842
843        if (status->from_filter) {
844                twitter_status_show_filter(ic, status);
845        } else if (td->flags & TWITTER_MODE_CHAT) {
846                twitter_status_show_chat(ic, status);
847        } else {
848                twitter_status_show_msg(ic, status);
849        }
850
851        // Update the timeline_id to hold the highest id, so that by the next request
852        // we won't pick up the updates already in the list.
853        td->timeline_id = MAX(td->timeline_id, status->rt_id);
854
855        last_id_str = g_strdup_printf("%" G_GUINT64_FORMAT, td->timeline_id);
856        set_setstr(&ic->acc->set, "_last_tweet", last_id_str);
857        g_free(last_id_str);
858}
859
860static gboolean twitter_stream_handle_object(struct im_connection *ic, json_value *o, gboolean from_filter);
861
862static void twitter_http_stream(struct http_request *req)
863{
864        struct im_connection *ic = req->data;
865        struct twitter_data *td;
866        json_value *parsed;
867        int len = 0;
868        char c, *nl;
869        gboolean from_filter;
870
871        if (!g_slist_find(twitter_connections, ic)) {
872                return;
873        }
874
875        ic->flags |= OPT_PONGED;
876        td = ic->proto_data;
877
878        if ((req->flags & HTTPC_EOF) || !req->reply_body) {
879                if (req == td->stream) {
880                        td->stream = NULL;
881                } else if (req == td->filter_stream) {
882                        td->filter_stream = NULL;
883                }
884
885                imcb_error(ic, "Stream closed (%s)", req->status_string);
886                if (req->status_code == 401) {
887                        imcb_error(ic, "Check your system clock.");
888                }
889                imc_logout(ic, TRUE);
890                return;
891        }
892
893        /* MUST search for CRLF, not just LF:
894           https://dev.twitter.com/docs/streaming-apis/processing#Parsing_responses */
895        if (!(nl = strstr(req->reply_body, "\r\n"))) {
896                return;
897        }
898
899        len = nl - req->reply_body;
900        if (len > 0) {
901                c = req->reply_body[len];
902                req->reply_body[len] = '\0';
903
904                if ((parsed = json_parse(req->reply_body, req->body_size))) {
905                        from_filter = (req == td->filter_stream);
906                        twitter_stream_handle_object(ic, parsed, from_filter);
907                }
908                json_value_free(parsed);
909                req->reply_body[len] = c;
910        }
911
912        http_flush_bytes(req, len + 2);
913
914        /* One notification might bring multiple events! */
915        if (req->body_size > 0) {
916                twitter_http_stream(req);
917        }
918}
919
920static gboolean twitter_stream_handle_event(struct im_connection *ic, json_value *o);
921static gboolean twitter_stream_handle_status(struct im_connection *ic, struct twitter_xml_status *txs);
922
923static gboolean twitter_stream_handle_object(struct im_connection *ic, json_value *o, gboolean from_filter)
924{
925        struct twitter_data *td = ic->proto_data;
926        struct twitter_xml_status *txs;
927        json_value *c;
928
929        if ((txs = twitter_xt_get_status(o))) {
930                txs->from_filter = from_filter;
931                gboolean ret = twitter_stream_handle_status(ic, txs);
932                txs_free(txs);
933                return ret;
934        } else if ((c = json_o_get(o, "direct_message")) &&
935                   (txs = twitter_xt_get_dm(c))) {
936                if (g_strcasecmp(txs->user->screen_name, td->user) != 0) {
937                        imcb_buddy_msg(ic, txs->user->screen_name,
938                                       txs->text, 0, txs->created_at);
939                }
940                txs_free(txs);
941                return TRUE;
942        } else if ((c = json_o_get(o, "event")) && c->type == json_string) {
943                twitter_stream_handle_event(ic, o);
944                return TRUE;
945        } else if ((c = json_o_get(o, "disconnect")) && c->type == json_object) {
946                /* HACK: Because we're inside an event handler, we can't just
947                   disconnect here. Instead, just change the HTTP status string
948                   into a Twitter status string. */
949                char *reason = json_o_strdup(c, "reason");
950                if (reason) {
951                        g_free(td->stream->status_string);
952                        td->stream->status_string = reason;
953                }
954                return TRUE;
955        }
956        return FALSE;
957}
958
959static gboolean twitter_stream_handle_status(struct im_connection *ic, struct twitter_xml_status *txs)
960{
961        struct twitter_data *td = ic->proto_data;
962        int i;
963
964        for (i = 0; i < TWITTER_LOG_LENGTH; i++) {
965                if (td->log[i].id == txs->id) {
966                        /* Got a duplicate (RT, probably). Drop it. */
967                        return TRUE;
968                }
969        }
970
971        if (!(g_strcasecmp(txs->user->screen_name, td->user) == 0 ||
972              set_getbool(&ic->acc->set, "fetch_mentions") ||
973              bee_user_by_handle(ic->bee, ic, txs->user->screen_name))) {
974                /* Tweet is from an unknown person and the user does not want
975                   to see @mentions, so drop it. twitter_stream_handle_event()
976                   picks up new follows so this simple filter should be safe. */
977                /* TODO: The streaming API seems to do poor @mention matching.
978                   I.e. I'm getting mentions for @WilmerSomething, not just for
979                   @Wilmer. But meh. You want spam, you get spam. */
980                return TRUE;
981        }
982
983        twitter_status_show(ic, txs);
984
985        return TRUE;
986}
987
988static gboolean twitter_stream_handle_event(struct im_connection *ic, json_value *o)
989{
990        struct twitter_data *td = ic->proto_data;
991        json_value *source = json_o_get(o, "source");
992        json_value *target = json_o_get(o, "target");
993        const char *type = json_o_str(o, "event");
994
995        if (!type || !source || source->type != json_object
996            || !target || target->type != json_object) {
997                return FALSE;
998        }
999
1000        if (strcmp(type, "follow") == 0) {
1001                struct twitter_xml_user *us = twitter_xt_get_user(source);
1002                struct twitter_xml_user *ut = twitter_xt_get_user(target);
1003                if (g_strcasecmp(us->screen_name, td->user) == 0) {
1004                        twitter_add_buddy(ic, ut->screen_name, ut->name);
1005                }
1006                txu_free(us);
1007                txu_free(ut);
1008        }
1009
1010        return TRUE;
1011}
1012
1013gboolean twitter_open_stream(struct im_connection *ic)
1014{
1015        struct twitter_data *td = ic->proto_data;
1016        char *args[2] = { "with", "followings" };
1017
1018        if ((td->stream = twitter_http(ic, TWITTER_USER_STREAM_URL,
1019                                       twitter_http_stream, ic, 0, args, 2))) {
1020                /* This flag must be enabled or we'll get no data until EOF
1021                   (which err, kind of, defeats the purpose of a streaming API). */
1022                td->stream->flags |= HTTPC_STREAMING;
1023                return TRUE;
1024        }
1025
1026        return FALSE;
1027}
1028
1029static gboolean twitter_filter_stream(struct im_connection *ic)
1030{
1031        struct twitter_data *td = ic->proto_data;
1032        char *args[4] = { "follow", NULL, "track", NULL };
1033        GString *followstr = g_string_new("");
1034        GString *trackstr = g_string_new("");
1035        gboolean ret = FALSE;
1036        struct twitter_filter *tf;
1037        GSList *l;
1038
1039        for (l = td->filters; l; l = g_slist_next(l)) {
1040                tf = l->data;
1041
1042                switch (tf->type) {
1043                case TWITTER_FILTER_TYPE_FOLLOW:
1044                        if (followstr->len > 0) {
1045                                g_string_append_c(followstr, ',');
1046                        }
1047
1048                        g_string_append_printf(followstr, "%" G_GUINT64_FORMAT,
1049                                               tf->uid);
1050                        break;
1051
1052                case TWITTER_FILTER_TYPE_TRACK:
1053                        if (trackstr->len > 0) {
1054                                g_string_append_c(trackstr, ',');
1055                        }
1056
1057                        g_string_append(trackstr, tf->text);
1058                        break;
1059
1060                default:
1061                        continue;
1062                }
1063        }
1064
1065        args[1] = followstr->str;
1066        args[3] = trackstr->str;
1067
1068        if (td->filter_stream) {
1069                http_close(td->filter_stream);
1070        }
1071
1072        if ((td->filter_stream = twitter_http(ic, TWITTER_FILTER_STREAM_URL,
1073                                              twitter_http_stream, ic, 0,
1074                                              args, 4))) {
1075                /* This flag must be enabled or we'll get no data until EOF
1076                   (which err, kind of, defeats the purpose of a streaming API). */
1077                td->filter_stream->flags |= HTTPC_STREAMING;
1078                ret = TRUE;
1079        }
1080
1081        g_string_free(followstr, TRUE);
1082        g_string_free(trackstr, TRUE);
1083
1084        return ret;
1085}
1086
1087static void twitter_filter_users_post(struct http_request *req)
1088{
1089        struct im_connection *ic = req->data;
1090        struct twitter_data *td;
1091        struct twitter_filter *tf;
1092        GList *users = NULL;
1093        json_value *parsed;
1094        json_value *id;
1095        const char *name;
1096        GString *fstr;
1097        GSList *l;
1098        GList *u;
1099        int i;
1100
1101        // Check if the connection is still active.
1102        if (!g_slist_find(twitter_connections, ic)) {
1103                return;
1104        }
1105
1106        td = ic->proto_data;
1107
1108        if (!(parsed = twitter_parse_response(ic, req))) {
1109                return;
1110        }
1111
1112        for (l = td->filters; l; l = g_slist_next(l)) {
1113                tf = l->data;
1114
1115                if (tf->type == TWITTER_FILTER_TYPE_FOLLOW) {
1116                        users = g_list_prepend(users, tf);
1117                }
1118        }
1119
1120        if (parsed->type != json_array) {
1121                goto finish;
1122        }
1123
1124        for (i = 0; i < parsed->u.array.length; i++) {
1125                id = json_o_get(parsed->u.array.values[i], "id");
1126                name = json_o_str(parsed->u.array.values[i], "screen_name");
1127
1128                if (!name || !id || id->type != json_integer) {
1129                        continue;
1130                }
1131
1132                for (u = users; u; u = g_list_next(u)) {
1133                        tf = u->data;
1134
1135                        if (g_strcasecmp(tf->text, name) == 0) {
1136                                tf->uid = id->u.integer;
1137                                users = g_list_delete_link(users, u);
1138                                break;
1139                        }
1140                }
1141        }
1142
1143finish:
1144        json_value_free(parsed);
1145        twitter_filter_stream(ic);
1146
1147        if (!users) {
1148                return;
1149        }
1150
1151        fstr = g_string_new("");
1152
1153        for (u = users; u; u = g_list_next(u)) {
1154                if (fstr->len > 0) {
1155                        g_string_append(fstr, ", ");
1156                }
1157
1158                g_string_append(fstr, tf->text);
1159        }
1160
1161        imcb_error(ic, "Failed UID acquisitions: %s", fstr->str);
1162
1163        g_string_free(fstr, TRUE);
1164        g_list_free(users);
1165}
1166
1167gboolean twitter_open_filter_stream(struct im_connection *ic)
1168{
1169        struct twitter_data *td = ic->proto_data;
1170        char *args[2] = { "screen_name", NULL };
1171        GString *ustr = g_string_new("");
1172        struct twitter_filter *tf;
1173        struct http_request *req;
1174        GSList *l;
1175
1176        for (l = td->filters; l; l = g_slist_next(l)) {
1177                tf = l->data;
1178
1179                if (tf->type != TWITTER_FILTER_TYPE_FOLLOW || tf->uid != 0) {
1180                        continue;
1181                }
1182
1183                if (ustr->len > 0) {
1184                        g_string_append_c(ustr, ',');
1185                }
1186
1187                g_string_append(ustr, tf->text);
1188        }
1189
1190        if (ustr->len == 0) {
1191                g_string_free(ustr, TRUE);
1192                return twitter_filter_stream(ic);
1193        }
1194
1195        args[1] = ustr->str;
1196        req = twitter_http(ic, TWITTER_USERS_LOOKUP_URL,
1197                           twitter_filter_users_post,
1198                           ic, 0, args, 2);
1199
1200        g_string_free(ustr, TRUE);
1201        return req != NULL;
1202}
1203
1204static void twitter_get_home_timeline(struct im_connection *ic, gint64 next_cursor);
1205static void twitter_get_mentions(struct im_connection *ic, gint64 next_cursor);
1206
1207/**
1208 * Get the timeline with optionally mentions
1209 */
1210gboolean twitter_get_timeline(struct im_connection *ic, gint64 next_cursor)
1211{
1212        struct twitter_data *td = ic->proto_data;
1213        gboolean include_mentions = set_getbool(&ic->acc->set, "fetch_mentions");
1214
1215        if (td->flags & TWITTER_DOING_TIMELINE) {
1216                if (++td->http_fails >= 5) {
1217                        imcb_error(ic, "Fetch timeout (%d)", td->flags);
1218                        imc_logout(ic, TRUE);
1219                        return FALSE;
1220                }
1221        }
1222
1223        td->flags |= TWITTER_DOING_TIMELINE;
1224
1225        twitter_get_home_timeline(ic, next_cursor);
1226
1227        if (include_mentions) {
1228                twitter_get_mentions(ic, next_cursor);
1229        }
1230
1231        return TRUE;
1232}
1233
1234/**
1235 * Call this one after receiving timeline/mentions. Show to user once we have
1236 * both.
1237 */
1238void twitter_flush_timeline(struct im_connection *ic)
1239{
1240        struct twitter_data *td = ic->proto_data;
1241        gboolean include_mentions = set_getbool(&ic->acc->set, "fetch_mentions");
1242        int show_old_mentions = set_getint(&ic->acc->set, "show_old_mentions");
1243        struct twitter_xml_list *home_timeline = td->home_timeline_obj;
1244        struct twitter_xml_list *mentions = td->mentions_obj;
1245        guint64 last_id = 0;
1246        GSList *output = NULL;
1247        GSList *l;
1248
1249        imcb_connected(ic);
1250
1251        if (!(td->flags & TWITTER_GOT_TIMELINE)) {
1252                return;
1253        }
1254
1255        if (include_mentions && !(td->flags & TWITTER_GOT_MENTIONS)) {
1256                return;
1257        }
1258
1259        if (home_timeline && home_timeline->list) {
1260                for (l = home_timeline->list; l; l = g_slist_next(l)) {
1261                        output = g_slist_insert_sorted(output, l->data, twitter_compare_elements);
1262                }
1263        }
1264
1265        if (include_mentions && mentions && mentions->list) {
1266                for (l = mentions->list; l; l = g_slist_next(l)) {
1267                        if (show_old_mentions < 1 && output && twitter_compare_elements(l->data, output->data) < 0) {
1268                                continue;
1269                        }
1270
1271                        output = g_slist_insert_sorted(output, l->data, twitter_compare_elements);
1272                }
1273        }
1274
1275        // See if the user wants to see the messages in a groupchat window or as private messages.
1276        while (output) {
1277                struct twitter_xml_status *txs = output->data;
1278                if (txs->id != last_id) {
1279                        twitter_status_show(ic, txs);
1280                }
1281                last_id = txs->id;
1282                output = g_slist_remove(output, txs);
1283        }
1284
1285        txl_free(home_timeline);
1286        txl_free(mentions);
1287
1288        td->flags &= ~(TWITTER_DOING_TIMELINE | TWITTER_GOT_TIMELINE | TWITTER_GOT_MENTIONS);
1289        td->home_timeline_obj = td->mentions_obj = NULL;
1290}
1291
1292static void twitter_http_get_home_timeline(struct http_request *req);
1293static void twitter_http_get_mentions(struct http_request *req);
1294
1295/**
1296 * Get the timeline.
1297 */
1298static void twitter_get_home_timeline(struct im_connection *ic, gint64 next_cursor)
1299{
1300        struct twitter_data *td = ic->proto_data;
1301
1302        txl_free(td->home_timeline_obj);
1303        td->home_timeline_obj = NULL;
1304        td->flags &= ~TWITTER_GOT_TIMELINE;
1305
1306        char *args[6];
1307        args[0] = "cursor";
1308        args[1] = g_strdup_printf("%" G_GINT64_FORMAT, next_cursor);
1309        args[2] = "include_entities";
1310        args[3] = "true";
1311        if (td->timeline_id) {
1312                args[4] = "since_id";
1313                args[5] = g_strdup_printf("%" G_GUINT64_FORMAT, td->timeline_id);
1314        }
1315
1316        if (twitter_http(ic, TWITTER_HOME_TIMELINE_URL, twitter_http_get_home_timeline, ic, 0, args,
1317                         td->timeline_id ? 6 : 4) == NULL) {
1318                if (++td->http_fails >= 5) {
1319                        imcb_error(ic, "Could not retrieve %s: %s",
1320                                   TWITTER_HOME_TIMELINE_URL, "connection failed");
1321                }
1322                td->flags |= TWITTER_GOT_TIMELINE;
1323                twitter_flush_timeline(ic);
1324        }
1325
1326        g_free(args[1]);
1327        if (td->timeline_id) {
1328                g_free(args[5]);
1329        }
1330}
1331
1332/**
1333 * Get mentions.
1334 */
1335static void twitter_get_mentions(struct im_connection *ic, gint64 next_cursor)
1336{
1337        struct twitter_data *td = ic->proto_data;
1338
1339        txl_free(td->mentions_obj);
1340        td->mentions_obj = NULL;
1341        td->flags &= ~TWITTER_GOT_MENTIONS;
1342
1343        char *args[6];
1344        args[0] = "cursor";
1345        args[1] = g_strdup_printf("%" G_GINT64_FORMAT, next_cursor);
1346        args[2] = "include_entities";
1347        args[3] = "true";
1348        if (td->timeline_id) {
1349                args[4] = "since_id";
1350                args[5] = g_strdup_printf("%" G_GUINT64_FORMAT, td->timeline_id);
1351        } else {
1352                args[4] = "count";
1353                args[5] = g_strdup_printf("%d", set_getint(&ic->acc->set, "show_old_mentions"));
1354        }
1355
1356        if (twitter_http(ic, TWITTER_MENTIONS_URL, twitter_http_get_mentions,
1357                         ic, 0, args, 6) == NULL) {
1358                if (++td->http_fails >= 5) {
1359                        imcb_error(ic, "Could not retrieve %s: %s",
1360                                   TWITTER_MENTIONS_URL, "connection failed");
1361                }
1362                td->flags |= TWITTER_GOT_MENTIONS;
1363                twitter_flush_timeline(ic);
1364        }
1365
1366        g_free(args[1]);
1367        g_free(args[5]);
1368}
1369
1370/**
1371 * Callback for getting the home timeline.
1372 */
1373static void twitter_http_get_home_timeline(struct http_request *req)
1374{
1375        struct im_connection *ic = req->data;
1376        struct twitter_data *td;
1377        json_value *parsed;
1378        struct twitter_xml_list *txl;
1379
1380        // Check if the connection is still active.
1381        if (!g_slist_find(twitter_connections, ic)) {
1382                return;
1383        }
1384
1385        td = ic->proto_data;
1386
1387        txl = g_new0(struct twitter_xml_list, 1);
1388        txl->list = NULL;
1389
1390        // The root <statuses> node should hold the list of statuses <status>
1391        if (!(parsed = twitter_parse_response(ic, req))) {
1392                goto end;
1393        }
1394        twitter_xt_get_status_list(ic, parsed, txl);
1395        json_value_free(parsed);
1396
1397        td->home_timeline_obj = txl;
1398
1399end:
1400        if (!g_slist_find(twitter_connections, ic)) {
1401                return;
1402        }
1403
1404        td->flags |= TWITTER_GOT_TIMELINE;
1405
1406        twitter_flush_timeline(ic);
1407}
1408
1409/**
1410 * Callback for getting mentions.
1411 */
1412static void twitter_http_get_mentions(struct http_request *req)
1413{
1414        struct im_connection *ic = req->data;
1415        struct twitter_data *td;
1416        json_value *parsed;
1417        struct twitter_xml_list *txl;
1418
1419        // Check if the connection is still active.
1420        if (!g_slist_find(twitter_connections, ic)) {
1421                return;
1422        }
1423
1424        td = ic->proto_data;
1425
1426        txl = g_new0(struct twitter_xml_list, 1);
1427        txl->list = NULL;
1428
1429        // The root <statuses> node should hold the list of statuses <status>
1430        if (!(parsed = twitter_parse_response(ic, req))) {
1431                goto end;
1432        }
1433        twitter_xt_get_status_list(ic, parsed, txl);
1434        json_value_free(parsed);
1435
1436        td->mentions_obj = txl;
1437
1438end:
1439        if (!g_slist_find(twitter_connections, ic)) {
1440                return;
1441        }
1442
1443        td->flags |= TWITTER_GOT_MENTIONS;
1444
1445        twitter_flush_timeline(ic);
1446}
1447
1448/**
1449 * Callback to use after sending a POST request to twitter.
1450 * (Generic, used for a few kinds of queries.)
1451 */
1452static void twitter_http_post(struct http_request *req)
1453{
1454        struct im_connection *ic = req->data;
1455        struct twitter_data *td;
1456        json_value *parsed, *id;
1457
1458        // Check if the connection is still active.
1459        if (!g_slist_find(twitter_connections, ic)) {
1460                return;
1461        }
1462
1463        td = ic->proto_data;
1464        td->last_status_id = 0;
1465
1466        if (!(parsed = twitter_parse_response(ic, req))) {
1467                return;
1468        }
1469
1470        if ((id = json_o_get(parsed, "id")) && id->type == json_integer) {
1471                td->last_status_id = id->u.integer;
1472        }
1473
1474        json_value_free(parsed);
1475
1476        if (req->flags & TWITTER_HTTP_USER_ACK) {
1477                twitter_log(ic, "Command processed successfully");
1478        }
1479}
1480
1481/**
1482 * Function to POST a new status to twitter.
1483 */
1484void twitter_post_status(struct im_connection *ic, char *msg, guint64 in_reply_to)
1485{
1486        char *args[4] = {
1487                "status", msg,
1488                "in_reply_to_status_id",
1489                g_strdup_printf("%" G_GUINT64_FORMAT, in_reply_to)
1490        };
1491
1492        twitter_http(ic, TWITTER_STATUS_UPDATE_URL, twitter_http_post, ic, 1,
1493                     args, in_reply_to ? 4 : 2);
1494        g_free(args[3]);
1495}
1496
1497
1498/**
1499 * Function to POST a new message to twitter.
1500 */
1501void twitter_direct_messages_new(struct im_connection *ic, char *who, char *msg)
1502{
1503        char *args[4];
1504
1505        args[0] = "screen_name";
1506        args[1] = who;
1507        args[2] = "text";
1508        args[3] = msg;
1509        // Use the same callback as for twitter_post_status, since it does basically the same.
1510        twitter_http(ic, TWITTER_DIRECT_MESSAGES_NEW_URL, twitter_http_post, ic, 1, args, 4);
1511}
1512
1513void twitter_friendships_create_destroy(struct im_connection *ic, char *who, int create)
1514{
1515        char *args[2];
1516
1517        args[0] = "screen_name";
1518        args[1] = who;
1519        twitter_http(ic, create ? TWITTER_FRIENDSHIPS_CREATE_URL : TWITTER_FRIENDSHIPS_DESTROY_URL,
1520                     twitter_http_post, ic, 1, args, 2);
1521}
1522
1523void twitter_status_destroy(struct im_connection *ic, guint64 id)
1524{
1525        char *url;
1526
1527        url = g_strdup_printf("%s%" G_GUINT64_FORMAT "%s",
1528                              TWITTER_STATUS_DESTROY_URL, id, ".json");
1529        twitter_http_f(ic, url, twitter_http_post, ic, 1, NULL, 0,
1530                       TWITTER_HTTP_USER_ACK);
1531        g_free(url);
1532}
1533
1534void twitter_status_retweet(struct im_connection *ic, guint64 id)
1535{
1536        char *url;
1537
1538        url = g_strdup_printf("%s%" G_GUINT64_FORMAT "%s",
1539                              TWITTER_STATUS_RETWEET_URL, id, ".json");
1540        twitter_http_f(ic, url, twitter_http_post, ic, 1, NULL, 0,
1541                       TWITTER_HTTP_USER_ACK);
1542        g_free(url);
1543}
1544
1545/**
1546 * Report a user for sending spam.
1547 */
1548void twitter_report_spam(struct im_connection *ic, char *screen_name)
1549{
1550        char *args[2] = {
1551                "screen_name",
1552                NULL,
1553        };
1554
1555        args[1] = screen_name;
1556        twitter_http_f(ic, TWITTER_REPORT_SPAM_URL, twitter_http_post,
1557                       ic, 1, args, 2, TWITTER_HTTP_USER_ACK);
1558}
1559
1560/**
1561 * Favourite a tweet.
1562 */
1563void twitter_favourite_tweet(struct im_connection *ic, guint64 id)
1564{
1565        char *args[2] = {
1566                "id",
1567                NULL,
1568        };
1569
1570        args[1] = g_strdup_printf("%" G_GUINT64_FORMAT, id);
1571        twitter_http_f(ic, TWITTER_FAVORITE_CREATE_URL, twitter_http_post,
1572                       ic, 1, args, 2, TWITTER_HTTP_USER_ACK);
1573        g_free(args[1]);
1574}
Note: See TracBrowser for help on using the repository browser.