Context Navigation

source: protocols/jabber/jabber.c @ 91dd19c

Last change on this file since 91dd19c was 73dd021, checked in by dequis <dx@…>, at 2015-07-04T21:25:16Z

jabber: Add SASL ANONYMOUS support (XEP-0175)

Use "account jabber set anonymous on" to have bitlbee try that method

Property mode set to 100644

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

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

Download in other formats: