Context Navigation

source: protocols/jabber/jabber.c @ bef322e

Last change on this file since bef322e was b38f655, checked in by dequis <dx@…>, at 2015-05-28T05:26:30Z

Rename mail notification related settings for consistency

GMail notifications stuff is now just 'mail_notifications'
sed -i s/notify_handle/mail_notifications_handle/

Property mode set to 100644

File size: 20.0 KB

Line
1	/***************************************************************************\
2	* *
3	* BitlBee - An IRC to IM gateway *
4	* Jabber module - Main file *
5	* *
6	* Copyright 2006-2013 Wilmer van der Gaast <wilmer@gaast.net> *
7	* *
8	* This program is free software; you can redistribute it and/or modify *
9	* it under the terms of the GNU General Public License as published by *
10	* the Free Software Foundation; either version 2 of the License, or *
11	* (at your option) any later version. *
12	* *
13	* This program is distributed in the hope that it will be useful, *
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16	* GNU General Public License for more details. *
17	* *
18	* You should have received a copy of the GNU General Public License along *
19	* with this program; if not, write to the Free Software Foundation, Inc., *
20	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
21	* *
22	\***************************************************************************/
23
24	#include <glib.h>
25	#include <string.h>
26	#include <unistd.h>
27	#include <ctype.h>
28	#include <stdio.h>
29
30	#include "ssl_client.h"
31	#include "xmltree.h"
32	#include "bitlbee.h"
33	#include "jabber.h"
34	#include "oauth.h"
35	#include "md5.h"
36
37	GSList *jabber_connections;
38
39	/* First enty is the default */
40	static const int jabber_port_list[] = {
41	5222,
42	5223,
43	5220,
44	5221,
45	5224,
46	5225,
47	5226,
48	5227,
49	5228,
50	5229,
51	80,
52	443,
53	0
54	};
55
56	static void jabber_init(account_t *acc)
57	{
58	set_t *s;
59	char str[16];
60
61	s = set_add(&acc->set, "activity_timeout", "600", set_eval_int, acc);
62
63	s = set_add(&acc->set, "display_name", NULL, NULL, acc);
64
65	g_snprintf(str, sizeof(str), "%d", jabber_port_list[0]);
66	s = set_add(&acc->set, "port", str, set_eval_int, acc);
67	s->flags \|= ACC_SET_OFFLINE_ONLY;
68
69	s = set_add(&acc->set, "priority", "0", set_eval_priority, acc);
70
71	s = set_add(&acc->set, "proxy", "<local>;<auto>", NULL, acc);
72
73	s = set_add(&acc->set, "resource", "BitlBee", NULL, acc);
74	s->flags \|= ACC_SET_OFFLINE_ONLY;
75
76	s = set_add(&acc->set, "resource_select", "activity", NULL, acc);
77
78	s = set_add(&acc->set, "sasl", "true", set_eval_bool, acc);
79	s->flags \|= ACC_SET_OFFLINE_ONLY \| SET_HIDDEN_DEFAULT;
80
81	s = set_add(&acc->set, "server", NULL, set_eval_account, acc);
82	s->flags \|= SET_NOSAVE \| ACC_SET_OFFLINE_ONLY \| SET_NULL_OK;
83
84	if (strcmp(acc->prpl->name, "hipchat") == 0) {
85	set_setstr(&acc->set, "server", "chat.hipchat.com");
86	} else {
87	s = set_add(&acc->set, "oauth", "false", set_eval_oauth, acc);
88	}
89
90	s = set_add(&acc->set, "ssl", "false", set_eval_bool, acc);
91	s->flags \|= ACC_SET_OFFLINE_ONLY;
92
93	s = set_add(&acc->set, "tls", "true", set_eval_tls, acc);
94	s->flags \|= ACC_SET_OFFLINE_ONLY;
95
96	s = set_add(&acc->set, "tls_verify", "true", set_eval_bool, acc);
97	s->flags \|= ACC_SET_OFFLINE_ONLY;
98
99	s = set_add(&acc->set, "user_agent", "BitlBee", NULL, acc);
100
101	s = set_add(&acc->set, "xmlconsole", "false", set_eval_bool, acc);
102
103	s = set_add(&acc->set, "mail_notifications", "false", set_eval_bool, acc);
104	s->flags \|= ACC_SET_OFFLINE_ONLY;
105
106	/* changing this is rarely needed so keeping it secret */
107	s = set_add(&acc->set, "mail_notifications_limit", "5", set_eval_int, acc);
108	s->flags \|= SET_HIDDEN_DEFAULT;
109
110	s = set_add(&acc->set, "mail_notifications_handle", NULL, NULL, acc);
111	s->flags \|= ACC_SET_OFFLINE_ONLY \| SET_NULL_OK;
112
113	acc->flags \|= ACC_FLAG_AWAY_MESSAGE \| ACC_FLAG_STATUS_MESSAGE \|
114	ACC_FLAG_HANDLE_DOMAINS;
115	}
116
117	static void jabber_generate_id_hash(struct jabber_data *jd);
118
119	static void jabber_login(account_t *acc)
120	{
121	struct im_connection *ic = imcb_new(acc);
122	struct jabber_data *jd = g_new0(struct jabber_data, 1);
123	char *s;
124
125	/* For now this is needed in the _connected() handlers if using
126	GLib event handling, to make sure we're not handling events
127	on dead connections. */
128	jabber_connections = g_slist_prepend(jabber_connections, ic);
129
130	jd->ic = ic;
131	ic->proto_data = jd;
132
133	jabber_set_me(ic, acc->user);
134
135	jd->fd = jd->r_inpa = jd->w_inpa = -1;
136
137	if (strcmp(acc->prpl->name, "hipchat") == 0) {
138	jd->flags \|= JFLAG_HIPCHAT;
139	}
140
141	if (jd->server == NULL) {
142	imcb_error(ic, "Incomplete account name (format it like <username@jabberserver.name>)");
143	imc_logout(ic, FALSE);
144	return;
145	}
146
147	if ((s = strchr(jd->server, '/'))) {
148	*s = 0;
149	set_setstr(&acc->set, "resource", s + 1);
150
151	/* Also remove the /resource from the original variable so we
152	won't have to do this again every time. */
153	s = strchr(acc->user, '/');
154	*s = 0;
155	}
156
157	jd->node_cache = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, jabber_cache_entry_free);
158	jd->buddies = g_hash_table_new(g_str_hash, g_str_equal);
159
160	if (set_getbool(&acc->set, "oauth")) {
161	GSList *p_in = NULL;
162	const char *tok;
163
164	jd->fd = jd->r_inpa = jd->w_inpa = -1;
165
166	if (strstr(jd->server, ".facebook.com")) {
167	jd->oauth2_service = &oauth2_service_facebook;
168	} else {
169	jd->oauth2_service = &oauth2_service_google;
170	}
171
172	oauth_params_parse(&p_in, ic->acc->pass);
173
174	/* First see if we have a refresh token, in which case any
175	access token we might have has probably expired already
176	anyway. */
177	if ((tok = oauth_params_get(&p_in, "refresh_token"))) {
178	sasl_oauth2_refresh(ic, tok);
179	}
180	/* If we don't have a refresh token, let's hope the access
181	token is still usable. */
182	else if ((tok = oauth_params_get(&p_in, "access_token"))) {
183	jd->oauth2_access_token = g_strdup(tok);
184	jabber_connect(ic);
185	}
186	/* If we don't have any, start the OAuth process now. Don't
187	even open an XMPP connection yet. */
188	else {
189	sasl_oauth2_init(ic);
190	ic->flags \|= OPT_SLOW_LOGIN;
191	}
192
193	oauth_params_free(&p_in);
194	} else {
195	jabber_connect(ic);
196	}
197	}
198
199	/* Separate this from jabber_login() so we can do OAuth first if necessary.
200	Putting this in io.c would probably be more correct. */
201	void jabber_connect(struct im_connection *ic)
202	{
203	account_t *acc = ic->acc;
204	struct jabber_data *jd = ic->proto_data;
205	int i;
206	char *connect_to;
207	struct ns_srv_reply *srvl = NULL, srv = NULL;
208
209	/* Figure out the hostname to connect to. */
210	if (acc->server && *acc->server) {
211	connect_to = acc->server;
212	} else if ((srvl = srv_lookup("xmpp-client", "tcp", jd->server)) \|\|
213	(srvl = srv_lookup("jabber-client", "tcp", jd->server))) {
214	/* Find the lowest-priority one. These usually come
215	back in random/shuffled order. Not looking at
216	weights etc for now. */
217	srv = *srvl;
218	for (i = 1; srvl[i]; i++) {
219	if (srvl[i]->prio < srv->prio) {
220	srv = srvl[i];
221	}
222	}
223
224	connect_to = srv->name;
225	} else {
226	connect_to = jd->server;
227	}
228
229	imcb_log(ic, "Connecting");
230
231	for (i = 0; jabber_port_list[i] > 0; i++) {
232	if (set_getint(&acc->set, "port") == jabber_port_list[i]) {
233	break;
234	}
235	}
236
237	if (jabber_port_list[i] == 0) {
238	imcb_log(ic, "Illegal port number");
239	imc_logout(ic, FALSE);
240	return;
241	}
242
243	/* For non-SSL connections we can try to use the port # from the SRV
244	reply, but let's not do that when using SSL, SSL usually runs on
245	non-standard ports... */
246	if (set_getbool(&acc->set, "ssl")) {
247	jd->ssl = ssl_connect(connect_to, set_getint(&acc->set, "port"), set_getbool(&acc->set,
248	"tls_verify"), jabber_connected_ssl,
249	ic);
250	jd->fd = jd->ssl ? ssl_getfd(jd->ssl) : -1;
251	} else {
252	jd->fd = proxy_connect(connect_to, srv ? srv->port : set_getint(&acc->set,
253	"port"), jabber_connected_plain, ic);
254	}
255	srv_free(srvl);
256
257	if (jd->fd == -1) {
258	imcb_error(ic, "Could not connect to server");
259	imc_logout(ic, TRUE);
260
261	return;
262	}
263
264	if (set_getbool(&acc->set, "xmlconsole")) {
265	jd->flags \|= JFLAG_XMLCONSOLE;
266	/* Shouldn't really do this at this stage already, maybe. But
267	I think this shouldn't break anything. */
268	imcb_add_buddy(ic, JABBER_XMLCONSOLE_HANDLE, NULL);
269	}
270
271	if (set_getbool(&acc->set, "mail_notifications")) {
272	/* It's gmail specific, but it checks for server support before enabling it */
273	jd->flags \|= JFLAG_GMAILNOTIFY;
274	if (set_getstr(&acc->set, "mail_notifications_handle")) {
275	imcb_add_buddy(ic, set_getstr(&acc->set, "mail_notifications_handle"), NULL);
276	}
277	}
278
279	jabber_generate_id_hash(jd);
280	}
281
282	/* This generates an unfinished md5_state_t variable. Every time we generate
283	an ID, we finish the state by adding a sequence number and take the hash. */
284	static void jabber_generate_id_hash(struct jabber_data *jd)
285	{
286	md5_byte_t binbuf[4];
287	char *s;
288
289	md5_init(&jd->cached_id_prefix);
290	md5_append(&jd->cached_id_prefix, (unsigned char *) jd->username, strlen(jd->username));
291	md5_append(&jd->cached_id_prefix, (unsigned char *) jd->server, strlen(jd->server));
292	s = set_getstr(&jd->ic->acc->set, "resource");
293	md5_append(&jd->cached_id_prefix, (unsigned char *) s, strlen(s));
294	random_bytes(binbuf, 4);
295	md5_append(&jd->cached_id_prefix, binbuf, 4);
296	}
297
298	static void jabber_logout(struct im_connection *ic)
299	{
300	struct jabber_data *jd = ic->proto_data;
301
302	while (jd->filetransfers) {
303	imcb_file_canceled(ic, (( struct jabber_transfer *) jd->filetransfers->data)->ft, "Logging out");
304	}
305
306	while (jd->streamhosts) {
307	jabber_streamhost_t *sh = jd->streamhosts->data;
308	jd->streamhosts = g_slist_remove(jd->streamhosts, sh);
309	g_free(sh->jid);
310	g_free(sh->host);
311	g_free(sh);
312	}
313
314	if (jd->fd >= 0) {
315	jabber_end_stream(ic);
316	}
317
318	while (ic->groupchats) {
319	jabber_chat_free(ic->groupchats->data);
320	}
321
322	if (jd->r_inpa >= 0) {
323	b_event_remove(jd->r_inpa);
324	}
325	if (jd->w_inpa >= 0) {
326	b_event_remove(jd->w_inpa);
327	}
328
329	if (jd->ssl) {
330	ssl_disconnect(jd->ssl);
331	}
332	if (jd->fd >= 0) {
333	closesocket(jd->fd);
334	}
335
336	if (jd->tx_len) {
337	g_free(jd->txq);
338	}
339
340	if (jd->node_cache) {
341	g_hash_table_destroy(jd->node_cache);
342	}
343
344	jabber_buddy_remove_all(ic);
345
346	xt_free(jd->xt);
347
348	md5_free(&jd->cached_id_prefix);
349
350	g_free(jd->oauth2_access_token);
351	g_free(jd->away_message);
352	g_free(jd->internal_jid);
353	g_free(jd->gmail_tid);
354	g_free(jd->username);
355	g_free(jd->me);
356	g_free(jd);
357
358	jabber_connections = g_slist_remove(jabber_connections, ic);
359	}
360
361	static int jabber_buddy_msg(struct im_connection ic, char who, char *message, int flags)
362	{
363	struct jabber_data *jd = ic->proto_data;
364	struct jabber_buddy *bud;
365	struct xt_node *node;
366	char *s;
367	int st;
368
369	if (g_strcasecmp(who, JABBER_XMLCONSOLE_HANDLE) == 0) {
370	return jabber_write(ic, message, strlen(message));
371	}
372
373	if (g_strcasecmp(who, JABBER_OAUTH_HANDLE) == 0 &&
374	!(jd->flags & OPT_LOGGED_IN) && jd->fd == -1) {
375	if (sasl_oauth2_get_refresh_token(ic, message)) {
376	return 1;
377	} else {
378	imcb_error(ic, "OAuth failure");
379	imc_logout(ic, TRUE);
380	return 0;
381	}
382	}
383
384	if ((s = strchr(who, '=')) && jabber_chat_by_jid(ic, s + 1)) {
385	bud = jabber_buddy_by_ext_jid(ic, who, 0);
386	} else {
387	bud = jabber_buddy_by_jid(ic, who, GET_BUDDY_BARE_OK);
388	}
389
390	node = xt_new_node("body", message, NULL);
391	node = jabber_make_packet("message", "chat", bud ? bud->full_jid : who, node);
392
393	if (bud && (jd->flags & JFLAG_WANT_TYPING) &&
394	((bud->flags & JBFLAG_DOES_XEP85) \|\|
395	!(bud->flags & JBFLAG_PROBED_XEP85))) {
396	struct xt_node *act;
397
398	/* If the user likes typing notification and if we don't know
399	(and didn't probe before) if this resource supports XEP85,
400	include a probe in this packet now. Also, if we know this
401	buddy does support XEP85, we have to send this <active/>
402	tag to tell that the user stopped typing (well, that's what
403	we guess when s/he pressed Enter...). */
404	act = xt_new_node("active", NULL, NULL);
405	xt_add_attr(act, "xmlns", XMLNS_CHATSTATES);
406	xt_add_child(node, act);
407
408	/* Just make sure we do this only once. */
409	bud->flags \|= JBFLAG_PROBED_XEP85;
410	}
411
412	st = jabber_write_packet(ic, node);
413	xt_free_node(node);
414
415	return st;
416	}
417
418	static GList jabber_away_states(struct im_connection ic)
419	{
420	static GList *l = NULL;
421	int i;
422
423	if (l == NULL) {
424	for (i = 0; jabber_away_state_list[i].full_name; i++) {
425	l = g_list_append(l, (void *) jabber_away_state_list[i].full_name);
426	}
427	}
428
429	return l;
430	}
431
432	static void jabber_get_info(struct im_connection ic, char who)
433	{
434	struct jabber_buddy *bud;
435
436	bud = jabber_buddy_by_jid(ic, who, GET_BUDDY_FIRST);
437
438	while (bud) {
439	imcb_log(ic, "Buddy %s (%d) information:", bud->full_jid, bud->priority);
440	if (bud->away_state) {
441	imcb_log(ic, "Away state: %s", bud->away_state->full_name);
442	}
443	imcb_log(ic, "Status message: %s", bud->away_message ? bud->away_message : "(none)");
444
445	bud = bud->next;
446	}
447
448	jabber_get_vcard(ic, who);
449	}
450
451	static void jabber_set_away(struct im_connection ic, char state_txt, char *message)
452	{
453	struct jabber_data *jd = ic->proto_data;
454
455	/* state_txt == NULL -> Not away.
456	Unknown state -> fall back to the first defined away state. */
457	if (state_txt == NULL) {
458	jd->away_state = NULL;
459	} else if ((jd->away_state = jabber_away_state_by_name(state_txt)) == NULL) {
460	jd->away_state = jabber_away_state_list;
461	}
462
463	g_free(jd->away_message);
464	jd->away_message = (message && *message) ? g_strdup(message) : NULL;
465
466	presence_send_update(ic);
467	}
468
469	static void jabber_add_buddy(struct im_connection ic, char who, char *group)
470	{
471	struct jabber_data *jd = ic->proto_data;
472
473	if (g_strcasecmp(who, JABBER_XMLCONSOLE_HANDLE) == 0) {
474	jd->flags \|= JFLAG_XMLCONSOLE;
475	imcb_add_buddy(ic, JABBER_XMLCONSOLE_HANDLE, NULL);
476	return;
477	}
478
479	if (jabber_add_to_roster(ic, who, NULL, group)) {
480	presence_send_request(ic, who, "subscribe");
481	}
482	}
483
484	static void jabber_remove_buddy(struct im_connection ic, char who, char *group)
485	{
486	struct jabber_data *jd = ic->proto_data;
487
488	if (g_strcasecmp(who, JABBER_XMLCONSOLE_HANDLE) == 0) {
489	jd->flags &= ~JFLAG_XMLCONSOLE;
490	/* Not necessary for now. And for now the code isn't too
491	happy if the buddy is completely gone right after calling
492	this function already.
493	imcb_remove_buddy( ic, JABBER_XMLCONSOLE_HANDLE, NULL );
494	*/
495	return;
496	}
497
498	/* We should always do this part. Clean up our administration a little bit. */
499	jabber_buddy_remove_bare(ic, who);
500
501	if (jabber_remove_from_roster(ic, who)) {
502	presence_send_request(ic, who, "unsubscribe");
503	}
504	}
505
506	static struct groupchat jabber_chat_join_(struct im_connection ic, const char room, const char nick,
507	const char password, set_t *sets)
508	{
509	struct jabber_data *jd = ic->proto_data;
510	char *final_nick;
511
512	/* Ignore the passed nick parameter if we have our own default */
513	if (!(final_nick = set_getstr(sets, "nick")) &&
514	!(final_nick = set_getstr(&ic->acc->set, "display_name"))) {
515	/* Well, whatever, actually use the provided default, then */
516	final_nick = (char *) nick;
517	}
518
519	if (strchr(room, '@') == NULL) {
520	imcb_error(ic, "%s is not a valid Jabber room name. Maybe you mean %s@conference.%s?",
521	room, room, jd->server);
522	} else if (jabber_chat_by_jid(ic, room)) {
523	imcb_error(ic, "Already present in chat `%s'", room);
524	} else {
525	return jabber_chat_join(ic, room, final_nick, set_getstr(sets, "password"));
526	}
527
528	return NULL;
529	}
530
531	static struct groupchat jabber_chat_with_(struct im_connection ic, char *who)
532	{
533	return jabber_chat_with(ic, who);
534	}
535
536	static void jabber_chat_msg_(struct groupchat c, char message, int flags)
537	{
538	if (c && message) {
539	jabber_chat_msg(c, message, flags);
540	}
541	}
542
543	static void jabber_chat_topic_(struct groupchat c, char topic)
544	{
545	if (c && topic) {
546	jabber_chat_topic(c, topic);
547	}
548	}
549
550	static void jabber_chat_leave_(struct groupchat *c)
551	{
552	if (c) {
553	jabber_chat_leave(c, NULL);
554	}
555	}
556
557	static void jabber_chat_invite_(struct groupchat c, char who, char *msg)
558	{
559	struct jabber_data *jd = c->ic->proto_data;
560	struct jabber_chat *jc = c->data;
561	gchar *msg_alt = NULL;
562
563	if (msg == NULL) {
564	msg_alt = g_strdup_printf("%s invited you to %s", jd->me, jc->name);
565	}
566
567	if (c && who) {
568	jabber_chat_invite(c, who, msg ? msg : msg_alt);
569	}
570
571	g_free(msg_alt);
572	}
573
574	static void jabber_keepalive(struct im_connection *ic)
575	{
576	/* Just any whitespace character is enough as a keepalive for XMPP sessions. */
577	if (!jabber_write(ic, "\n", 1)) {
578	return;
579	}
580
581	/* This runs the garbage collection every minute, which means every packet
582	is in the cache for about a minute (which should be enough AFAIK). */
583	jabber_cache_clean(ic);
584	}
585
586	static int jabber_send_typing(struct im_connection ic, char who, int typing)
587	{
588	struct jabber_data *jd = ic->proto_data;
589	struct jabber_buddy *bud;
590
591	/* Enable typing notification related code from now. */
592	jd->flags \|= JFLAG_WANT_TYPING;
593
594	if ((bud = jabber_buddy_by_jid(ic, who, 0)) == NULL) {
595	/* Sending typing notifications to unknown buddies is
596	unsupported for now. Shouldn't be a problem, I think. */
597	return 0;
598	}
599
600	if (bud->flags & JBFLAG_DOES_XEP85) {
601	/* We're only allowed to send this stuff if we know the other
602	side supports it. */
603
604	struct xt_node *node;
605	char *type;
606	int st;
607
608	if (typing & OPT_TYPING) {
609	type = "composing";
610	} else if (typing & OPT_THINKING) {
611	type = "paused";
612	} else {
613	type = "active";
614	}
615
616	node = xt_new_node(type, NULL, NULL);
617	xt_add_attr(node, "xmlns", XMLNS_CHATSTATES);
618	node = jabber_make_packet("message", "chat", bud->full_jid, node);
619
620	st = jabber_write_packet(ic, node);
621	xt_free_node(node);
622
623	return st;
624	}
625
626	return 1;
627	}
628
629	void jabber_chat_add_settings(account_t acc, set_t *head)
630	{
631	/* Meh. Stupid room passwords. Not trying to obfuscate/hide
632	them from the user for now. */
633	set_add(head, "password", NULL, NULL, NULL);
634	}
635
636	void jabber_chat_free_settings(account_t acc, set_t *head)
637	{
638	set_del(head, "password");
639	}
640
641	GList jabber_buddy_action_list(bee_user_t bu)
642	{
643	static GList *ret = NULL;
644
645	if (ret == NULL) {
646	static const struct buddy_action ba[2] = {
647	{ "VERSION", "Get client (version) information" },
648	};
649
650	ret = g_list_prepend(ret, (void *) ba + 0);
651	}
652
653	return ret;
654	}
655
656	void jabber_buddy_action(struct bee_user bu, const char action, char const args[], void *data)
657	{
658	if (g_strcasecmp(action, "VERSION") == 0) {
659	struct jabber_buddy *bud;
660
661	if ((bud = jabber_buddy_by_ext_jid(bu->ic, bu->handle, 0)) == NULL) {
662	bud = jabber_buddy_by_jid(bu->ic, bu->handle, GET_BUDDY_FIRST);
663	}
664	for (; bud; bud = bud->next) {
665	jabber_iq_version_send(bu->ic, bud, data);
666	}
667	}
668
669	return NULL;
670	}
671
672	gboolean jabber_handle_is_self(struct im_connection ic, const char who)
673	{
674	struct jabber_data *jd = ic->proto_data;
675
676	return ((g_strcasecmp(who, ic->acc->user) == 0) \|\|
677	(jd->internal_jid &&
678	g_strcasecmp(who, jd->internal_jid) == 0));
679	}
680
681	void jabber_initmodule()
682	{
683	struct prpl *ret = g_new0(struct prpl, 1);
684	struct prpl *hipchat = NULL;
685
686	ret->name = "jabber";
687	ret->mms = 0; /* no limit */
688	ret->login = jabber_login;
689	ret->init = jabber_init;
690	ret->logout = jabber_logout;
691	ret->buddy_msg = jabber_buddy_msg;
692	ret->away_states = jabber_away_states;
693	ret->set_away = jabber_set_away;
694	// ret->set_info = jabber_set_info;
695	ret->get_info = jabber_get_info;
696	ret->add_buddy = jabber_add_buddy;
697	ret->remove_buddy = jabber_remove_buddy;
698	ret->chat_msg = jabber_chat_msg_;
699	ret->chat_topic = jabber_chat_topic_;
700	ret->chat_invite = jabber_chat_invite_;
701	ret->chat_leave = jabber_chat_leave_;
702	ret->chat_join = jabber_chat_join_;
703	ret->chat_with = jabber_chat_with_;
704	ret->chat_add_settings = jabber_chat_add_settings;
705	ret->chat_free_settings = jabber_chat_free_settings;
706	ret->keepalive = jabber_keepalive;
707	ret->send_typing = jabber_send_typing;
708	ret->handle_cmp = g_strcasecmp;
709	ret->handle_is_self = jabber_handle_is_self;
710	ret->transfer_request = jabber_si_transfer_request;
711	ret->buddy_action_list = jabber_buddy_action_list;
712	ret->buddy_action = jabber_buddy_action;
713
714	register_protocol(ret);
715
716	/* Another one for hipchat, which has completely different logins */
717	hipchat = g_memdup(ret, sizeof(struct prpl));
718	hipchat->name = "hipchat";
719	register_protocol(hipchat);
720	}

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

Download in other formats: