source: protocols/twitter/twitter_lib.c @ 6f10697

Last change on this file since 6f10697 was 9f8bb17, checked in by dequis <dx@…>, at 2014-11-24T05:16:11Z

twitter: Use g_strcasecmp for screen_name

Fixes a few minor bugs with users who have uppercase characters in nicks
(see trac ticket 1138). Most notably, the "follow" command showing no
feedback that a user was followed

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