Context Navigation

source: protocols/twitter/twitter.c @ 9754c2f

Last change on this file since 9754c2f was 9754c2f, checked in by Miklos Vajna <vmiklos@…>, at 2013-02-18T08:42:30Z
Clean up set_my_name API implementations
Property mode set to `100644`
File size: 21.1 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-2012 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	#include "nogaim.h"
26	#include "oauth.h"
27	#include "twitter.h"
28	#include "twitter_http.h"
29	#include "twitter_lib.h"
30	#include "url.h"
31
32	GSList *twitter_connections = NULL;
33	/**
34	* Main loop function
35	*/
36	gboolean twitter_main_loop(gpointer data, gint fd, b_input_condition cond)
37	{
38	struct im_connection *ic = data;
39
40	// Check if we are still logged in...
41	if (!g_slist_find(twitter_connections, ic))
42	return 0;
43
44	// Do stuff..
45	twitter_get_timeline(ic, -1);
46
47	// If we are still logged in run this function again after timeout.
48	return (ic->flags & OPT_LOGGED_IN) == OPT_LOGGED_IN;
49	}
50
51	static void twitter_main_loop_start(struct im_connection *ic)
52	{
53	struct twitter_data *td = ic->proto_data;
54
55	/* Create the room now that we "logged in". */
56	if (td->flags & TWITTER_MODE_CHAT)
57	twitter_groupchat_init(ic);
58
59	imcb_log(ic, "Getting initial statuses");
60
61	// Run this once. After this queue the main loop function (or open the
62	// stream if available).
63	twitter_main_loop(ic, -1, 0);
64
65	if (set_getbool(&ic->acc->set, "stream")) {
66	/* That fetch was just to get backlog, the stream will give
67	us the rest. \o/ */
68	twitter_open_stream(ic);
69
70	/* Stream sends keepalives (empty lines) or actual data at
71	least twice a minute. Disconnect if this stops. */
72	ic->flags \|= OPT_PONGS;
73	} else {
74	/* Not using the streaming API, so keep polling the old-
75	fashioned way. :-( */
76	td->main_loop_id =
77	b_timeout_add(set_getint(&ic->acc->set, "fetch_interval") * 1000,
78	twitter_main_loop, ic);
79	}
80	}
81
82	struct groupchat twitter_groupchat_init(struct im_connection ic)
83	{
84	char *name_hint;
85	struct groupchat *gc;
86	struct twitter_data *td = ic->proto_data;
87	GSList *l;
88
89	if (td->timeline_gc)
90	return td->timeline_gc;
91
92	td->timeline_gc = gc = imcb_chat_new(ic, "twitter/timeline");
93
94	name_hint = g_strdup_printf("%s_%s", td->prefix, ic->acc->user);
95	imcb_chat_name_hint(gc, name_hint);
96	g_free(name_hint);
97
98	for (l = ic->bee->users; l; l = l->next) {
99	bee_user_t *bu = l->data;
100	if (bu->ic == ic)
101	imcb_chat_add_buddy(gc, bu->handle);
102	}
103	imcb_chat_add_buddy(gc, ic->acc->user);
104
105	return gc;
106	}
107
108	static void twitter_oauth_start(struct im_connection *ic);
109
110	void twitter_login_finish(struct im_connection *ic)
111	{
112	struct twitter_data *td = ic->proto_data;
113
114	td->flags &= ~TWITTER_DOING_TIMELINE;
115
116	if (set_getbool(&ic->acc->set, "oauth") && !td->oauth_info)
117	twitter_oauth_start(ic);
118	else if (!(td->flags & TWITTER_MODE_ONE) &&
119	!(td->flags & TWITTER_HAVE_FRIENDS)) {
120	imcb_log(ic, "Getting contact list");
121	twitter_get_friends_ids(ic, -1);
122	} else
123	twitter_main_loop_start(ic);
124	}
125
126	static const struct oauth_service twitter_oauth = {
127	"https://api.twitter.com/oauth/request_token",
128	"https://api.twitter.com/oauth/access_token",
129	"https://api.twitter.com/oauth/authorize",
130	.consumer_key = "xsDNKJuNZYkZyMcu914uEA",
131	.consumer_secret = "FCxqcr0pXKzsF9ajmP57S3VQ8V6Drk4o2QYtqMcOszo",
132	};
133
134	static const struct oauth_service identica_oauth = {
135	"https://identi.ca/api/oauth/request_token",
136	"https://identi.ca/api/oauth/access_token",
137	"https://identi.ca/api/oauth/authorize",
138	.consumer_key = "e147ff789fcbd8a5a07963afbb43f9da",
139	.consumer_secret = "c596267f277457ec0ce1ab7bb788d828",
140	};
141
142	static gboolean twitter_oauth_callback(struct oauth_info *info);
143
144	static const struct oauth_service get_oauth_service(struct im_connection ic)
145	{
146	struct twitter_data *td = ic->proto_data;
147
148	if (strstr(td->url_host, "identi.ca"))
149	return &identica_oauth;
150	else
151	return &twitter_oauth;
152
153	/* Could add more services, or allow configuring your own base URL +
154	API keys. */
155	}
156
157	static void twitter_oauth_start(struct im_connection *ic)
158	{
159	struct twitter_data *td = ic->proto_data;
160
161	imcb_log(ic, "Requesting OAuth request token");
162
163	td->oauth_info = oauth_request_token(get_oauth_service(ic), twitter_oauth_callback, ic);
164
165	/* We need help from the user to complete OAuth login, so don't time
166	out on this login. */
167	ic->flags \|= OPT_SLOW_LOGIN;
168	}
169
170	static gboolean twitter_oauth_callback(struct oauth_info *info)
171	{
172	struct im_connection *ic = info->data;
173	struct twitter_data *td;
174
175	if (!g_slist_find(twitter_connections, ic))
176	return FALSE;
177
178	td = ic->proto_data;
179	if (info->stage == OAUTH_REQUEST_TOKEN) {
180	char name[strlen(ic->acc->user) + 9], *msg;
181
182	if (info->request_token == NULL) {
183	imcb_error(ic, "OAuth error: %s", twitter_parse_error(info->http));
184	imc_logout(ic, TRUE);
185	return FALSE;
186	}
187
188	sprintf(name, "%s_%s", td->prefix, ic->acc->user);
189	msg = g_strdup_printf("To finish OAuth authentication, please visit "
190	"%s and respond with the resulting PIN code.",
191	info->auth_url);
192	imcb_buddy_msg(ic, name, msg, 0, 0);
193	g_free(msg);
194	} else if (info->stage == OAUTH_ACCESS_TOKEN) {
195	const char *sn;
196
197	if (info->token == NULL \|\| info->token_secret == NULL) {
198	imcb_error(ic, "OAuth error: %s", twitter_parse_error(info->http));
199	imc_logout(ic, TRUE);
200	return FALSE;
201	}
202
203	if ((sn = oauth_params_get(&info->params, "screen_name"))) {
204	if (ic->acc->prpl->handle_cmp(sn, ic->acc->user) != 0)
205	imcb_log(ic, "Warning: You logged in via OAuth as %s "
206	"instead of %s.", sn, ic->acc->user);
207	g_free(td->user);
208	td->user = g_strdup(sn);
209	}
210
211	/* IM mods didn't do this so far and it's ugly but I should
212	be able to get away with it... */
213	g_free(ic->acc->pass);
214	ic->acc->pass = oauth_to_string(info);
215
216	twitter_login_finish(ic);
217	}
218
219	return TRUE;
220	}
221
222	int twitter_url_len_diff(gchar *msg, unsigned int target_len)
223	{
224	int url_len_diff = 0;
225
226	static GRegex *regex = NULL;
227	GMatchInfo *match_info;
228
229	if (regex == NULL)
230	regex = g_regex_new("(^\|\\s)(http(s)?://[^\\s$]+)", 0, 0, NULL);
231
232	g_regex_match(regex, msg, 0, &match_info);
233	while (g_match_info_matches(match_info)) {
234	gchar *url = g_match_info_fetch(match_info, 2);
235	url_len_diff += target_len - g_utf8_strlen(url, -1);
236	if (g_match_info_fetch(match_info, 3) != NULL)
237	url_len_diff += 1;
238	g_free(url);
239	g_match_info_next(match_info, NULL);
240	}
241	g_match_info_free(match_info);
242
243	return url_len_diff;
244	}
245
246	static gboolean twitter_length_check(struct im_connection ic, gchar msg)
247	{
248	int max = set_getint(&ic->acc->set, "message_length"), len;
249	int target_len = set_getint(&ic->acc->set, "target_url_length");
250	int url_len_diff = 0;
251
252	if (target_len > 0)
253	url_len_diff = twitter_url_len_diff(msg, target_len);
254
255	if (max == 0 \|\| (len = g_utf8_strlen(msg, -1) + url_len_diff) <= max)
256	return TRUE;
257
258	twitter_log(ic, "Maximum message length exceeded: %d > %d", len, max);
259
260	return FALSE;
261	}
262
263	static char set_eval_commands(set_t set, char *value)
264	{
265	if (g_strcasecmp(value, "strict") == 0 )
266	return value;
267	else
268	return set_eval_bool(set, value);
269	}
270
271	static char set_eval_mode(set_t set, char *value)
272	{
273	if (g_strcasecmp(value, "one") == 0 \|\|
274	g_strcasecmp(value, "many") == 0 \|\| g_strcasecmp(value, "chat") == 0)
275	return value;
276	else
277	return NULL;
278	}
279
280	static void twitter_init(account_t * acc)
281	{
282	set_t *s;
283	char *def_url;
284	char *def_tul;
285
286	if (strcmp(acc->prpl->name, "twitter") == 0) {
287	def_url = TWITTER_API_URL;
288	def_tul = "20";
289	} else { /* if( strcmp( acc->prpl->name, "identica" ) == 0 ) */
290	def_url = IDENTICA_API_URL;
291	def_tul = "0";
292	}
293
294	s = set_add(&acc->set, "auto_reply_timeout", "10800", set_eval_int, acc);
295
296	s = set_add(&acc->set, "base_url", def_url, NULL, acc);
297	s->flags \|= ACC_SET_OFFLINE_ONLY;
298
299	s = set_add(&acc->set, "commands", "true", set_eval_commands, acc);
300
301	s = set_add(&acc->set, "fetch_interval", "60", set_eval_int, acc);
302	s->flags \|= ACC_SET_OFFLINE_ONLY;
303
304	s = set_add(&acc->set, "fetch_mentions", "true", set_eval_bool, acc);
305
306	s = set_add(&acc->set, "message_length", "140", set_eval_int, acc);
307
308	s = set_add(&acc->set, "target_url_length", def_tul, set_eval_int, acc);
309
310	s = set_add(&acc->set, "mode", "chat", set_eval_mode, acc);
311	s->flags \|= ACC_SET_OFFLINE_ONLY;
312
313	s = set_add(&acc->set, "oauth", "true", set_eval_oauth, acc);
314
315	s = set_add(&acc->set, "show_ids", "true", set_eval_bool, acc);
316
317	s = set_add(&acc->set, "show_old_mentions", "20", set_eval_int, acc);
318
319	s = set_add(&acc->set, "strip_newlines", "false", set_eval_bool, acc);
320
321	if (strcmp(acc->prpl->name, "twitter") == 0) {
322	s = set_add(&acc->set, "stream", "true", set_eval_bool, acc);
323	s->flags \|= ACC_SET_OFFLINE_ONLY;
324	}
325	}
326
327	/**
328	* Login method. Since the twitter API works with separate HTTP request we
329	* only save the user and pass to the twitter_data object.
330	*/
331	static void twitter_login(account_t * acc)
332	{
333	struct im_connection *ic = imcb_new(acc);
334	struct twitter_data *td;
335	char name[strlen(acc->user) + 9];
336	url_t url;
337	char *s;
338
339	if (!url_set(&url, set_getstr(&ic->acc->set, "base_url")) \|\|
340	(url.proto != PROTO_HTTP && url.proto != PROTO_HTTPS)) {
341	imcb_error(ic, "Incorrect API base URL: %s", set_getstr(&ic->acc->set, "base_url"));
342	imc_logout(ic, FALSE);
343	return;
344	}
345
346	if (!strstr(url.host, "twitter.com") &&
347	set_getbool(&ic->acc->set, "stream")) {
348	imcb_error(ic, "Warning: The streaming API is only supported by Twitter, "
349	"and you seem to be connecting to a different service.");
350	}
351
352	imcb_log(ic, "Connecting");
353
354	twitter_connections = g_slist_append(twitter_connections, ic);
355	td = g_new0(struct twitter_data, 1);
356	ic->proto_data = td;
357	td->user = g_strdup(acc->user);
358
359	td->url_ssl = url.proto == PROTO_HTTPS;
360	td->url_port = url.port;
361	td->url_host = g_strdup(url.host);
362	if (strcmp(url.file, "/") != 0)
363	td->url_path = g_strdup(url.file);
364	else {
365	td->url_path = g_strdup("");
366	if (g_str_has_suffix(url.host, "twitter.com"))
367	/* May fire for people who turned on HTTPS. */
368	imcb_error(ic, "Warning: Twitter requires a version number in API calls "
369	"now. Try resetting the base_url account setting.");
370	}
371
372	/* Hacky string mangling: Turn identi.ca into identi.ca and api.twitter.com
373	into twitter, and try to be sensible if we get anything else. */
374	td->prefix = g_strdup(url.host);
375	if (g_str_has_suffix(td->prefix, ".com"))
376	td->prefix[strlen(url.host) - 4] = '\0';
377	if ((s = strrchr(td->prefix, '.')) && strlen(s) > 4) {
378	/* If we have at least 3 chars after the last dot, cut off the rest.
379	(mostly a www/api prefix or sth) */
380	s = g_strdup(s + 1);
381	g_free(td->prefix);
382	td->prefix = s;
383	}
384
385	if (strstr(acc->pass, "oauth_token="))
386	td->oauth_info = oauth_from_string(acc->pass, get_oauth_service(ic));
387
388	sprintf(name, "%s_%s", td->prefix, acc->user);
389	imcb_add_buddy(ic, name, NULL);
390	imcb_buddy_status(ic, name, OPT_LOGGED_IN, NULL, NULL);
391
392	td->log = g_new0(struct twitter_log_data, TWITTER_LOG_LENGTH);
393	td->log_id = -1;
394
395	s = set_getstr(&ic->acc->set, "mode");
396	if (g_strcasecmp(s, "one") == 0)
397	td->flags \|= TWITTER_MODE_ONE;
398	else if (g_strcasecmp(s, "many") == 0)
399	td->flags \|= TWITTER_MODE_MANY;
400	else
401	td->flags \|= TWITTER_MODE_CHAT;
402
403	twitter_login_finish(ic);
404	}
405
406	/**
407	* Logout method. Just free the twitter_data.
408	*/
409	static void twitter_logout(struct im_connection *ic)
410	{
411	struct twitter_data *td = ic->proto_data;
412
413	// Set the status to logged out.
414	ic->flags &= ~OPT_LOGGED_IN;
415
416	// Remove the main_loop function from the function queue.
417	b_event_remove(td->main_loop_id);
418
419	if (td->timeline_gc)
420	imcb_chat_free(td->timeline_gc);
421
422	if (td) {
423	http_close(td->stream);
424	oauth_info_free(td->oauth_info);
425	g_free(td->user);
426	g_free(td->prefix);
427	g_free(td->url_host);
428	g_free(td->url_path);
429	g_free(td->log);
430	g_free(td);
431	}
432
433	twitter_connections = g_slist_remove(twitter_connections, ic);
434	}
435
436	static void twitter_handle_command(struct im_connection ic, char message);
437
438	/**
439	*
440	*/
441	static int twitter_buddy_msg(struct im_connection ic, char who, char *message, int away)
442	{
443	struct twitter_data *td = ic->proto_data;
444	int plen = strlen(td->prefix);
445
446	if (g_strncasecmp(who, td->prefix, plen) == 0 && who[plen] == '_' &&
447	g_strcasecmp(who + plen + 1, ic->acc->user) == 0) {
448	if (set_getbool(&ic->acc->set, "oauth") &&
449	td->oauth_info && td->oauth_info->token == NULL) {
450	char pin[strlen(message) + 1], *s;
451
452	strcpy(pin, message);
453	for (s = pin + sizeof(pin) - 2; s > pin && isspace(*s); s--)
454	*s = '\0';
455	for (s = pin; s && isspace(s); s++) {
456	}
457
458	if (!oauth_access_token(s, td->oauth_info)) {
459	imcb_error(ic, "OAuth error: %s",
460	"Failed to send access token request");
461	imc_logout(ic, TRUE);
462	return FALSE;
463	}
464	} else
465	twitter_handle_command(ic, message);
466	} else {
467	twitter_direct_messages_new(ic, who, message);
468	}
469	return (0);
470	}
471
472	static void twitter_get_info(struct im_connection ic, char who)
473	{
474	}
475
476	static void twitter_add_buddy(struct im_connection ic, char who, char *group)
477	{
478	twitter_friendships_create_destroy(ic, who, 1);
479	}
480
481	static void twitter_remove_buddy(struct im_connection ic, char who, char *group)
482	{
483	twitter_friendships_create_destroy(ic, who, 0);
484	}
485
486	static void twitter_chat_msg(struct groupchat c, char message, int flags)
487	{
488	if (c && message)
489	twitter_handle_command(c->ic, message);
490	}
491
492	static void twitter_chat_invite(struct groupchat c, char who, char *message)
493	{
494	}
495
496	static void twitter_chat_leave(struct groupchat *c)
497	{
498	struct twitter_data *td = c->ic->proto_data;
499
500	if (c != td->timeline_gc)
501	return; /* WTF? */
502
503	/* If the user leaves the channel: Fine. Rejoin him/her once new
504	tweets come in. */
505	imcb_chat_free(td->timeline_gc);
506	td->timeline_gc = NULL;
507	}
508
509	static void twitter_keepalive(struct im_connection *ic)
510	{
511	}
512
513	static void twitter_add_permit(struct im_connection ic, char who)
514	{
515	}
516
517	static void twitter_rem_permit(struct im_connection ic, char who)
518	{
519	}
520
521	static void twitter_add_deny(struct im_connection ic, char who)
522	{
523	}
524
525	static void twitter_rem_deny(struct im_connection ic, char who)
526	{
527	}
528
529	//static char twitter_set_display_name( set_t set, char *value )
530	//{
531	// return value;
532	//}
533
534	static void twitter_buddy_data_add(struct bee_user *bu)
535	{
536	bu->data = g_new0(struct twitter_user_data, 1);
537	}
538
539	static void twitter_buddy_data_free(struct bee_user *bu)
540	{
541	g_free(bu->data);
542	}
543
544	/** Convert the given bitlbee tweet ID, bitlbee username, or twitter tweet ID
545	* into a twitter tweet ID.
546	*
547	* Returns 0 if the user provides garbage.
548	*/
549	static guint64 twitter_message_id_from_command_arg(struct im_connection ic, char arg, bee_user_t **bu_) {
550	struct twitter_data *td = ic->proto_data;
551	struct twitter_user_data *tud;
552	bee_user_t *bu = NULL;
553	guint64 id = 0;
554
555	if (bu_)
556	*bu_ = NULL;
557	if (!arg \|\| !arg[0])
558	return 0;
559
560	if (arg[0] != '#' && (bu = bee_user_by_handle(ic->bee, ic, arg))) {
561	if ((tud = bu->data))
562	id = tud->last_id;
563	} else {
564	if (arg[0] == '#')
565	arg++;
566	if (sscanf(arg, "%" G_GINT64_MODIFIER "x", &id) == 1 &&
567	id < TWITTER_LOG_LENGTH) {
568	bu = td->log[id].bu;
569	id = td->log[id].id;
570	/* Beware of dangling pointers! */
571	if (!g_slist_find(ic->bee->users, bu))
572	bu = NULL;
573	} else if (sscanf(arg, "%" G_GINT64_MODIFIER "d", &id) == 1) {
574	/* Allow normal tweet IDs as well; not a very useful
575	feature but it's always been there. Just ignore
576	very low IDs to avoid accidents. */
577	if (id < 1000000)
578	id = 0;
579	}
580	}
581	if (bu_)
582	*bu_ = bu;
583	return id;
584	}
585
586	static void twitter_handle_command(struct im_connection ic, char message)
587	{
588	struct twitter_data *td = ic->proto_data;
589	char cmds, cmd, new = NULL;
590	guint64 in_reply_to = 0, id;
591	gboolean allow_post =
592	g_strcasecmp(set_getstr(&ic->acc->set, "commands"), "strict") != 0;
593	bee_user_t *bu = NULL;
594
595	cmds = g_strdup(message);
596	cmd = split_command_parts(cmds);
597
598	if (cmd[0] == NULL) {
599	goto eof;
600	} else if (!set_getbool(&ic->acc->set, "commands") && allow_post) {
601	/* Not supporting commands if "commands" is set to true/strict. */
602	} else if (g_strcasecmp(cmd[0], "undo") == 0) {
603	if (cmd[1] == NULL)
604	twitter_status_destroy(ic, td->last_status_id);
605	else if ((id = twitter_message_id_from_command_arg(ic, cmd[1], NULL)))
606	twitter_status_destroy(ic, id);
607	else
608	twitter_log(ic, "Could not undo last action");
609
610	goto eof;
611	} else if (g_strcasecmp(cmd[0], "favourite") == 0 && cmd[1]) {
612	if ((id = twitter_message_id_from_command_arg(ic, cmd[1], NULL))) {
613	twitter_favourite_tweet(ic, id);
614	} else {
615	twitter_log(ic, "Please provide a message ID or username.");
616	}
617	goto eof;
618	} else if (g_strcasecmp(cmd[0], "follow") == 0 && cmd[1]) {
619	twitter_add_buddy(ic, cmd[1], NULL);
620	goto eof;
621	} else if (g_strcasecmp(cmd[0], "unfollow") == 0 && cmd[1]) {
622	twitter_remove_buddy(ic, cmd[1], NULL);
623	goto eof;
624	} else if ((g_strcasecmp(cmd[0], "report") == 0 \|\|
625	g_strcasecmp(cmd[0], "spam") == 0) && cmd[1]) {
626	char *screen_name;
627
628	/* Report nominally works on users but look up the user who
629	posted the given ID if the user wants to do it that way */
630	twitter_message_id_from_command_arg(ic, cmd[1], &bu);
631	if (bu)
632	screen_name = bu->handle;
633	else
634	screen_name = cmd[1];
635
636	twitter_report_spam(ic, screen_name);
637	goto eof;
638	} else if (g_strcasecmp(cmd[0], "rt") == 0 && cmd[1]) {
639	id = twitter_message_id_from_command_arg(ic, cmd[1], NULL);
640
641	td->last_status_id = 0;
642	if (id)
643	twitter_status_retweet(ic, id);
644	else
645	twitter_log(ic, "User `%s' does not exist or didn't "
646	"post any statuses recently", cmd[1]);
647
648	goto eof;
649	} else if (g_strcasecmp(cmd[0], "reply") == 0 && cmd[1] && cmd[2]) {
650	id = twitter_message_id_from_command_arg(ic, cmd[1], &bu);
651	if (!id \|\| !bu) {
652	twitter_log(ic, "User `%s' does not exist or didn't "
653	"post any statuses recently", cmd[1]);
654	goto eof;
655	}
656	message = new = g_strdup_printf("@%s %s", bu->handle, message + (cmd[2] - cmd[0]));
657	in_reply_to = id;
658	allow_post = TRUE;
659	} else if (g_strcasecmp(cmd[0], "post") == 0) {
660	message += 5;
661	allow_post = TRUE;
662	}
663
664	if (allow_post) {
665	char *s;
666
667	if (!twitter_length_check(ic, message))
668	goto eof;
669
670	s = cmd[0] + strlen(cmd[0]) - 1;
671	if (!new && s > cmd[0] && (s == ':' \|\| s == ',')) {
672	*s = '\0';
673
674	if ((bu = bee_user_by_handle(ic->bee, ic, cmd[0]))) {
675	struct twitter_user_data *tud = bu->data;
676
677	new = g_strdup_printf("@%s %s", bu->handle,
678	message + (s - cmd[0]) + 2);
679	message = new;
680
681	if (time(NULL) < tud->last_time +
682	set_getint(&ic->acc->set, "auto_reply_timeout"))
683	in_reply_to = tud->last_id;
684	}
685	}
686
687	/* If the user runs undo between this request and its response
688	this would delete the second-last Tweet. Prevent that. */
689	td->last_status_id = 0;
690	twitter_post_status(ic, message, in_reply_to);
691	} else {
692	twitter_log(ic, "Unknown command: %s", cmd[0]);
693	}
694	eof:
695	g_free(new);
696	g_free(cmds);
697	}
698
699	void twitter_log(struct im_connection ic, char format, ... )
700	{
701	struct twitter_data *td = ic->proto_data;
702	va_list params;
703	char *text;
704
705	va_start(params, format);
706	text = g_strdup_vprintf(format, params);
707	va_end(params);
708
709	if (td->timeline_gc)
710	imcb_chat_log(td->timeline_gc, "%s", text);
711	else
712	imcb_log(ic, "%s", text);
713
714	g_free(text);
715	}
716
717
718	void twitter_initmodule()
719	{
720	struct prpl *ret = g_new0(struct prpl, 1);
721
722	ret->options = OPT_NOOTR;
723	ret->name = "twitter";
724	ret->login = twitter_login;
725	ret->init = twitter_init;
726	ret->logout = twitter_logout;
727	ret->buddy_msg = twitter_buddy_msg;
728	ret->get_info = twitter_get_info;
729	ret->add_buddy = twitter_add_buddy;
730	ret->remove_buddy = twitter_remove_buddy;
731	ret->chat_msg = twitter_chat_msg;
732	ret->chat_invite = twitter_chat_invite;
733	ret->chat_leave = twitter_chat_leave;
734	ret->keepalive = twitter_keepalive;
735	ret->add_permit = twitter_add_permit;
736	ret->rem_permit = twitter_rem_permit;
737	ret->add_deny = twitter_add_deny;
738	ret->rem_deny = twitter_rem_deny;
739	ret->buddy_data_add = twitter_buddy_data_add;
740	ret->buddy_data_free = twitter_buddy_data_free;
741	ret->handle_cmp = g_strcasecmp;
742
743	register_protocol(ret);
744
745	/* And an identi.ca variant: */
746	ret = g_memdup(ret, sizeof(struct prpl));
747	ret->name = "identica";
748	register_protocol(ret);
749	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: