Context Navigation

source: protocols/oscar/oscar.c @ 23d6165

Last change on this file since 23d6165 was 5588edf5, checked in by Wilmer van der Gaast <wilmer@…>, at 2010-07-25T08:56:17Z
Suppress GLib warning when trying to get a user's IP address while not any IP information is available (yet).
Property mode set to `100644`
File size: 74.2 KB

Line
1	/*
2	* gaim
3	*
4	* Some code copyright (C) 2002-2006, Jelmer Vernooij <jelmer@samba.org>
5	* and the BitlBee team.
6	* Some code copyright (C) 1998-1999, Mark Spencer <markster@marko.net>
7	* libfaim code copyright 1998, 1999 Adam Fritzler <afritz@auk.cx>
8	*
9	* This program is free software; you can redistribute it and/or modify
10	* it under the terms of the GNU General Public License as published by
11	* the Free Software Foundation; either version 2 of the License, or
12	* (at your option) any later version.
13	*
14	* This program 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
17	* GNU General Public License for more details.
18	*
19	* You should have received a copy of the GNU General Public License
20	* along with this program; if not, write to the Free Software
21	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22	*
23	*/
24
25	#include <errno.h>
26	#include <ctype.h>
27	#include <string.h>
28	#include <stdlib.h>
29	#include <stdio.h>
30	#include <time.h>
31	#include <sys/stat.h>
32	#include <glib.h>
33	#include "nogaim.h"
34	#include "bitlbee.h"
35	#include "proxy.h"
36	#include "sock.h"
37
38	#include "aim.h"
39	#include "icq.h"
40	#include "bos.h"
41	#include "ssi.h"
42	#include "im.h"
43	#include "info.h"
44	#include "buddylist.h"
45	#include "chat.h"
46	#include "chatnav.h"
47
48	/* constants to identify proto_opts */
49	#define USEROPT_AUTH 0
50	#define USEROPT_AUTHPORT 1
51
52	#define UC_AOL 0x02
53	#define UC_ADMIN 0x04
54	#define UC_UNCONFIRMED 0x08
55	#define UC_NORMAL 0x10
56	#define UC_AB 0x20
57	#define UC_WIRELESS 0x40
58
59	#define AIMHASHDATA "http://gaim.sourceforge.net/aim_data.php3"
60
61	#define OSCAR_GROUP "Friends"
62
63	#define BUF_LEN 2048
64	#define BUF_LONG ( BUF_LEN * 2 )
65
66	/* Don't know if support for UTF8 is really working. For now it's UTF16 here.
67	static int gaim_caps = AIM_CAPS_UTF8; */
68
69	static int gaim_caps = AIM_CAPS_INTEROP \| AIM_CAPS_ICHAT \| AIM_CAPS_ICQSERVERRELAY \| AIM_CAPS_CHAT;
70	static guint8 gaim_features[] = {0x01, 0x01, 0x01, 0x02};
71
72	struct oscar_data {
73	aim_session_t *sess;
74	aim_conn_t *conn;
75
76	guint cnpa;
77	guint paspa;
78
79	GSList *create_rooms;
80
81	gboolean conf;
82	gboolean reqemail;
83	gboolean setemail;
84	char *email;
85	gboolean setnick;
86	char *newsn;
87	gboolean chpass;
88	char *oldp;
89	char *newp;
90
91	GSList *oscar_chats;
92
93	gboolean killme, no_reconnect;
94	gboolean icq;
95	GSList *evilhack;
96
97	GHashTable *ips;
98
99	struct {
100	guint maxbuddies; /* max users you can watch */
101	guint maxwatchers; /* max users who can watch you */
102	guint maxpermits; /* max users on permit list */
103	guint maxdenies; /* max users on deny list */
104	guint maxsiglen; /* max size (bytes) of profile */
105	guint maxawaymsglen; /* max size (bytes) of posted away message */
106	} rights;
107	};
108
109	struct create_room {
110	char *name;
111	int exchange;
112	};
113
114	struct chat_connection {
115	char *name;
116	char show; / AOL did something funny to us */
117	guint16 exchange;
118	guint16 instance;
119	int fd; /* this is redundant since we have the conn below */
120	aim_conn_t *conn;
121	int inpa;
122	int id;
123	struct im_connection ic; / i hate this. */
124	struct groupchat cnv; / bah. */
125	int maxlen;
126	int maxvis;
127	};
128
129	struct ask_direct {
130	struct im_connection *ic;
131	char *sn;
132	char ip[64];
133	guint8 cookie[8];
134	};
135
136	struct icq_auth {
137	struct im_connection *ic;
138	guint32 uin;
139	};
140
141	static char extract_name(const char name) {
142	char *tmp;
143	int i, j;
144	char *x = strchr(name, '-');
145	if (!x) return g_strdup(name);
146	x = strchr(++x, '-');
147	if (!x) return g_strdup(name);
148	tmp = g_strdup(++x);
149
150	for (i = 0, j = 0; x[i]; i++) {
151	char hex[3];
152	if (x[i] != '%') {
153	tmp[j++] = x[i];
154	continue;
155	}
156	strncpy(hex, x + ++i, 2); hex[2] = 0;
157	i++;
158	tmp[j++] = (char)strtol(hex, NULL, 16);
159	}
160
161	tmp[j] = 0;
162	return tmp;
163	}
164
165	static struct chat_connection find_oscar_chat_by_conn(struct im_connection ic,
166	aim_conn_t *conn) {
167	GSList g = ((struct oscar_data )ic->proto_data)->oscar_chats;
168	struct chat_connection *c = NULL;
169
170	while (g) {
171	c = (struct chat_connection *)g->data;
172	if (c->conn == conn)
173	break;
174	g = g->next;
175	c = NULL;
176	}
177
178	return c;
179	}
180
181	static int gaim_parse_auth_resp (aim_session_t , aim_frame_t , ...);
182	static int gaim_parse_login (aim_session_t , aim_frame_t , ...);
183	static int gaim_parse_logout (aim_session_t , aim_frame_t , ...);
184	static int gaim_handle_redirect (aim_session_t , aim_frame_t , ...);
185	static int gaim_parse_oncoming (aim_session_t , aim_frame_t , ...);
186	static int gaim_parse_offgoing (aim_session_t , aim_frame_t , ...);
187	static int gaim_parse_incoming_im(aim_session_t , aim_frame_t , ...);
188	static int gaim_parse_misses (aim_session_t , aim_frame_t , ...);
189	static int gaim_parse_motd (aim_session_t , aim_frame_t , ...);
190	static int gaim_chatnav_info (aim_session_t , aim_frame_t , ...);
191	static int gaim_chat_join (aim_session_t , aim_frame_t , ...);
192	static int gaim_chat_leave (aim_session_t , aim_frame_t , ...);
193	static int gaim_chat_info_update (aim_session_t , aim_frame_t , ...);
194	static int gaim_chat_incoming_msg(aim_session_t , aim_frame_t , ...);
195	static int gaim_parse_ratechange (aim_session_t , aim_frame_t , ...);
196	static int gaim_bosrights (aim_session_t , aim_frame_t , ...);
197	static int conninitdone_bos (aim_session_t , aim_frame_t , ...);
198	static int conninitdone_admin (aim_session_t , aim_frame_t , ...);
199	static int conninitdone_chat (aim_session_t , aim_frame_t , ...);
200	static int conninitdone_chatnav (aim_session_t , aim_frame_t , ...);
201	static int gaim_parse_msgerr (aim_session_t , aim_frame_t , ...);
202	static int gaim_parse_locaterights(aim_session_t , aim_frame_t , ...);
203	static int gaim_parse_buddyrights(aim_session_t , aim_frame_t , ...);
204	static int gaim_parse_locerr (aim_session_t , aim_frame_t , ...);
205	static int gaim_icbm_param_info (aim_session_t , aim_frame_t , ...);
206	static int gaim_parse_genericerr (aim_session_t , aim_frame_t , ...);
207	static int gaim_selfinfo (aim_session_t , aim_frame_t , ...);
208	static int gaim_offlinemsg (aim_session_t , aim_frame_t , ...);
209	static int gaim_offlinemsgdone (aim_session_t , aim_frame_t , ...);
210	static int gaim_ssi_parserights (aim_session_t , aim_frame_t , ...);
211	static int gaim_ssi_parselist (aim_session_t , aim_frame_t , ...);
212	static int gaim_ssi_parseack (aim_session_t , aim_frame_t , ...);
213	static int gaim_parsemtn (aim_session_t , aim_frame_t , ...);
214	static int gaim_icqinfo (aim_session_t , aim_frame_t , ...);
215	static int gaim_parseaiminfo (aim_session_t , aim_frame_t , ...);
216
217	static char *msgerrreason[] = {
218	"Invalid error",
219	"Invalid SNAC",
220	"Rate to host",
221	"Rate to client",
222	"Not logged in",
223	"Service unavailable",
224	"Service not defined",
225	"Obsolete SNAC",
226	"Not supported by host",
227	"Not supported by client",
228	"Refused by client",
229	"Reply too big",
230	"Responses lost",
231	"Request denied",
232	"Busted SNAC payload",
233	"Insufficient rights",
234	"In local permit/deny",
235	"Too evil (sender)",
236	"Too evil (receiver)",
237	"User temporarily unavailable",
238	"No match",
239	"List overflow",
240	"Request ambiguous",
241	"Queue full",
242	"Not while on AOL"
243	};
244	static int msgerrreasonlen = 25;
245
246	/* Hurray, this function is NOT thread-safe \o/ */
247	static char normalize(const char s)
248	{
249	static char buf[BUF_LEN];
250	char t, u;
251	int x = 0;
252
253	g_return_val_if_fail((s != NULL), NULL);
254
255	u = t = g_strdup(s);
256	g_strdown(t);
257
258	while (*t && (x < BUF_LEN - 1)) {
259	if (t != ' ' && t != '!') {
260	buf[x] = *t;
261	x++;
262	}
263	t++;
264	}
265	buf[x] = '\0';
266	g_free(u);
267	return buf;
268	}
269
270	static gboolean oscar_callback(gpointer data, gint source,
271	b_input_condition condition) {
272	aim_conn_t conn = (aim_conn_t )data;
273	aim_session_t *sess = aim_conn_getsess(conn);
274	struct im_connection *ic = sess ? sess->aux_data : NULL;
275	struct oscar_data *odata;
276
277	if (!ic) {
278	/* ic is null. we return, else we seg SIGSEG on next line. */
279	return FALSE;
280	}
281
282	if (!g_slist_find(get_connections(), ic)) {
283	/* oh boy. this is probably bad. i guess the only thing we
284	* can really do is return? */
285	return FALSE;
286	}
287
288	odata = (struct oscar_data *)ic->proto_data;
289
290	if (condition & B_EV_IO_READ) {
291	if (aim_get_command(odata->sess, conn) >= 0) {
292	aim_rxdispatch(odata->sess);
293	if (odata->killme)
294	imc_logout(ic, !odata->no_reconnect);
295	} else {
296	if ((conn->type == AIM_CONN_TYPE_BOS) \|\|
297	!(aim_getconn_type(odata->sess, AIM_CONN_TYPE_BOS))) {
298	imcb_error(ic, _("Disconnected."));
299	imc_logout(ic, TRUE);
300	} else if (conn->type == AIM_CONN_TYPE_CHAT) {
301	struct chat_connection *c = find_oscar_chat_by_conn(ic, conn);
302	c->conn = NULL;
303	if (c->inpa > 0)
304	b_event_remove(c->inpa);
305	c->inpa = 0;
306	c->fd = -1;
307	aim_conn_kill(odata->sess, &conn);
308	imcb_error(sess->aux_data, _("You have been disconnected from chat room %s."), c->name);
309	} else if (conn->type == AIM_CONN_TYPE_CHATNAV) {
310	if (odata->cnpa > 0)
311	b_event_remove(odata->cnpa);
312	odata->cnpa = 0;
313	while (odata->create_rooms) {
314	struct create_room *cr = odata->create_rooms->data;
315	g_free(cr->name);
316	odata->create_rooms =
317	g_slist_remove(odata->create_rooms, cr);
318	g_free(cr);
319	imcb_error(sess->aux_data, _("Chat is currently unavailable"));
320	}
321	aim_conn_kill(odata->sess, &conn);
322	} else if (conn->type == AIM_CONN_TYPE_AUTH) {
323	if (odata->paspa > 0)
324	b_event_remove(odata->paspa);
325	odata->paspa = 0;
326	aim_conn_kill(odata->sess, &conn);
327	} else {
328	aim_conn_kill(odata->sess, &conn);
329	}
330	}
331	} else {
332	/* WTF??? */
333	return FALSE;
334	}
335
336	return TRUE;
337	}
338
339	static gboolean oscar_login_connect(gpointer data, gint source, b_input_condition cond)
340	{
341	struct im_connection *ic = data;
342	struct oscar_data *odata;
343	aim_session_t *sess;
344	aim_conn_t *conn;
345
346	if (!g_slist_find(get_connections(), ic)) {
347	closesocket(source);
348	return FALSE;
349	}
350
351	odata = ic->proto_data;
352	sess = odata->sess;
353	conn = aim_getconn_type_all(sess, AIM_CONN_TYPE_AUTH);
354
355	if (source < 0) {
356	imcb_error(ic, _("Couldn't connect to host"));
357	imc_logout(ic, TRUE);
358	return FALSE;
359	}
360
361	aim_conn_completeconnect(sess, conn);
362	ic->inpa = b_input_add(conn->fd, B_EV_IO_READ,
363	oscar_callback, conn);
364
365	return FALSE;
366	}
367
368	static void oscar_init(account_t *acc)
369	{
370	set_t *s;
371
372	if (isdigit(acc->user[0])) {
373	set_add(&acc->set, "ignore_auth_requests", "false", set_eval_bool, acc);
374	set_add(&acc->set, "old_icq_auth", "false", set_eval_bool, acc);
375	}
376
377	s = set_add(&acc->set, "server", AIM_DEFAULT_LOGIN_SERVER, set_eval_account, acc);
378	s->flags \|= ACC_SET_NOSAVE \| ACC_SET_OFFLINE_ONLY;
379
380	if(isdigit(acc->user[0])) {
381	s = set_add(&acc->set, "web_aware", "false", set_eval_bool, acc);
382	s->flags \|= ACC_SET_OFFLINE_ONLY;
383	}
384
385	acc->flags \|= ACC_FLAG_AWAY_MESSAGE;
386	}
387
388	static void oscar_login(account_t *acc) {
389	aim_session_t *sess;
390	aim_conn_t *conn;
391	struct im_connection *ic = imcb_new(acc);
392	struct oscar_data *odata = ic->proto_data = g_new0(struct oscar_data, 1);
393
394	if (isdigit(acc->user[0]))
395	odata->icq = TRUE;
396	else
397	ic->flags \|= OPT_DOES_HTML;
398
399	sess = g_new0(aim_session_t, 1);
400
401	aim_session_init(sess, AIM_SESS_FLAGS_NONBLOCKCONNECT, 0);
402
403	/* we need an immediate queue because we don't use a while-loop to
404	* see if things need to be sent. */
405	aim_tx_setenqueue(sess, AIM_TX_IMMEDIATE, NULL);
406	odata->sess = sess;
407	sess->aux_data = ic;
408
409	conn = aim_newconn(sess, AIM_CONN_TYPE_AUTH, NULL);
410	if (conn == NULL) {
411	imcb_error(ic, _("Unable to login to AIM"));
412	imc_logout(ic, TRUE);
413	return;
414	}
415
416	imcb_log(ic, _("Signon: %s"), ic->acc->user);
417
418	aim_conn_addhandler(sess, conn, 0x0017, 0x0007, gaim_parse_login, 0);
419	aim_conn_addhandler(sess, conn, 0x0017, 0x0003, gaim_parse_auth_resp, 0);
420
421	conn->status \|= AIM_CONN_STATUS_INPROGRESS;
422	conn->fd = proxy_connect(set_getstr(&acc->set, "server"),
423	AIM_LOGIN_PORT, oscar_login_connect, ic);
424	if (conn->fd < 0) {
425	imcb_error(ic, _("Couldn't connect to host"));
426	imc_logout(ic, TRUE);
427	return;
428	}
429	aim_request_login(sess, conn, ic->acc->user);
430	}
431
432	static void oscar_logout(struct im_connection *ic) {
433	struct oscar_data odata = (struct oscar_data )ic->proto_data;
434
435	while (odata->oscar_chats) {
436	struct chat_connection *n = odata->oscar_chats->data;
437	if (n->inpa > 0)
438	b_event_remove(n->inpa);
439	g_free(n->name);
440	g_free(n->show);
441	odata->oscar_chats = g_slist_remove(odata->oscar_chats, n);
442	g_free(n);
443	}
444	while (odata->create_rooms) {
445	struct create_room *cr = odata->create_rooms->data;
446	g_free(cr->name);
447	odata->create_rooms = g_slist_remove(odata->create_rooms, cr);
448	g_free(cr);
449	}
450	if (odata->ips)
451	g_hash_table_destroy(odata->ips);
452	if (odata->email)
453	g_free(odata->email);
454	if (odata->newp)
455	g_free(odata->newp);
456	if (odata->oldp)
457	g_free(odata->oldp);
458	if (ic->inpa > 0)
459	b_event_remove(ic->inpa);
460	if (odata->cnpa > 0)
461	b_event_remove(odata->cnpa);
462	if (odata->paspa > 0)
463	b_event_remove(odata->paspa);
464	aim_session_kill(odata->sess);
465	g_free(odata->sess);
466	odata->sess = NULL;
467	g_free(ic->proto_data);
468	ic->proto_data = NULL;
469	}
470
471	static gboolean oscar_bos_connect(gpointer data, gint source, b_input_condition cond) {
472	struct im_connection *ic = data;
473	struct oscar_data *odata;
474	aim_session_t *sess;
475	aim_conn_t *bosconn;
476
477	if (!g_slist_find(get_connections(), ic)) {
478	closesocket(source);
479	return FALSE;
480	}
481
482	odata = ic->proto_data;
483	sess = odata->sess;
484	bosconn = odata->conn;
485
486	if (source < 0) {
487	imcb_error(ic, _("Could Not Connect"));
488	imc_logout(ic, TRUE);
489	return FALSE;
490	}
491
492	aim_conn_completeconnect(sess, bosconn);
493	ic->inpa = b_input_add(bosconn->fd, B_EV_IO_READ,
494	oscar_callback, bosconn);
495	imcb_log(ic, _("Connection established, cookie sent"));
496
497	return FALSE;
498	}
499
500	static int gaim_parse_auth_resp(aim_session_t sess, aim_frame_t fr, ...) {
501	va_list ap;
502	struct aim_authresp_info *info;
503	int i; char *host; int port;
504	aim_conn_t *bosconn;
505
506	struct im_connection *ic = sess->aux_data;
507	struct oscar_data *od = ic->proto_data;
508	port = AIM_LOGIN_PORT;
509
510	va_start(ap, fr);
511	info = va_arg(ap, struct aim_authresp_info *);
512	va_end(ap);
513
514	if (info->errorcode \|\| !info->bosip \|\| !info->cookie) {
515	switch (info->errorcode) {
516	case 0x05:
517	/* Incorrect nick/password */
518	imcb_error(ic, _("Incorrect nickname or password."));
519	// plugin_event(event_error, (void *)980, 0, 0, 0);
520	break;
521	case 0x11:
522	/* Suspended account */
523	imcb_error(ic, _("Your account is currently suspended."));
524	break;
525	case 0x18:
526	/* connecting too frequently */
527	od->no_reconnect = TRUE;
528	imcb_error(ic, _("You have been connecting and disconnecting too frequently. Wait ten minutes and try again. If you continue to try, you will need to wait even longer."));
529	break;
530	case 0x1c:
531	/* client too old */
532	imcb_error(ic, _("The client version you are using is too old. Please upgrade at " WEBSITE));
533	break;
534	default:
535	imcb_error(ic, _("Authentication Failed"));
536	break;
537	}
538	od->killme = TRUE;
539	return 1;
540	}
541
542
543	aim_conn_kill(sess, &fr->conn);
544
545	bosconn = aim_newconn(sess, AIM_CONN_TYPE_BOS, NULL);
546	if (bosconn == NULL) {
547	imcb_error(ic, _("Internal Error"));
548	od->killme = TRUE;
549	return 0;
550	}
551
552	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNINITDONE, conninitdone_bos, 0);
553	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_BOS, AIM_CB_BOS_RIGHTS, gaim_bosrights, 0);
554	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_ACK, AIM_CB_ACK_ACK, NULL, 0);
555	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_GEN, AIM_CB_GEN_REDIRECT, gaim_handle_redirect, 0);
556	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_LOC, AIM_CB_LOC_RIGHTSINFO, gaim_parse_locaterights, 0);
557	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_BUD, AIM_CB_BUD_RIGHTSINFO, gaim_parse_buddyrights, 0);
558	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_BUD, AIM_CB_BUD_ONCOMING, gaim_parse_oncoming, 0);
559	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_BUD, AIM_CB_BUD_OFFGOING, gaim_parse_offgoing, 0);
560	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_MSG, AIM_CB_MSG_INCOMING, gaim_parse_incoming_im, 0);
561	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_LOC, AIM_CB_LOC_ERROR, gaim_parse_locerr, 0);
562	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_MSG, AIM_CB_MSG_MISSEDCALL, gaim_parse_misses, 0);
563	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_GEN, AIM_CB_GEN_RATECHANGE, gaim_parse_ratechange, 0);
564	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_MSG, AIM_CB_MSG_ERROR, gaim_parse_msgerr, 0);
565	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_GEN, AIM_CB_GEN_MOTD, gaim_parse_motd, 0);
566	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_MSG, AIM_CB_MSG_PARAMINFO, gaim_icbm_param_info, 0);
567	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_GEN, AIM_CB_GEN_ERROR, gaim_parse_genericerr, 0);
568	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_BUD, AIM_CB_BUD_ERROR, gaim_parse_genericerr, 0);
569	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_BOS, AIM_CB_BOS_ERROR, gaim_parse_genericerr, 0);
570	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_GEN, AIM_CB_GEN_SELFINFO, gaim_selfinfo, 0);
571	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_ICQ, AIM_CB_ICQ_OFFLINEMSG, gaim_offlinemsg, 0);
572	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_ICQ, AIM_CB_ICQ_OFFLINEMSGCOMPLETE, gaim_offlinemsgdone, 0);
573	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_ICQ, AIM_CB_ICQ_INFO, gaim_icqinfo, 0);
574	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_SSI, AIM_CB_SSI_RIGHTSINFO, gaim_ssi_parserights, 0);
575	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_SSI, AIM_CB_SSI_LIST, gaim_ssi_parselist, 0);
576	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_SSI, AIM_CB_SSI_SRVACK, gaim_ssi_parseack, 0);
577	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_LOC, AIM_CB_LOC_USERINFO, gaim_parseaiminfo, 0);
578	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_MSG, AIM_CB_MSG_MTN, gaim_parsemtn, 0);
579	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNERR, gaim_parse_logout, 0);
580
581	((struct oscar_data *)ic->proto_data)->conn = bosconn;
582	for (i = 0; i < (int)strlen(info->bosip); i++) {
583	if (info->bosip[i] == ':') {
584	port = atoi(&(info->bosip[i+1]));
585	break;
586	}
587	}
588	host = g_strndup(info->bosip, i);
589	bosconn->status \|= AIM_CONN_STATUS_INPROGRESS;
590	bosconn->fd = proxy_connect(host, port, oscar_bos_connect, ic);
591	g_free(host);
592	if (bosconn->fd < 0) {
593	imcb_error(ic, _("Could Not Connect"));
594	od->killme = TRUE;
595	return 0;
596	}
597	aim_sendcookie(sess, bosconn, info->cookie);
598	b_event_remove(ic->inpa);
599
600	return 1;
601	}
602
603	/* size of icbmui.ocm, the largest module in AIM 3.5 */
604	#define AIM_MAX_FILE_SIZE 98304
605
606	static int gaim_parse_login(aim_session_t sess, aim_frame_t fr, ...) {
607	#if 0
608	struct client_info_s info = {"gaim", 4, 1, 2010, "us", "en", 0x0004, 0x0000, 0x04b};
609	#else
610	struct client_info_s info = AIM_CLIENTINFO_KNOWNGOOD;
611	#endif
612	char *key;
613	va_list ap;
614	struct im_connection *ic = sess->aux_data;
615
616	va_start(ap, fr);
617	key = va_arg(ap, char *);
618	va_end(ap);
619
620	aim_send_login(sess, fr->conn, ic->acc->user, ic->acc->pass, &info, key);
621
622	return 1;
623	}
624
625	static int gaim_parse_logout(aim_session_t sess, aim_frame_t fr, ...) {
626	struct im_connection *ic = sess->aux_data;
627	struct oscar_data *odata = ic->proto_data;
628	int code;
629	va_list ap;
630
631	va_start(ap, fr);
632	code = va_arg(ap, int);
633	va_end(ap);
634
635	imcb_error( ic, "Connection aborted by server: %s", code == 1 ?
636	"someone else logged in with your account" :
637	"unknown reason" );
638
639	/* Tell BitlBee to disable auto_reconnect if code == 1, since that
640	means a concurrent login somewhere else. */
641	odata->no_reconnect = code == 1;
642
643	/* DO NOT log out here! Just tell the callback to do it. */
644	odata->killme = TRUE;
645
646	return 1;
647	}
648
649	static int conninitdone_chat(aim_session_t sess, aim_frame_t fr, ...) {
650	struct im_connection *ic = sess->aux_data;
651	struct chat_connection *chatcon;
652	struct groupchat *c = NULL;
653	static int id = 1;
654
655	aim_conn_addhandler(sess, fr->conn, 0x000e, 0x0001, gaim_parse_genericerr, 0);
656	aim_conn_addhandler(sess, fr->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_USERJOIN, gaim_chat_join, 0);
657	aim_conn_addhandler(sess, fr->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_USERLEAVE, gaim_chat_leave, 0);
658	aim_conn_addhandler(sess, fr->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_ROOMINFOUPDATE, gaim_chat_info_update, 0);
659	aim_conn_addhandler(sess, fr->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_INCOMINGMSG, gaim_chat_incoming_msg, 0);
660
661	aim_clientready(sess, fr->conn);
662
663	chatcon = find_oscar_chat_by_conn(ic, fr->conn);
664	chatcon->id = id;
665
666	c = bee_chat_by_title(ic->bee, ic, chatcon->show);
667	if (c && !c->data)
668	chatcon->cnv = c;
669	else
670	chatcon->cnv = imcb_chat_new(ic, chatcon->show);
671	chatcon->cnv->data = chatcon;
672
673	return 1;
674	}
675
676	static int conninitdone_chatnav(aim_session_t sess, aim_frame_t fr, ...) {
677
678	aim_conn_addhandler(sess, fr->conn, AIM_CB_FAM_CTN, AIM_CB_CTN_ERROR, gaim_parse_genericerr, 0);
679	aim_conn_addhandler(sess, fr->conn, AIM_CB_FAM_CTN, AIM_CB_CTN_INFO, gaim_chatnav_info, 0);
680
681	aim_clientready(sess, fr->conn);
682
683	aim_chatnav_reqrights(sess, fr->conn);
684
685	return 1;
686	}
687
688	static gboolean oscar_chatnav_connect(gpointer data, gint source, b_input_condition cond) {
689	struct im_connection *ic = data;
690	struct oscar_data *odata;
691	aim_session_t *sess;
692	aim_conn_t *tstconn;
693
694	if (!g_slist_find(get_connections(), ic)) {
695	closesocket(source);
696	return FALSE;
697	}
698
699	odata = ic->proto_data;
700	sess = odata->sess;
701	tstconn = aim_getconn_type_all(sess, AIM_CONN_TYPE_CHATNAV);
702
703	if (source < 0) {
704	aim_conn_kill(sess, &tstconn);
705	return FALSE;
706	}
707
708	aim_conn_completeconnect(sess, tstconn);
709	odata->cnpa = b_input_add(tstconn->fd, B_EV_IO_READ,
710	oscar_callback, tstconn);
711
712	return FALSE;
713	}
714
715	static gboolean oscar_auth_connect(gpointer data, gint source, b_input_condition cond)
716	{
717	struct im_connection *ic = data;
718	struct oscar_data *odata;
719	aim_session_t *sess;
720	aim_conn_t *tstconn;
721
722	if (!g_slist_find(get_connections(), ic)) {
723	closesocket(source);
724	return FALSE;
725	}
726
727	odata = ic->proto_data;
728	sess = odata->sess;
729	tstconn = aim_getconn_type_all(sess, AIM_CONN_TYPE_AUTH);
730
731	if (source < 0) {
732	aim_conn_kill(sess, &tstconn);
733	return FALSE;
734	}
735
736	aim_conn_completeconnect(sess, tstconn);
737	odata->paspa = b_input_add(tstconn->fd, B_EV_IO_READ,
738	oscar_callback, tstconn);
739
740	return FALSE;
741	}
742
743	static gboolean oscar_chat_connect(gpointer data, gint source, b_input_condition cond)
744	{
745	struct chat_connection *ccon = data;
746	struct im_connection *ic = ccon->ic;
747	struct oscar_data *odata;
748	aim_session_t *sess;
749	aim_conn_t *tstconn;
750
751	if (!g_slist_find(get_connections(), ic)) {
752	closesocket(source);
753	g_free(ccon->show);
754	g_free(ccon->name);
755	g_free(ccon);
756	return FALSE;
757	}
758
759	odata = ic->proto_data;
760	sess = odata->sess;
761	tstconn = ccon->conn;
762
763	if (source < 0) {
764	aim_conn_kill(sess, &tstconn);
765	g_free(ccon->show);
766	g_free(ccon->name);
767	g_free(ccon);
768	return FALSE;
769	}
770
771	aim_conn_completeconnect(sess, ccon->conn);
772	ccon->inpa = b_input_add(tstconn->fd,
773	B_EV_IO_READ,
774	oscar_callback, tstconn);
775	odata->oscar_chats = g_slist_append(odata->oscar_chats, ccon);
776
777	return FALSE;
778	}
779
780	/* Hrmph. I don't know how to make this look better. --mid */
781	static int gaim_handle_redirect(aim_session_t sess, aim_frame_t fr, ...) {
782	va_list ap;
783	struct aim_redirect_data *redir;
784	struct im_connection *ic = sess->aux_data;
785	aim_conn_t *tstconn;
786	int i;
787	char *host;
788	int port;
789
790	va_start(ap, fr);
791	redir = va_arg(ap, struct aim_redirect_data *);
792	va_end(ap);
793
794	port = AIM_LOGIN_PORT;
795	for (i = 0; i < (int)strlen(redir->ip); i++) {
796	if (redir->ip[i] == ':') {
797	port = atoi(&(redir->ip[i+1]));
798	break;
799	}
800	}
801	host = g_strndup(redir->ip, i);
802
803	switch(redir->group) {
804	case 0x7: /* Authorizer */
805	tstconn = aim_newconn(sess, AIM_CONN_TYPE_AUTH, NULL);
806	if (tstconn == NULL) {
807	g_free(host);
808	return 1;
809	}
810	aim_conn_addhandler(sess, tstconn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNINITDONE, conninitdone_admin, 0);
811	// aim_conn_addhandler(sess, tstconn, 0x0007, 0x0003, gaim_info_change, 0);
812	// aim_conn_addhandler(sess, tstconn, 0x0007, 0x0005, gaim_info_change, 0);
813	// aim_conn_addhandler(sess, tstconn, 0x0007, 0x0007, gaim_account_confirm, 0);
814
815	tstconn->status \|= AIM_CONN_STATUS_INPROGRESS;
816	tstconn->fd = proxy_connect(host, port, oscar_auth_connect, ic);
817	if (tstconn->fd < 0) {
818	aim_conn_kill(sess, &tstconn);
819	g_free(host);
820	return 1;
821	}
822	aim_sendcookie(sess, tstconn, redir->cookie);
823	break;
824	case 0xd: /* ChatNav */
825	tstconn = aim_newconn(sess, AIM_CONN_TYPE_CHATNAV, NULL);
826	if (tstconn == NULL) {
827	g_free(host);
828	return 1;
829	}
830	aim_conn_addhandler(sess, tstconn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNINITDONE, conninitdone_chatnav, 0);
831
832	tstconn->status \|= AIM_CONN_STATUS_INPROGRESS;
833	tstconn->fd = proxy_connect(host, port, oscar_chatnav_connect, ic);
834	if (tstconn->fd < 0) {
835	aim_conn_kill(sess, &tstconn);
836	g_free(host);
837	return 1;
838	}
839	aim_sendcookie(sess, tstconn, redir->cookie);
840	break;
841	case 0xe: /* Chat */
842	{
843	struct chat_connection *ccon;
844
845	tstconn = aim_newconn(sess, AIM_CONN_TYPE_CHAT, NULL);
846	if (tstconn == NULL) {
847	g_free(host);
848	return 1;
849	}
850
851	aim_conn_addhandler(sess, tstconn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNINITDONE, conninitdone_chat, 0);
852
853	ccon = g_new0(struct chat_connection, 1);
854	ccon->conn = tstconn;
855	ccon->ic = ic;
856	ccon->fd = -1;
857	ccon->name = g_strdup(redir->chat.room);
858	ccon->exchange = redir->chat.exchange;
859	ccon->instance = redir->chat.instance;
860	ccon->show = extract_name(redir->chat.room);
861
862	ccon->conn->status \|= AIM_CONN_STATUS_INPROGRESS;
863	ccon->conn->fd = proxy_connect(host, port, oscar_chat_connect, ccon);
864	if (ccon->conn->fd < 0) {
865	aim_conn_kill(sess, &tstconn);
866	g_free(host);
867	g_free(ccon->show);
868	g_free(ccon->name);
869	g_free(ccon);
870	return 1;
871	}
872	aim_sendcookie(sess, tstconn, redir->cookie);
873	}
874	break;
875	default: /* huh? */
876	break;
877	}
878
879	g_free(host);
880	return 1;
881	}
882
883	static int gaim_parse_oncoming(aim_session_t sess, aim_frame_t fr, ...) {
884	struct im_connection *ic = sess->aux_data;
885	struct oscar_data *od = ic->proto_data;
886	aim_userinfo_t *info;
887	time_t time_idle = 0, signon = 0;
888	int flags = OPT_LOGGED_IN;
889	char tmp, state_string = NULL;
890
891	va_list ap;
892	va_start(ap, fr);
893	info = va_arg(ap, aim_userinfo_t *);
894	va_end(ap);
895
896	if ((!od->icq) && (info->present & AIM_USERINFO_PRESENT_FLAGS)) {
897	if (info->flags & AIM_FLAG_AWAY)
898	flags \|= OPT_AWAY;
899	}
900
901	if (info->present & AIM_USERINFO_PRESENT_ICQEXTSTATUS) {
902	if (!(info->icqinfo.status & AIM_ICQ_STATE_CHAT) &&
903	(info->icqinfo.status != AIM_ICQ_STATE_NORMAL)) {
904	flags \|= OPT_AWAY;
905	}
906
907	if( info->icqinfo.status & AIM_ICQ_STATE_DND )
908	state_string = "Do Not Disturb";
909	else if( info->icqinfo.status & AIM_ICQ_STATE_OUT )
910	state_string = "Not Available";
911	else if( info->icqinfo.status & AIM_ICQ_STATE_BUSY )
912	state_string = "Occupied";
913	else if( info->icqinfo.status & AIM_ICQ_STATE_INVISIBLE )
914	state_string = "Invisible";
915	}
916
917	if (info->present & AIM_USERINFO_PRESENT_IDLE) {
918	time(&time_idle);
919	time_idle -= info->idletime*60;
920	}
921
922	if (info->present & AIM_USERINFO_PRESENT_SESSIONLEN)
923	signon = time(NULL) - info->sessionlen;
924
925	if (info->present & AIM_USERINFO_PRESENT_ICQIPADDR) {
926	uint32_t *uin = g_new0(uint32_t, 1);
927
928	if (od->ips == NULL)
929	od->ips = g_hash_table_new_full(g_int_hash, g_int_equal, g_free, NULL);
930
931	if (sscanf(info->sn, "%d", uin) == 1)
932	g_hash_table_insert(od->ips, uin, (gpointer) (long) info->icqinfo.ipaddr);
933	}
934
935	if (!aim_sncmp(ic->acc->user, info->sn))
936	g_snprintf(ic->displayname, sizeof(ic->displayname), "%s", info->sn);
937
938	tmp = normalize(info->sn);
939	imcb_buddy_status(ic, tmp, flags, state_string, NULL);
940	imcb_buddy_times(ic, tmp, signon, time_idle);
941
942
943	return 1;
944	}
945
946	static int gaim_parse_offgoing(aim_session_t sess, aim_frame_t fr, ...) {
947	aim_userinfo_t *info;
948	va_list ap;
949	struct im_connection *ic = sess->aux_data;
950
951	va_start(ap, fr);
952	info = va_arg(ap, aim_userinfo_t *);
953	va_end(ap);
954
955	imcb_buddy_status(ic, normalize(info->sn), 0, NULL, NULL );
956
957	return 1;
958	}
959
960	static int incomingim_chan1(aim_session_t sess, aim_conn_t conn, aim_userinfo_t userinfo, struct aim_incomingim_ch1_args args) {
961	char *tmp = g_malloc(BUF_LONG + 1);
962	struct im_connection *ic = sess->aux_data;
963	int flags = 0;
964
965	if (args->icbmflags & AIM_IMFLAGS_AWAY)
966	flags \|= OPT_AWAY;
967
968	if ((args->icbmflags & AIM_IMFLAGS_UNICODE) \|\| (args->icbmflags & AIM_IMFLAGS_ISO_8859_1)) {
969	char *src;
970
971	if (args->icbmflags & AIM_IMFLAGS_UNICODE)
972	src = "UNICODEBIG";
973	else
974	src = "ISO8859-1";
975
976	/* Try to use iconv first to convert the message to UTF8 - which is what BitlBee expects */
977	if (do_iconv(src, "UTF-8", args->msg, tmp, args->msglen, BUF_LONG) >= 0) {
978	// Successfully converted!
979	} else if (args->icbmflags & AIM_IMFLAGS_UNICODE) {
980	int i;
981
982	for (i = 0, tmp[0] = '\0'; i < args->msglen; i += 2) {
983	unsigned short uni;
984
985	uni = ((args->msg[i] & 0xff) << 8) \| (args->msg[i+1] & 0xff);
986
987	if ((uni < 128) \|\| ((uni >= 160) && (uni <= 255))) { /* ISO 8859-1 */
988	g_snprintf(tmp+strlen(tmp), BUF_LONG-strlen(tmp), "%c", uni);
989	} else { /* something else, do UNICODE entity */
990	g_snprintf(tmp+strlen(tmp), BUF_LONG-strlen(tmp), "&#%04x;", uni);
991	}
992	}
993	} else {
994	g_snprintf(tmp, BUF_LONG, "%s", args->msg);
995	}
996	} else if (args->mpmsg.numparts == 0) {
997	g_snprintf(tmp, BUF_LONG, "%s", args->msg);
998	} else {
999	aim_mpmsg_section_t *part;
1000
1001	*tmp = 0;
1002	for (part = args->mpmsg.parts; part; part = part->next) {
1003	if (part->data) {
1004	g_strlcat(tmp, (char*) part->data, BUF_LONG);
1005	g_strlcat(tmp, "\n", BUF_LONG);
1006	}
1007	}
1008	}
1009
1010	strip_linefeed(tmp);
1011	imcb_buddy_msg(ic, normalize(userinfo->sn), tmp, flags, 0);
1012	g_free(tmp);
1013
1014	return 1;
1015	}
1016
1017	void oscar_accept_chat(void *data);
1018	void oscar_reject_chat(void *data);
1019
1020	static int incomingim_chan2(aim_session_t sess, aim_conn_t conn, aim_userinfo_t userinfo, struct aim_incomingim_ch2_args args) {
1021	struct im_connection *ic = sess->aux_data;
1022
1023	if (args->status != AIM_RENDEZVOUS_PROPOSE)
1024	return 1;
1025
1026	if (args->reqclass & AIM_CAPS_CHAT) {
1027	char *name = extract_name(args->info.chat.roominfo.name);
1028	int *exch = g_new0(int, 1);
1029	GList *m = NULL;
1030	char txt[1024];
1031	struct aim_chat_invitation * inv = g_new0(struct aim_chat_invitation, 1);
1032
1033	m = g_list_append(m, g_strdup(name ? name : args->info.chat.roominfo.name));
1034	*exch = args->info.chat.roominfo.exchange;
1035	m = g_list_append(m, exch);
1036
1037	g_snprintf(txt, 1024, "Got an invitation to chatroom %s from %s: %s", name, userinfo->sn, args->msg);
1038
1039	inv->ic = ic;
1040	inv->exchange = *exch;
1041	inv->name = g_strdup(name);
1042
1043	imcb_ask(ic, txt, inv, oscar_accept_chat, oscar_reject_chat);
1044
1045	if (name)
1046	g_free(name);
1047	} else if (args->reqclass & AIM_CAPS_ICQRTF) {
1048	// TODO: constify
1049	char text[strlen(args->info.rtfmsg.rtfmsg)+1];
1050	strncpy(text, args->info.rtfmsg.rtfmsg, sizeof(text));
1051	imcb_buddy_msg(ic, normalize(userinfo->sn), text, 0, 0);
1052	}
1053
1054	return 1;
1055	}
1056
1057	static void gaim_icq_authgrant(void *data_) {
1058	struct icq_auth *data = data_;
1059	char *uin, message;
1060	struct oscar_data od = (struct oscar_data )data->ic->proto_data;
1061
1062	uin = g_strdup_printf("%u", data->uin);
1063	message = 0;
1064	aim_ssi_auth_reply(od->sess, od->conn, uin, 1, "");
1065	// aim_send_im_ch4(od->sess, uin, AIM_ICQMSG_AUTHGRANTED, &message);
1066	imcb_ask_add(data->ic, uin, NULL);
1067
1068	g_free(uin);
1069	g_free(data);
1070	}
1071
1072	static void gaim_icq_authdeny(void *data_) {
1073	struct icq_auth *data = data_;
1074	char uin, message;
1075	struct oscar_data od = (struct oscar_data )data->ic->proto_data;
1076
1077	uin = g_strdup_printf("%u", data->uin);
1078	message = g_strdup_printf("No reason given.");
1079	aim_ssi_auth_reply(od->sess, od->conn, uin, 0, "");
1080	// aim_send_im_ch4(od->sess, uin, AIM_ICQMSG_AUTHDENIED, message);
1081	g_free(message);
1082
1083	g_free(uin);
1084	g_free(data);
1085	}
1086
1087	/*
1088	* For when other people ask you for authorization
1089	*/
1090	static void gaim_icq_authask(struct im_connection ic, guint32 uin, char msg) {
1091	struct icq_auth *data;
1092	char *reason = NULL;
1093	char *dialog_msg;
1094
1095	if (set_getbool(&ic->acc->set, "ignore_auth_requests"))
1096	return;
1097
1098	data = g_new(struct icq_auth, 1);
1099
1100	if (strlen(msg) > 6)
1101	reason = msg + 6;
1102
1103	dialog_msg = g_strdup_printf("The user %u wants to add you to their buddy list for the following reason: %s", uin, reason ? reason : "No reason given.");
1104	data->ic = ic;
1105	data->uin = uin;
1106	imcb_ask(ic, dialog_msg, data, gaim_icq_authgrant, gaim_icq_authdeny);
1107	g_free(dialog_msg);
1108	}
1109
1110	static int incomingim_chan4(aim_session_t sess, aim_conn_t conn, aim_userinfo_t userinfo, struct aim_incomingim_ch4_args args) {
1111	struct im_connection *ic = sess->aux_data;
1112
1113	switch (args->type) {
1114	case 0x0001: { /* An almost-normal instant message. Mac ICQ sends this. It's peculiar. */
1115	char uin, message;
1116	uin = g_strdup_printf("%u", args->uin);
1117	message = g_strdup(args->msg);
1118	strip_linefeed(message);
1119	imcb_buddy_msg(ic, normalize(uin), message, 0, 0);
1120	g_free(uin);
1121	g_free(message);
1122	} break;
1123
1124	case 0x0004: { /* Someone sent you a URL */
1125	char uin, message;
1126	char **m;
1127
1128	uin = g_strdup_printf("%u", args->uin);
1129	m = g_strsplit(args->msg, "\376", 2);
1130
1131	if ((strlen(m[0]) != 0)) {
1132	message = g_strjoinv(" -- ", m);
1133	} else {
1134	message = m[1];
1135	}
1136
1137	strip_linefeed(message);
1138	imcb_buddy_msg(ic, normalize(uin), message, 0, 0);
1139	g_free(uin);
1140	g_free(m);
1141	g_free(message);
1142	} break;
1143
1144	case 0x0006: { /* Someone requested authorization */
1145	gaim_icq_authask(ic, args->uin, args->msg);
1146	} break;
1147
1148	case 0x0007: { /* Someone has denied you authorization */
1149	imcb_log(sess->aux_data, "The user %u has denied your request to add them to your contact list for the following reason:\n%s", args->uin, args->msg ? args->msg : _("No reason given.") );
1150	} break;
1151
1152	case 0x0008: { /* Someone has granted you authorization */
1153	imcb_log(sess->aux_data, "The user %u has granted your request to add them to your contact list for the following reason:\n%s", args->uin, args->msg ? args->msg : _("No reason given.") );
1154	} break;
1155
1156	case 0x0012: {
1157	/* Ack for authorizing/denying someone. Or possibly an ack for sending any system notice */
1158	} break;
1159
1160	default: {;
1161	} break;
1162	}
1163
1164	return 1;
1165	}
1166
1167	static int gaim_parse_incoming_im(aim_session_t sess, aim_frame_t fr, ...) {
1168	int channel, ret = 0;
1169	aim_userinfo_t *userinfo;
1170	va_list ap;
1171
1172	va_start(ap, fr);
1173	channel = va_arg(ap, int);
1174	userinfo = va_arg(ap, aim_userinfo_t *);
1175
1176	switch (channel) {
1177	case 1: { /* standard message */
1178	struct aim_incomingim_ch1_args *args;
1179	args = va_arg(ap, struct aim_incomingim_ch1_args *);
1180	ret = incomingim_chan1(sess, fr->conn, userinfo, args);
1181	} break;
1182
1183	case 2: { /* rendevous */
1184	struct aim_incomingim_ch2_args *args;
1185	args = va_arg(ap, struct aim_incomingim_ch2_args *);
1186	ret = incomingim_chan2(sess, fr->conn, userinfo, args);
1187	} break;
1188
1189	case 4: { /* ICQ */
1190	struct aim_incomingim_ch4_args *args;
1191	args = va_arg(ap, struct aim_incomingim_ch4_args *);
1192	ret = incomingim_chan4(sess, fr->conn, userinfo, args);
1193	} break;
1194
1195	default: {;
1196	} break;
1197	}
1198
1199	va_end(ap);
1200
1201	return ret;
1202	}
1203
1204	static int gaim_parse_misses(aim_session_t sess, aim_frame_t fr, ...) {
1205	va_list ap;
1206	guint16 chan, nummissed, reason;
1207	aim_userinfo_t *userinfo;
1208
1209	va_start(ap, fr);
1210	chan = (guint16)va_arg(ap, unsigned int);
1211	userinfo = va_arg(ap, aim_userinfo_t *);
1212	nummissed = (guint16)va_arg(ap, unsigned int);
1213	reason = (guint16)va_arg(ap, unsigned int);
1214	va_end(ap);
1215
1216	switch(reason) {
1217	case 0:
1218	/* Invalid (0) */
1219	imcb_error(sess->aux_data,
1220	nummissed == 1 ?
1221	_("You missed %d message from %s because it was invalid.") :
1222	_("You missed %d messages from %s because they were invalid."),
1223	nummissed,
1224	userinfo->sn);
1225	break;
1226	case 1:
1227	/* Message too large */
1228	imcb_error(sess->aux_data,
1229	nummissed == 1 ?
1230	_("You missed %d message from %s because it was too large.") :
1231	_("You missed %d messages from %s because they were too large."),
1232	nummissed,
1233	userinfo->sn);
1234	break;
1235	case 2:
1236	/* Rate exceeded */
1237	imcb_error(sess->aux_data,
1238	nummissed == 1 ?
1239	_("You missed %d message from %s because the rate limit has been exceeded.") :
1240	_("You missed %d messages from %s because the rate limit has been exceeded."),
1241	nummissed,
1242	userinfo->sn);
1243	break;
1244	case 3:
1245	/* Evil Sender */
1246	imcb_error(sess->aux_data,
1247	nummissed == 1 ?
1248	_("You missed %d message from %s because it was too evil.") :
1249	_("You missed %d messages from %s because they are too evil."),
1250	nummissed,
1251	userinfo->sn);
1252	break;
1253	case 4:
1254	/* Evil Receiver */
1255	imcb_error(sess->aux_data,
1256	nummissed == 1 ?
1257	_("You missed %d message from %s because you are too evil.") :
1258	_("You missed %d messages from %s because you are too evil."),
1259	nummissed,
1260	userinfo->sn);
1261	break;
1262	default:
1263	imcb_error(sess->aux_data,
1264	nummissed == 1 ?
1265	_("You missed %d message from %s for unknown reasons.") :
1266	_("You missed %d messages from %s for unknown reasons."),
1267	nummissed,
1268	userinfo->sn);
1269	break;
1270	}
1271
1272	return 1;
1273	}
1274
1275	static int gaim_parse_genericerr(aim_session_t sess, aim_frame_t fr, ...) {
1276	va_list ap;
1277	guint16 reason;
1278
1279	va_start(ap, fr);
1280	reason = (guint16)va_arg(ap, unsigned int);
1281	va_end(ap);
1282
1283	imcb_error(sess->aux_data, _("SNAC threw error: %s"),
1284	reason < msgerrreasonlen ? msgerrreason[reason] : "Unknown error");
1285
1286	return 1;
1287	}
1288
1289	static int gaim_parse_msgerr(aim_session_t sess, aim_frame_t fr, ...) {
1290	va_list ap;
1291	char *destn;
1292	guint16 reason;
1293
1294	va_start(ap, fr);
1295	reason = (guint16)va_arg(ap, unsigned int);
1296	destn = va_arg(ap, char *);
1297	va_end(ap);
1298
1299	imcb_error(sess->aux_data, _("Your message to %s did not get sent: %s"), destn,
1300	(reason < msgerrreasonlen) ? msgerrreason[reason] : _("Reason unknown"));
1301
1302	return 1;
1303	}
1304
1305	static int gaim_parse_locerr(aim_session_t sess, aim_frame_t fr, ...) {
1306	va_list ap;
1307	char *destn;
1308	guint16 reason;
1309
1310	va_start(ap, fr);
1311	reason = (guint16)va_arg(ap, unsigned int);
1312	destn = va_arg(ap, char *);
1313	va_end(ap);
1314
1315	imcb_error(sess->aux_data, _("User information for %s unavailable: %s"), destn,
1316	(reason < msgerrreasonlen) ? msgerrreason[reason] : _("Reason unknown"));
1317
1318	return 1;
1319	}
1320
1321	static int gaim_parse_motd(aim_session_t sess, aim_frame_t fr, ...) {
1322	char *msg;
1323	guint16 id;
1324	va_list ap;
1325
1326	va_start(ap, fr);
1327	id = (guint16)va_arg(ap, unsigned int);
1328	msg = va_arg(ap, char *);
1329	va_end(ap);
1330
1331	if (id < 4)
1332	imcb_error(sess->aux_data, _("Your connection may be lost."));
1333
1334	return 1;
1335	}
1336
1337	static int gaim_chatnav_info(aim_session_t sess, aim_frame_t fr, ...) {
1338	va_list ap;
1339	guint16 type;
1340	struct im_connection *ic = sess->aux_data;
1341	struct oscar_data odata = (struct oscar_data )ic->proto_data;
1342
1343	va_start(ap, fr);
1344	type = (guint16)va_arg(ap, unsigned int);
1345
1346	switch(type) {
1347	case 0x0002: {
1348	guint8 maxrooms;
1349	struct aim_chat_exchangeinfo *exchanges;
1350	int exchangecount; // i;
1351
1352	maxrooms = (guint8)va_arg(ap, unsigned int);
1353	exchangecount = va_arg(ap, int);
1354	exchanges = va_arg(ap, struct aim_chat_exchangeinfo *);
1355	va_end(ap);
1356
1357	while (odata->create_rooms) {
1358	struct create_room *cr = odata->create_rooms->data;
1359	aim_chatnav_createroom(sess, fr->conn, cr->name, cr->exchange);
1360	g_free(cr->name);
1361	odata->create_rooms = g_slist_remove(odata->create_rooms, cr);
1362	g_free(cr);
1363	}
1364	}
1365	break;
1366	case 0x0008: {
1367	char fqcn, name, *ck;
1368	guint16 instance, flags, maxmsglen, maxoccupancy, unknown, exchange;
1369	guint8 createperms;
1370	guint32 createtime;
1371
1372	fqcn = va_arg(ap, char *);
1373	instance = (guint16)va_arg(ap, unsigned int);
1374	exchange = (guint16)va_arg(ap, unsigned int);
1375	flags = (guint16)va_arg(ap, unsigned int);
1376	createtime = va_arg(ap, guint32);
1377	maxmsglen = (guint16)va_arg(ap, unsigned int);
1378	maxoccupancy = (guint16)va_arg(ap, unsigned int);
1379	createperms = (guint8)va_arg(ap, int);
1380	unknown = (guint16)va_arg(ap, unsigned int);
1381	name = va_arg(ap, char *);
1382	ck = va_arg(ap, char *);
1383	va_end(ap);
1384
1385	aim_chat_join(odata->sess, odata->conn, exchange, ck, instance);
1386	}
1387	break;
1388	default:
1389	va_end(ap);
1390	break;
1391	}
1392	return 1;
1393	}
1394
1395	static int gaim_chat_join(aim_session_t sess, aim_frame_t fr, ...) {
1396	va_list ap;
1397	int count, i;
1398	aim_userinfo_t *info;
1399	struct im_connection *g = sess->aux_data;
1400
1401	struct chat_connection *c = NULL;
1402
1403	va_start(ap, fr);
1404	count = va_arg(ap, int);
1405	info = va_arg(ap, aim_userinfo_t *);
1406	va_end(ap);
1407
1408	c = find_oscar_chat_by_conn(g, fr->conn);
1409	if (!c)
1410	return 1;
1411
1412	for (i = 0; i < count; i++)
1413	imcb_chat_add_buddy(c->cnv, normalize(info[i].sn));
1414
1415	return 1;
1416	}
1417
1418	static int gaim_chat_leave(aim_session_t sess, aim_frame_t fr, ...) {
1419	va_list ap;
1420	int count, i;
1421	aim_userinfo_t *info;
1422	struct im_connection *g = sess->aux_data;
1423
1424	struct chat_connection *c = NULL;
1425
1426	va_start(ap, fr);
1427	count = va_arg(ap, int);
1428	info = va_arg(ap, aim_userinfo_t *);
1429	va_end(ap);
1430
1431	c = find_oscar_chat_by_conn(g, fr->conn);
1432	if (!c)
1433	return 1;
1434
1435	for (i = 0; i < count; i++)
1436	imcb_chat_remove_buddy(c->cnv, normalize(info[i].sn), NULL);
1437
1438	return 1;
1439	}
1440
1441	static int gaim_chat_info_update(aim_session_t sess, aim_frame_t fr, ...) {
1442	va_list ap;
1443	aim_userinfo_t *userinfo;
1444	struct aim_chat_roominfo *roominfo;
1445	char *roomname;
1446	int usercount;
1447	char *roomdesc;
1448	guint16 unknown_c9, unknown_d2, unknown_d5, maxmsglen, maxvisiblemsglen;
1449	guint32 creationtime;
1450	struct im_connection *ic = sess->aux_data;
1451	struct chat_connection *ccon = find_oscar_chat_by_conn(ic, fr->conn);
1452
1453	va_start(ap, fr);
1454	roominfo = va_arg(ap, struct aim_chat_roominfo *);
1455	roomname = va_arg(ap, char *);
1456	usercount= va_arg(ap, int);
1457	userinfo = va_arg(ap, aim_userinfo_t *);
1458	roomdesc = va_arg(ap, char *);
1459	unknown_c9 = (guint16)va_arg(ap, int);
1460	creationtime = (guint32)va_arg(ap, unsigned long);
1461	maxmsglen = (guint16)va_arg(ap, int);
1462	unknown_d2 = (guint16)va_arg(ap, int);
1463	unknown_d5 = (guint16)va_arg(ap, int);
1464	maxvisiblemsglen = (guint16)va_arg(ap, int);
1465	va_end(ap);
1466
1467	ccon->maxlen = maxmsglen;
1468	ccon->maxvis = maxvisiblemsglen;
1469
1470	return 1;
1471	}
1472
1473	static int gaim_chat_incoming_msg(aim_session_t sess, aim_frame_t fr, ...) {
1474	va_list ap;
1475	aim_userinfo_t *info;
1476	char *msg;
1477	struct im_connection *ic = sess->aux_data;
1478	struct chat_connection *ccon = find_oscar_chat_by_conn(ic, fr->conn);
1479	char *tmp;
1480
1481	va_start(ap, fr);
1482	info = va_arg(ap, aim_userinfo_t *);
1483	msg = va_arg(ap, char *);
1484
1485	tmp = g_malloc(BUF_LONG);
1486	g_snprintf(tmp, BUF_LONG, "%s", msg);
1487	imcb_chat_msg(ccon->cnv, normalize(info->sn), tmp, 0, 0);
1488	g_free(tmp);
1489
1490	return 1;
1491	}
1492
1493	static int gaim_parse_ratechange(aim_session_t sess, aim_frame_t fr, ...) {
1494	#if 0
1495	static const char *codes[5] = {
1496	"invalid",
1497	"change",
1498	"warning",
1499	"limit",
1500	"limit cleared",
1501	};
1502	#endif
1503	va_list ap;
1504	guint16 code, rateclass;
1505	guint32 windowsize, clear, alert, limit, disconnect, currentavg, maxavg;
1506
1507	va_start(ap, fr);
1508	code = (guint16)va_arg(ap, unsigned int);
1509	rateclass= (guint16)va_arg(ap, unsigned int);
1510	windowsize = (guint32)va_arg(ap, unsigned long);
1511	clear = (guint32)va_arg(ap, unsigned long);
1512	alert = (guint32)va_arg(ap, unsigned long);
1513	limit = (guint32)va_arg(ap, unsigned long);
1514	disconnect = (guint32)va_arg(ap, unsigned long);
1515	currentavg = (guint32)va_arg(ap, unsigned long);
1516	maxavg = (guint32)va_arg(ap, unsigned long);
1517	va_end(ap);
1518
1519	/* XXX fix these values */
1520	if (code == AIM_RATE_CODE_CHANGE) {
1521	if (currentavg >= clear)
1522	aim_conn_setlatency(fr->conn, 0);
1523	} else if (code == AIM_RATE_CODE_WARNING) {
1524	aim_conn_setlatency(fr->conn, windowsize/4);
1525	} else if (code == AIM_RATE_CODE_LIMIT) {
1526	imcb_error(sess->aux_data, _("The last message was not sent because you are over the rate limit. "
1527	"Please wait 10 seconds and try again."));
1528	aim_conn_setlatency(fr->conn, windowsize/2);
1529	} else if (code == AIM_RATE_CODE_CLEARLIMIT) {
1530	aim_conn_setlatency(fr->conn, 0);
1531	}
1532
1533	return 1;
1534	}
1535
1536	static int gaim_selfinfo(aim_session_t sess, aim_frame_t fr, ...) {
1537	va_list ap;
1538	aim_userinfo_t *info;
1539	struct im_connection *ic = sess->aux_data;
1540
1541	va_start(ap, fr);
1542	info = va_arg(ap, aim_userinfo_t *);
1543	va_end(ap);
1544
1545	ic->evil = info->warnlevel/10;
1546	/* ic->correction_time = (info->onlinesince - ic->login_time); */
1547
1548	return 1;
1549	}
1550
1551	static int conninitdone_bos(aim_session_t sess, aim_frame_t fr, ...) {
1552
1553	aim_reqpersonalinfo(sess, fr->conn);
1554	aim_bos_reqlocaterights(sess, fr->conn);
1555	aim_bos_reqbuddyrights(sess, fr->conn);
1556
1557	aim_reqicbmparams(sess);
1558
1559	aim_bos_reqrights(sess, fr->conn);
1560	aim_bos_setgroupperm(sess, fr->conn, AIM_FLAG_ALLUSERS);
1561	aim_bos_setprivacyflags(sess, fr->conn, AIM_PRIVFLAGS_ALLOWIDLE \|
1562	AIM_PRIVFLAGS_ALLOWMEMBERSINCE);
1563
1564	return 1;
1565	}
1566
1567	static int conninitdone_admin(aim_session_t sess, aim_frame_t fr, ...) {
1568	struct im_connection *ic = sess->aux_data;
1569	struct oscar_data *od = ic->proto_data;
1570
1571	aim_clientready(sess, fr->conn);
1572
1573	if (od->chpass) {
1574	aim_admin_changepasswd(sess, fr->conn, od->newp, od->oldp);
1575	g_free(od->oldp);
1576	od->oldp = NULL;
1577	g_free(od->newp);
1578	od->newp = NULL;
1579	od->chpass = FALSE;
1580	}
1581	if (od->setnick) {
1582	aim_admin_setnick(sess, fr->conn, od->newsn);
1583	g_free(od->newsn);
1584	od->newsn = NULL;
1585	od->setnick = FALSE;
1586	}
1587	if (od->conf) {
1588	aim_admin_reqconfirm(sess, fr->conn);
1589	od->conf = FALSE;
1590	}
1591	if (od->reqemail) {
1592	aim_admin_getinfo(sess, fr->conn, 0x0011);
1593	od->reqemail = FALSE;
1594	}
1595	if (od->setemail) {
1596	aim_admin_setemail(sess, fr->conn, od->email);
1597	g_free(od->email);
1598	od->setemail = FALSE;
1599	}
1600
1601	return 1;
1602	}
1603
1604	static int gaim_icbm_param_info(aim_session_t sess, aim_frame_t fr, ...) {
1605	struct aim_icbmparameters *params;
1606	va_list ap;
1607
1608	va_start(ap, fr);
1609	params = va_arg(ap, struct aim_icbmparameters *);
1610	va_end(ap);
1611
1612	/* Maybe senderwarn and recverwarn should be user preferences... */
1613	params->flags = 0x0000000b;
1614	params->maxmsglen = 8000;
1615	params->minmsginterval = 0;
1616
1617	aim_seticbmparam(sess, params);
1618
1619	return 1;
1620	}
1621
1622	static int gaim_parse_locaterights(aim_session_t sess, aim_frame_t fr, ...)
1623	{
1624	va_list ap;
1625	guint16 maxsiglen;
1626	struct im_connection *ic = sess->aux_data;
1627	struct oscar_data odata = (struct oscar_data )ic->proto_data;
1628
1629	va_start(ap, fr);
1630	maxsiglen = va_arg(ap, int);
1631	va_end(ap);
1632
1633	odata->rights.maxsiglen = odata->rights.maxawaymsglen = (guint)maxsiglen;
1634
1635	/* FIXME: It seems we're not really using this, and it broke now that
1636	struct aim_user is dead.
1637	aim_bos_setprofile(sess, fr->conn, ic->user->user_info, NULL, gaim_caps);
1638	*/
1639
1640	return 1;
1641	}
1642
1643	static int gaim_parse_buddyrights(aim_session_t sess, aim_frame_t fr, ...) {
1644	va_list ap;
1645	guint16 maxbuddies, maxwatchers;
1646	struct im_connection *ic = sess->aux_data;
1647	struct oscar_data odata = (struct oscar_data )ic->proto_data;
1648
1649	va_start(ap, fr);
1650	maxbuddies = (guint16)va_arg(ap, unsigned int);
1651	maxwatchers = (guint16)va_arg(ap, unsigned int);
1652	va_end(ap);
1653
1654	odata->rights.maxbuddies = (guint)maxbuddies;
1655	odata->rights.maxwatchers = (guint)maxwatchers;
1656
1657	return 1;
1658	}
1659
1660	static int gaim_bosrights(aim_session_t sess, aim_frame_t fr, ...) {
1661	guint16 maxpermits, maxdenies;
1662	va_list ap;
1663	struct im_connection *ic = sess->aux_data;
1664	struct oscar_data odata = (struct oscar_data )ic->proto_data;
1665
1666	va_start(ap, fr);
1667	maxpermits = (guint16)va_arg(ap, unsigned int);
1668	maxdenies = (guint16)va_arg(ap, unsigned int);
1669	va_end(ap);
1670
1671	odata->rights.maxpermits = (guint)maxpermits;
1672	odata->rights.maxdenies = (guint)maxdenies;
1673
1674	aim_clientready(sess, fr->conn);
1675
1676	aim_reqservice(sess, fr->conn, AIM_CONN_TYPE_CHATNAV);
1677
1678	aim_ssi_reqrights(sess, fr->conn);
1679	aim_ssi_reqalldata(sess, fr->conn);
1680
1681	return 1;
1682	}
1683
1684	static int gaim_offlinemsg(aim_session_t sess, aim_frame_t fr, ...) {
1685	va_list ap;
1686	struct aim_icq_offlinemsg *msg;
1687	struct im_connection *ic = sess->aux_data;
1688
1689	va_start(ap, fr);
1690	msg = va_arg(ap, struct aim_icq_offlinemsg *);
1691	va_end(ap);
1692
1693	switch (msg->type) {
1694	case 0x0001: { /* Basic offline message */
1695	char sender[32];
1696	char *dialog_msg = g_strdup(msg->msg);
1697	time_t t = get_time(msg->year, msg->month, msg->day, msg->hour, msg->minute, 0);
1698	g_snprintf(sender, sizeof(sender), "%u", msg->sender);
1699	strip_linefeed(dialog_msg);
1700	imcb_buddy_msg(ic, normalize(sender), dialog_msg, 0, t);
1701	g_free(dialog_msg);
1702	} break;
1703
1704	case 0x0004: { /* Someone sent you a URL */
1705	char sender[32];
1706	char *dialog_msg;
1707	char **m;
1708
1709	time_t t = get_time(msg->year, msg->month, msg->day, msg->hour, msg->minute, 0);
1710	g_snprintf(sender, sizeof(sender), "%u", msg->sender);
1711
1712	m = g_strsplit(msg->msg, "\376", 2);
1713
1714	if ((strlen(m[0]) != 0)) {
1715	dialog_msg = g_strjoinv(" -- ", m);
1716	} else {
1717	dialog_msg = m[1];
1718	}
1719
1720	strip_linefeed(dialog_msg);
1721	imcb_buddy_msg(ic, normalize(sender), dialog_msg, 0, t);
1722	g_free(dialog_msg);
1723	g_free(m);
1724	} break;
1725
1726	case 0x0006: { /* Authorization request */
1727	gaim_icq_authask(ic, msg->sender, msg->msg);
1728	} break;
1729
1730	case 0x0007: { /* Someone has denied you authorization */
1731	imcb_log(sess->aux_data, "The user %u has denied your request to add them to your contact list for the following reason:\n%s", msg->sender, msg->msg ? msg->msg : _("No reason given.") );
1732	} break;
1733
1734	case 0x0008: { /* Someone has granted you authorization */
1735	imcb_log(sess->aux_data, "The user %u has granted your request to add them to your contact list for the following reason:\n%s", msg->sender, msg->msg ? msg->msg : _("No reason given.") );
1736	} break;
1737
1738	case 0x0012: {
1739	/* Ack for authorizing/denying someone. Or possibly an ack for sending any system notice */
1740	} break;
1741
1742	default: {;
1743	}
1744	}
1745
1746	return 1;
1747	}
1748
1749	static int gaim_offlinemsgdone(aim_session_t sess, aim_frame_t fr, ...)
1750	{
1751	aim_icq_ackofflinemsgs(sess);
1752	return 1;
1753	}
1754
1755	static void oscar_keepalive(struct im_connection *ic) {
1756	struct oscar_data odata = (struct oscar_data )ic->proto_data;
1757	aim_flap_nop(odata->sess, odata->conn);
1758	}
1759
1760	static int oscar_buddy_msg(struct im_connection ic, char name, char *message, int imflags) {
1761	struct oscar_data odata = (struct oscar_data )ic->proto_data;
1762	int ret = 0, len = strlen(message);
1763	if (imflags & OPT_AWAY) {
1764	ret = aim_send_im(odata->sess, name, AIM_IMFLAGS_AWAY, message);
1765	} else {
1766	struct aim_sendimext_args args;
1767	char *s;
1768
1769	args.flags = AIM_IMFLAGS_ACK;
1770	if (odata->icq)
1771	args.flags \|= AIM_IMFLAGS_OFFLINE;
1772	for (s = message; *s; s++)
1773	if (*s & 128)
1774	break;
1775
1776	/* Message contains high ASCII chars, time for some translation! */
1777	if (*s) {
1778	s = g_malloc(BUF_LONG);
1779	/* Try if we can put it in an ISO8859-1 string first.
1780	If we can't, fall back to UTF16. */
1781	if ((ret = do_iconv("UTF-8", "ISO8859-1", message, s, len, BUF_LONG)) >= 0) {
1782	args.flags \|= AIM_IMFLAGS_ISO_8859_1;
1783	len = ret;
1784	} else if ((ret = do_iconv("UTF-8", "UNICODEBIG", message, s, len, BUF_LONG)) >= 0) {
1785	args.flags \|= AIM_IMFLAGS_UNICODE;
1786	len = ret;
1787	} else {
1788	/* OOF, translation failed... Oh well.. */
1789	g_free( s );
1790	s = message;
1791	}
1792	} else {
1793	s = message;
1794	}
1795
1796	args.features = gaim_features;
1797	args.featureslen = sizeof(gaim_features);
1798
1799	args.destsn = name;
1800	args.msg = s;
1801	args.msglen = len;
1802
1803	ret = aim_send_im_ext(odata->sess, &args);
1804
1805	if (s != message) {
1806	g_free(s);
1807	}
1808	}
1809	if (ret >= 0)
1810	return 1;
1811	return ret;
1812	}
1813
1814	static void oscar_get_info(struct im_connection g, char name) {
1815	struct oscar_data odata = (struct oscar_data )g->proto_data;
1816	if (odata->icq)
1817	aim_icq_getallinfo(odata->sess, name);
1818	else {
1819	aim_getinfo(odata->sess, odata->conn, name, AIM_GETINFO_AWAYMESSAGE);
1820	aim_getinfo(odata->sess, odata->conn, name, AIM_GETINFO_GENERALINFO);
1821	}
1822	}
1823
1824	static void oscar_get_away(struct im_connection g, char who) {
1825	struct oscar_data odata = (struct oscar_data )g->proto_data;
1826	if (odata->icq) {
1827	/** FIXME(wilmer): Hmm, lost the ability to get away msgs here, do we care to get that back?
1828	struct buddy *budlight = imcb_find_buddy(g, who);
1829	if (budlight)
1830	if ((budlight->uc & 0xff80) >> 7)
1831	if (budlight->caps & AIM_CAPS_ICQSERVERRELAY)
1832	aim_send_im_ch2_geticqmessage(odata->sess, who, (budlight->uc & 0xff80) >> 7);
1833	*/
1834	} else
1835	aim_getinfo(odata->sess, odata->conn, who, AIM_GETINFO_AWAYMESSAGE);
1836	}
1837
1838	static void oscar_set_away_aim(struct im_connection ic, struct oscar_data od, const char state, const char message)
1839	{
1840	if (state == NULL)
1841	state = "";
1842
1843	if (!g_strcasecmp(state, _("Visible"))) {
1844	aim_setextstatus(od->sess, od->conn, AIM_ICQ_STATE_NORMAL);
1845	return;
1846	} else if (!g_strcasecmp(state, _("Invisible"))) {
1847	aim_setextstatus(od->sess, od->conn, AIM_ICQ_STATE_INVISIBLE);
1848	return;
1849	} else if (message == NULL) {
1850	message = state;
1851	}
1852
1853	if (od->rights.maxawaymsglen == 0)
1854	imcb_error(ic, "oscar_set_away_aim called before locate rights received");
1855
1856	aim_setextstatus(od->sess, od->conn, AIM_ICQ_STATE_NORMAL);
1857
1858	g_free(ic->away);
1859	ic->away = NULL;
1860
1861	if (!message) {
1862	aim_bos_setprofile(od->sess, od->conn, NULL, "", gaim_caps);
1863	return;
1864	}
1865
1866	if (strlen(message) > od->rights.maxawaymsglen) {
1867	imcb_error(ic, "Maximum away message length of %d bytes exceeded, truncating", od->rights.maxawaymsglen);
1868	}
1869
1870	ic->away = g_strndup(message, od->rights.maxawaymsglen);
1871	aim_bos_setprofile(od->sess, od->conn, NULL, ic->away, gaim_caps);
1872
1873	return;
1874	}
1875
1876	static void oscar_set_away_icq(struct im_connection ic, struct oscar_data od, const char state, const char message)
1877	{
1878	const char *msg = NULL;
1879	gboolean no_message = FALSE;
1880
1881	/* clean old states */
1882	g_free(ic->away);
1883	ic->away = NULL;
1884	od->sess->aim_icq_state = 0;
1885
1886	/* if no message, then use an empty message */
1887	if (message) {
1888	msg = message;
1889	} else {
1890	msg = "";
1891	no_message = TRUE;
1892	}
1893
1894	if (state == NULL) {
1895	aim_setextstatus(od->sess, od->conn, AIM_ICQ_STATE_NORMAL);
1896	} else if (!g_strcasecmp(state, "Away")) {
1897	aim_setextstatus(od->sess, od->conn, AIM_ICQ_STATE_AWAY);
1898	ic->away = g_strdup(msg);
1899	od->sess->aim_icq_state = AIM_MTYPE_AUTOAWAY;
1900	} else if (!g_strcasecmp(state, "Do Not Disturb")) {
1901	aim_setextstatus(od->sess, od->conn, AIM_ICQ_STATE_AWAY \| AIM_ICQ_STATE_DND \| AIM_ICQ_STATE_BUSY);
1902	ic->away = g_strdup(msg);
1903	od->sess->aim_icq_state = AIM_MTYPE_AUTODND;
1904	} else if (!g_strcasecmp(state, "Not Available")) {
1905	aim_setextstatus(od->sess, od->conn, AIM_ICQ_STATE_OUT \| AIM_ICQ_STATE_AWAY);
1906	ic->away = g_strdup(msg);
1907	od->sess->aim_icq_state = AIM_MTYPE_AUTONA;
1908	} else if (!g_strcasecmp(state, "Occupied")) {
1909	aim_setextstatus(od->sess, od->conn, AIM_ICQ_STATE_AWAY \| AIM_ICQ_STATE_BUSY);
1910	ic->away = g_strdup(msg);
1911	od->sess->aim_icq_state = AIM_MTYPE_AUTOBUSY;
1912	} else if (!g_strcasecmp(state, "Free For Chat")) {
1913	aim_setextstatus(od->sess, od->conn, AIM_ICQ_STATE_CHAT);
1914	ic->away = g_strdup(msg);
1915	od->sess->aim_icq_state = AIM_MTYPE_AUTOFFC;
1916	} else if (!g_strcasecmp(state, "Invisible")) {
1917	aim_setextstatus(od->sess, od->conn, AIM_ICQ_STATE_INVISIBLE);
1918	ic->away = g_strdup(msg);
1919	} else {
1920	if (no_message) {
1921	aim_setextstatus(od->sess, od->conn, AIM_ICQ_STATE_NORMAL);
1922	} else {
1923	aim_setextstatus(od->sess, od->conn, AIM_ICQ_STATE_AWAY);
1924	ic->away = g_strdup(msg);
1925	od->sess->aim_icq_state = AIM_MTYPE_AUTOAWAY;
1926	}
1927	}
1928
1929	return;
1930	}
1931
1932	static void oscar_set_away(struct im_connection ic, char state, char *message)
1933	{
1934	struct oscar_data od = (struct oscar_data )ic->proto_data;
1935
1936	oscar_set_away_aim(ic, od, state, message);
1937	if (od->icq)
1938	oscar_set_away_icq(ic, od, state, message);
1939
1940	return;
1941	}
1942
1943	static void oscar_add_buddy(struct im_connection g, char name, char *group) {
1944	struct oscar_data odata = (struct oscar_data )g->proto_data;
1945	bee_user_t *bu;
1946
1947	if (group && (bu = bee_user_by_handle(g->bee, g, name)) && bu->group)
1948	aim_ssi_movebuddy(odata->sess, odata->conn, bu->group->name, group, name);
1949	else
1950	aim_ssi_addbuddies(odata->sess, odata->conn, group ? : OSCAR_GROUP, &name, 1, 0);
1951	}
1952
1953	static void oscar_remove_buddy(struct im_connection g, char name, char *group) {
1954	struct oscar_data odata = (struct oscar_data )g->proto_data;
1955	struct aim_ssi_item *ssigroup;
1956	while ((ssigroup = aim_ssi_itemlist_findparent(odata->sess->ssi.items, name)) && !aim_ssi_delbuddies(odata->sess, odata->conn, ssigroup->name, &name, 1));
1957	}
1958
1959	static int gaim_ssi_parserights(aim_session_t sess, aim_frame_t fr, ...) {
1960	return 1;
1961	}
1962
1963	static int gaim_ssi_parselist(aim_session_t sess, aim_frame_t fr, ...) {
1964	struct im_connection *ic = sess->aux_data;
1965	struct aim_ssi_item curitem, curgroup;
1966	int tmp;
1967	char *nrm;
1968
1969	/* Add from server list to local list */
1970	tmp = 0;
1971	for (curitem=sess->ssi.items; curitem; curitem=curitem->next) {
1972	nrm = curitem->name ? normalize(curitem->name) : NULL;
1973
1974	switch (curitem->type) {
1975	case 0x0000: /* Buddy */
1976	if ((curitem->name) && (!imcb_buddy_by_handle(ic, nrm))) {
1977	char *realname = NULL;
1978
1979	if (curitem->data && aim_gettlv(curitem->data, 0x0131, 1))
1980	realname = aim_gettlv_str(curitem->data, 0x0131, 1);
1981
1982	imcb_add_buddy(ic, nrm, curgroup->gid == curitem->gid ? curgroup->name : NULL);
1983
1984	if (realname) {
1985	imcb_buddy_nick_hint(ic, nrm, realname);
1986	imcb_rename_buddy(ic, nrm, realname);
1987	g_free(realname);
1988	}
1989	}
1990	break;
1991
1992	case 0x0001: /* Group */
1993	curgroup = curitem;
1994	break;
1995
1996	case 0x0002: /* Permit buddy */
1997	if (curitem->name) {
1998	GSList *list;
1999	for (list=ic->permit; (list && aim_sncmp(curitem->name, list->data)); list=list->next);
2000	if (!list) {
2001	char *name;
2002	name = g_strdup(nrm);
2003	ic->permit = g_slist_append(ic->permit, name);
2004	tmp++;
2005	}
2006	}
2007	break;
2008
2009	case 0x0003: /* Deny buddy */
2010	if (curitem->name) {
2011	GSList *list;
2012	for (list=ic->deny; (list && aim_sncmp(curitem->name, list->data)); list=list->next);
2013	if (!list) {
2014	char *name;
2015	name = g_strdup(nrm);
2016	ic->deny = g_slist_append(ic->deny, name);
2017	tmp++;
2018	}
2019	}
2020	break;
2021
2022	case 0x0004: /* Permit/deny setting */
2023	if (curitem->data) {
2024	guint8 permdeny;
2025	if ((permdeny = aim_ssi_getpermdeny(sess->ssi.items)) && (permdeny != ic->permdeny)) {
2026	ic->permdeny = permdeny;
2027	tmp++;
2028	}
2029	}
2030	break;
2031
2032	case 0x0005: /* Presence setting */
2033	/* We don't want to change Gaim's setting because it applies to all accounts */
2034	break;
2035	} /* End of switch on curitem->type */
2036	} /* End of for loop */
2037
2038	aim_ssi_enable(sess, fr->conn);
2039
2040	/* Request offline messages, now that the buddy list is complete. */
2041	aim_icq_reqofflinemsgs(sess);
2042
2043	/* Now that we have a buddy list, we can tell BitlBee that we're online. */
2044	imcb_connected(ic);
2045
2046	return 1;
2047	}
2048
2049	static int gaim_ssi_parseack( aim_session_t sess, aim_frame_t fr, ... )
2050	{
2051	aim_snac_t *origsnac;
2052	va_list ap;
2053
2054	va_start( ap, fr );
2055	origsnac = va_arg( ap, aim_snac_t * );
2056	va_end( ap );
2057
2058	if( origsnac && origsnac->family == AIM_CB_FAM_SSI && origsnac->type == AIM_CB_SSI_ADD && origsnac->data )
2059	{
2060	int i, st, count = aim_bstream_empty( &fr->data );
2061	char *list;
2062
2063	if( count & 1 )
2064	{
2065	/* Hmm, the length should be even... */
2066	imcb_error( sess->aux_data, "Received SSI ACK package with non-even length");
2067	return( 0 );
2068	}
2069	count >>= 1;
2070
2071	list = (char *) origsnac->data;
2072	for( i = 0; i < count; i ++ )
2073	{
2074	struct aim_ssi_item *ssigroup = aim_ssi_itemlist_findparent( sess->ssi.items, list );
2075	char *group = ssigroup ? ssigroup->name : NULL;
2076
2077	st = aimbs_get16( &fr->data );
2078	if( st == 0x00 )
2079	{
2080	imcb_add_buddy( sess->aux_data, normalize(list), group );
2081	}
2082	else if( st == 0x0E )
2083	{
2084	imcb_log( sess->aux_data, "Buddy %s can't be added without authorization, requesting authorization", list );
2085
2086	aim_ssi_auth_request( sess, fr->conn, list, "" );
2087	aim_ssi_addbuddies( sess, fr->conn, OSCAR_GROUP, &list, 1, 1 );
2088	}
2089	else
2090	{
2091	imcb_error( sess->aux_data, "Error while adding buddy: 0x%04x", st );
2092	}
2093	list += strlen( list ) + 1;
2094	}
2095	}
2096
2097	return( 1 );
2098	}
2099
2100	static void oscar_set_permit_deny(struct im_connection *ic) {
2101	struct oscar_data od = (struct oscar_data )ic->proto_data;
2102	if (od->icq) {
2103	GSList *list;
2104	char buf[MAXMSGLEN];
2105	int at;
2106
2107	switch(ic->permdeny) {
2108	case 1:
2109	aim_bos_changevisibility(od->sess, od->conn, AIM_VISIBILITYCHANGE_DENYADD, ic->acc->user);
2110	break;
2111	case 2:
2112	aim_bos_changevisibility(od->sess, od->conn, AIM_VISIBILITYCHANGE_PERMITADD, ic->acc->user);
2113	break;
2114	case 3:
2115	list = ic->permit;
2116	at = 0;
2117	while (list) {
2118	at += g_snprintf(buf + at, sizeof(buf) - at, "%s&", (char *)list->data);
2119	list = list->next;
2120	}
2121	aim_bos_changevisibility(od->sess, od->conn, AIM_VISIBILITYCHANGE_PERMITADD, buf);
2122	break;
2123	case 4:
2124	list = ic->deny;
2125	at = 0;
2126	while (list) {
2127	at += g_snprintf(buf + at, sizeof(buf) - at, "%s&", (char *)list->data);
2128	list = list->next;
2129	}
2130	aim_bos_changevisibility(od->sess, od->conn, AIM_VISIBILITYCHANGE_DENYADD, buf);
2131	break;
2132	default:
2133	break;
2134	}
2135	} else {
2136	if (od->sess->ssi.received_data)
2137	aim_ssi_setpermdeny(od->sess, od->conn, ic->permdeny, 0xffffffff);
2138	}
2139	}
2140
2141	static void oscar_add_permit(struct im_connection ic, char who) {
2142	struct oscar_data od = (struct oscar_data )ic->proto_data;
2143	if (od->icq) {
2144	aim_ssi_auth_reply(od->sess, od->conn, who, 1, "");
2145	} else {
2146	if (od->sess->ssi.received_data)
2147	aim_ssi_addpord(od->sess, od->conn, &who, 1, AIM_SSI_TYPE_PERMIT);
2148	}
2149	}
2150
2151	static void oscar_add_deny(struct im_connection ic, char who) {
2152	struct oscar_data od = (struct oscar_data )ic->proto_data;
2153	if (od->icq) {
2154	aim_ssi_auth_reply(od->sess, od->conn, who, 0, "");
2155	} else {
2156	if (od->sess->ssi.received_data)
2157	aim_ssi_addpord(od->sess, od->conn, &who, 1, AIM_SSI_TYPE_DENY);
2158	}
2159	}
2160
2161	static void oscar_rem_permit(struct im_connection ic, char who) {
2162	struct oscar_data od = (struct oscar_data )ic->proto_data;
2163	if (!od->icq) {
2164	if (od->sess->ssi.received_data)
2165	aim_ssi_delpord(od->sess, od->conn, &who, 1, AIM_SSI_TYPE_PERMIT);
2166	}
2167	}
2168
2169	static void oscar_rem_deny(struct im_connection ic, char who) {
2170	struct oscar_data od = (struct oscar_data )ic->proto_data;
2171	if (!od->icq) {
2172	if (od->sess->ssi.received_data)
2173	aim_ssi_delpord(od->sess, od->conn, &who, 1, AIM_SSI_TYPE_DENY);
2174	}
2175	}
2176
2177	static GList oscar_away_states(struct im_connection ic)
2178	{
2179	struct oscar_data *od = ic->proto_data;
2180
2181	if (od->icq) {
2182	static GList *m = NULL;
2183	m = g_list_append(m, "Away");
2184	m = g_list_append(m, "Do Not Disturb");
2185	m = g_list_append(m, "Not Available");
2186	m = g_list_append(m, "Occupied");
2187	m = g_list_append(m, "Free For Chat");
2188	m = g_list_append(m, "Invisible");
2189	return m;
2190	} else {
2191	static GList *m = NULL;
2192	m = g_list_append(m, "Away");
2193	return m;
2194	}
2195	}
2196
2197	static int gaim_icqinfo(aim_session_t sess, aim_frame_t fr, ...)
2198	{
2199	struct im_connection *ic = sess->aux_data;
2200	struct oscar_data *od = ic->proto_data;
2201	gchar who[16];
2202	GString *str;
2203	va_list ap;
2204	struct aim_icq_info *info;
2205	uint32_t ip;
2206
2207	va_start(ap, fr);
2208	info = va_arg(ap, struct aim_icq_info *);
2209	va_end(ap);
2210
2211	if (!info->uin)
2212	return 0;
2213
2214	str = g_string_sized_new(512);
2215	g_snprintf(who, sizeof(who), "%u", info->uin);
2216
2217	g_string_printf(str, "%s: %s - %s: %s", _("UIN"), who, _("Nick"),
2218	info->nick ? info->nick : "-");
2219	g_string_append_printf(str, "\n%s: %s", _("First Name"), info->first);
2220	g_string_append_printf(str, "\n%s: %s", _("Last Name"), info->last);
2221	g_string_append_printf(str, "\n%s: %s", _("Email Address"), info->email);
2222	if (info->numaddresses && info->email2) {
2223	int i;
2224	for (i = 0; i < info->numaddresses; i++) {
2225	g_string_append_printf(str, "\n%s: %s", _("Email Address"), info->email2[i]);
2226	}
2227	}
2228	if (od->ips && (ip = (long) g_hash_table_lookup(od->ips, &info->uin)) != 0) {
2229	g_string_append_printf(str, "\n%s: %d.%d.%d.%d", _("Last used IP address"),
2230	(ip >> 24), (ip >> 16) & 0xff, (ip >> 8) & 0xff, ip & 0xff);
2231	}
2232	g_string_append_printf(str, "\n%s: %s", _("Mobile Phone"), info->mobile);
2233	if (info->gender != 0)
2234	g_string_append_printf(str, "\n%s: %s", _("Gender"), info->gender==1 ? _("Female") : _("Male"));
2235	if (info->birthyear \|\| info->birthmonth \|\| info->birthday) {
2236	char date[30];
2237	struct tm tm;
2238	memset(&tm, 0, sizeof(struct tm));
2239	tm.tm_mday = (int)info->birthday;
2240	tm.tm_mon = (int)info->birthmonth-1;
2241	tm.tm_year = (int)info->birthyear%100;
2242	strftime(date, sizeof(date), "%Y-%m-%d", &tm);
2243	g_string_append_printf(str, "\n%s: %s", _("Birthday"), date);
2244	}
2245	if (info->age) {
2246	char age[5];
2247	g_snprintf(age, sizeof(age), "%hhd", info->age);
2248	g_string_append_printf(str, "\n%s: %s", _("Age"), age);
2249	}
2250	g_string_append_printf(str, "\n%s: %s", _("Personal Web Page"), info->personalwebpage);
2251	if (info->info && info->info[0]) {
2252	g_string_sprintfa(str, "\n%s:\n%s\n%s", _("Additional Information"),
2253	info->info, _("End of Additional Information"));
2254	}
2255	g_string_append_c(str, '\n');
2256	if ((info->homeaddr && (info->homeaddr[0])) \|\| (info->homecity && info->homecity[0]) \|\| (info->homestate && info->homestate[0]) \|\| (info->homezip && info->homezip[0])) {
2257	g_string_append_printf(str, "%s:", _("Home Address"));
2258	g_string_append_printf(str, "\n%s: %s", _("Address"), info->homeaddr);
2259	g_string_append_printf(str, "\n%s: %s", _("City"), info->homecity);
2260	g_string_append_printf(str, "\n%s: %s", _("State"), info->homestate);
2261	g_string_append_printf(str, "\n%s: %s", _("Zip Code"), info->homezip);
2262	g_string_append_c(str, '\n');
2263	}
2264	if ((info->workaddr && info->workaddr[0]) \|\| (info->workcity && info->workcity[0]) \|\| (info->workstate && info->workstate[0]) \|\| (info->workzip && info->workzip[0])) {
2265	g_string_append_printf(str, "%s:", _("Work Address"));
2266	g_string_append_printf(str, "\n%s: %s", _("Address"), info->workaddr);
2267	g_string_append_printf(str, "\n%s: %s", _("City"), info->workcity);
2268	g_string_append_printf(str, "\n%s: %s", _("State"), info->workstate);
2269	g_string_append_printf(str, "\n%s: %s", _("Zip Code"), info->workzip);
2270	g_string_append_c(str, '\n');
2271	}
2272	if ((info->workcompany && info->workcompany[0]) \|\| (info->workdivision && info->workdivision[0]) \|\| (info->workposition && info->workposition[0]) \|\| (info->workwebpage && info->workwebpage[0])) {
2273	g_string_append_printf(str, "%s:", _("Work Information"));
2274	g_string_append_printf(str, "\n%s: %s", _("Company"), info->workcompany);
2275	g_string_append_printf(str, "\n%s: %s", _("Division"), info->workdivision);
2276	g_string_append_printf(str, "\n%s: %s", _("Position"), info->workposition);
2277	if (info->workwebpage && info->workwebpage[0]) {
2278	g_string_append_printf(str, "\n%s: %s", _("Web Page"), info->workwebpage);
2279	}
2280	g_string_append_c(str, '\n');
2281	}
2282
2283	imcb_log(ic, "%s\n%s", _("User Info"), str->str);
2284	g_string_free(str, TRUE);
2285
2286	return 1;
2287
2288	}
2289
2290	static char oscar_encoding_extract(const char encoding)
2291	{
2292	char *ret = NULL;
2293	char begin, end;
2294
2295	g_return_val_if_fail(encoding != NULL, NULL);
2296
2297	/* Make sure encoding begins with charset= */
2298	if (strncmp(encoding, "text/plain; charset=", 20) &&
2299	strncmp(encoding, "text/aolrtf; charset=", 21) &&
2300	strncmp(encoding, "text/x-aolrtf; charset=", 23))
2301	{
2302	return NULL;
2303	}
2304
2305	begin = strchr(encoding, '"');
2306	end = strrchr(encoding, '"');
2307
2308	if ((begin == NULL) \|\| (end == NULL) \|\| (begin >= end))
2309	return NULL;
2310
2311	ret = g_strndup(begin+1, (end-1) - begin);
2312
2313	return ret;
2314	}
2315
2316	static char oscar_encoding_to_utf8(char encoding, char *text, int textlen)
2317	{
2318	char *utf8 = g_new0(char, 8192);
2319
2320	if ((encoding == NULL) \|\| encoding[0] == '\0') {
2321	/* gaim_debug_info("oscar", "Empty encoding, assuming UTF-8\n");*/
2322	} else if (!g_strcasecmp(encoding, "iso-8859-1")) {
2323	do_iconv("iso-8859-1", "UTF-8", text, utf8, textlen, 8192);
2324	} else if (!g_strcasecmp(encoding, "ISO-8859-1-Windows-3.1-Latin-1")) {
2325	do_iconv("Windows-1252", "UTF-8", text, utf8, textlen, 8192);
2326	} else if (!g_strcasecmp(encoding, "unicode-2-0")) {
2327	do_iconv("UCS-2BE", "UTF-8", text, utf8, textlen, 8192);
2328	} else if (g_strcasecmp(encoding, "us-ascii") && strcmp(encoding, "utf-8")) {
2329	/* gaim_debug_warning("oscar", "Unrecognized character encoding \"%s\", "
2330	"attempting to convert to UTF-8 anyway\n", encoding);*/
2331	do_iconv(encoding, "UTF-8", text, utf8, textlen, 8192);
2332	}
2333
2334	/*
2335	* If utf8 is still NULL then either the encoding is us-ascii/utf-8 or
2336	* we have been unable to convert the text to utf-8 from the encoding
2337	* that was specified. So we assume it's UTF-8 and hope for the best.
2338	*/
2339	if (*utf8 == 0) {
2340	strncpy(utf8, text, textlen);
2341	}
2342
2343	return utf8;
2344	}
2345
2346	static int gaim_parseaiminfo(aim_session_t sess, aim_frame_t fr, ...)
2347	{
2348	struct im_connection *ic = sess->aux_data;
2349	va_list ap;
2350	aim_userinfo_t *userinfo;
2351	guint16 infotype;
2352	char text_encoding = NULL, text = NULL, *extracted_encoding = NULL;
2353	guint16 text_length;
2354	char *utf8 = NULL;
2355
2356	va_start(ap, fr);
2357	userinfo = va_arg(ap, aim_userinfo_t *);
2358	infotype = va_arg(ap, int);
2359	text_encoding = va_arg(ap, char*);
2360	text = va_arg(ap, char*);
2361	text_length = va_arg(ap, int);
2362	va_end(ap);
2363
2364	if(text_encoding)
2365	extracted_encoding = oscar_encoding_extract(text_encoding);
2366	if(infotype == AIM_GETINFO_GENERALINFO) {
2367	/Display idle time/
2368	char buff[256];
2369	struct tm idletime;
2370	if(userinfo->idletime) {
2371	memset(&idletime, 0, sizeof(struct tm));
2372	idletime.tm_mday = (userinfo->idletime / 60) / 24;
2373	idletime.tm_hour = (userinfo->idletime / 60) % 24;
2374	idletime.tm_min = userinfo->idletime % 60;
2375	idletime.tm_sec = 0;
2376	strftime(buff, 256, _("%d days %H hours %M minutes"), &idletime);
2377	imcb_log(ic, "%s: %s", _("Idle Time"), buff);
2378	}
2379
2380	if(text) {
2381	utf8 = oscar_encoding_to_utf8(extracted_encoding, text, text_length);
2382	imcb_log(ic, "%s\n%s", _("User Info"), utf8);
2383	} else {
2384	imcb_log(ic, _("No user info available."));
2385	}
2386	} else if(infotype == AIM_GETINFO_AWAYMESSAGE && userinfo->flags & AIM_FLAG_AWAY) {
2387	utf8 = oscar_encoding_to_utf8(extracted_encoding, text, text_length);
2388	imcb_log(ic, "%s\n%s", _("Away Message"), utf8);
2389	}
2390
2391	g_free(utf8);
2392
2393	return 1;
2394	}
2395
2396	int gaim_parsemtn(aim_session_t sess, aim_frame_t fr, ...)
2397	{
2398	struct im_connection * ic = sess->aux_data;
2399	va_list ap;
2400	guint16 type1, type2;
2401	char * sn;
2402
2403	va_start(ap, fr);
2404	type1 = va_arg(ap, int);
2405	sn = va_arg(ap, char*);
2406	type2 = va_arg(ap, int);
2407	va_end(ap);
2408
2409	if(type2 == 0x0002) {
2410	/* User is typing */
2411	imcb_buddy_typing(ic, normalize(sn), OPT_TYPING);
2412	}
2413	else if (type2 == 0x0001) {
2414	/* User has typed something, but is not actively typing (stale) */
2415	imcb_buddy_typing(ic, normalize(sn), OPT_THINKING);
2416	}
2417	else {
2418	/* User has stopped typing */
2419	imcb_buddy_typing(ic, normalize(sn), 0);
2420	}
2421
2422	return 1;
2423	}
2424
2425	int oscar_send_typing(struct im_connection ic, char who, int typing)
2426	{
2427	struct oscar_data *od = ic->proto_data;
2428	return( aim_im_sendmtn(od->sess, 1, who, (typing & OPT_TYPING) ? 0x0002 : 0x0000) );
2429	}
2430
2431	void oscar_chat_msg(struct groupchat c, char message, int msgflags)
2432	{
2433	struct im_connection *ic = c->ic;
2434	struct oscar_data * od = (struct oscar_data*)ic->proto_data;
2435	struct chat_connection * ccon;
2436	int ret;
2437	guint8 len = strlen(message);
2438	guint16 flags;
2439	char *s;
2440
2441	if (!(ccon = c->data))
2442	return;
2443
2444	for (s = message; *s; s++)
2445	if (*s & 128)
2446	break;
2447
2448	flags = AIM_CHATFLAGS_NOREFLECT;
2449
2450	/* Message contains high ASCII chars, time for some translation! */
2451	if (*s) {
2452	s = g_malloc(BUF_LONG);
2453	/* Try if we can put it in an ISO8859-1 string first.
2454	If we can't, fall back to UTF16. */
2455	if ((ret = do_iconv("UTF-8", "ISO8859-1", message, s, len, BUF_LONG)) >= 0) {
2456	flags \|= AIM_CHATFLAGS_ISO_8859_1;
2457	len = ret;
2458	} else if ((ret = do_iconv("UTF-8", "UNICODEBIG", message, s, len, BUF_LONG)) >= 0) {
2459	flags \|= AIM_CHATFLAGS_UNICODE;
2460	len = ret;
2461	} else {
2462	/* OOF, translation failed... Oh well.. */
2463	g_free( s );
2464	s = message;
2465	}
2466	} else {
2467	s = message;
2468	}
2469
2470	ret = aim_chat_send_im(od->sess, ccon->conn, flags, s, len);
2471
2472	if (s != message) {
2473	g_free(s);
2474	}
2475
2476	/* return (ret >= 0); */
2477	}
2478
2479	void oscar_chat_invite(struct groupchat c, char who, char *message)
2480	{
2481	struct im_connection *ic = c->ic;
2482	struct oscar_data * od = (struct oscar_data *)ic->proto_data;
2483	struct chat_connection *ccon;
2484
2485	if (!(ccon = c->data))
2486	return;
2487
2488	aim_chat_invite(od->sess, od->conn, who, message ? message : "",
2489	ccon->exchange, ccon->name, 0x0);
2490	}
2491
2492	void oscar_chat_kill(struct im_connection ic, struct chat_connection cc)
2493	{
2494	struct oscar_data od = (struct oscar_data )ic->proto_data;
2495
2496	/* Notify the conversation window that we've left the chat */
2497	imcb_chat_free(cc->cnv);
2498
2499	/* Destroy the chat_connection */
2500	od->oscar_chats = g_slist_remove(od->oscar_chats, cc);
2501	if (cc->inpa > 0)
2502	b_event_remove(cc->inpa);
2503	aim_conn_kill(od->sess, &cc->conn);
2504	g_free(cc->name);
2505	g_free(cc->show);
2506	g_free(cc);
2507	}
2508
2509	void oscar_chat_leave(struct groupchat *c)
2510	{
2511	if (!c->data)
2512	return;
2513	oscar_chat_kill(c->ic, c->data);
2514	}
2515
2516	struct groupchat oscar_chat_join_internal(struct im_connection ic, const char *room,
2517	const char nick, const char password, int exchange_number)
2518	{
2519	struct oscar_data * od = (struct oscar_data *)ic->proto_data;
2520	struct groupchat *ret = imcb_chat_new(ic, room);
2521	aim_conn_t * cur;
2522
2523	if((cur = aim_getconn_type(od->sess, AIM_CONN_TYPE_CHATNAV))) {
2524	int st;
2525
2526	st = aim_chatnav_createroom(od->sess, cur, room, exchange_number);
2527
2528	return ret;
2529	} else {
2530	struct create_room * cr = g_new0(struct create_room, 1);
2531
2532	cr->exchange = exchange_number;
2533	cr->name = g_strdup(room);
2534	od->create_rooms = g_slist_append(od->create_rooms, cr);
2535	aim_reqservice(od->sess, od->conn, AIM_CONN_TYPE_CHATNAV);
2536
2537	return ret;
2538	}
2539	}
2540
2541	struct groupchat oscar_chat_join(struct im_connection ic, const char *room,
2542	const char nick, const char password, set_t **sets)
2543	{
2544	return oscar_chat_join_internal(ic, room, nick, password, set_getint(sets, "exchange_number"));
2545	}
2546
2547	struct groupchat oscar_chat_with(struct im_connection ic, char *who)
2548	{
2549	struct oscar_data * od = (struct oscar_data *)ic->proto_data;
2550	struct groupchat *ret;
2551	static int chat_id = 0;
2552	char * chatname, *s;
2553	struct groupchat *c;
2554
2555	chatname = g_strdup_printf("%s%s%d", isdigit(*ic->acc->user) ? "icq" : "",
2556	ic->acc->user, chat_id++);
2557
2558	for (s = chatname; *s; s ++)
2559	if (!isalnum(*s))
2560	*s = '0';
2561
2562	c = imcb_chat_new(ic, chatname);
2563	ret = oscar_chat_join_internal(ic, chatname, NULL, NULL, 4);
2564	aim_chat_invite(od->sess, od->conn, who, "", 4, chatname, 0x0);
2565
2566	g_free(chatname);
2567
2568	return NULL;
2569	}
2570
2571	void oscar_accept_chat(void *data)
2572	{
2573	struct aim_chat_invitation * inv = data;
2574
2575	oscar_chat_join_internal(inv->ic, inv->name, NULL, NULL, 4);
2576	g_free(inv->name);
2577	g_free(inv);
2578	}
2579
2580	void oscar_reject_chat(void *data)
2581	{
2582	struct aim_chat_invitation * inv = data;
2583
2584	g_free(inv->name);
2585	g_free(inv);
2586	}
2587
2588	void oscar_chat_add_settings(account_t acc, set_t *head)
2589	{
2590	set_add(head, "exchange_number", "4", set_eval_int, NULL);
2591	}
2592
2593	void oscar_chat_free_settings(account_t acc, set_t *head)
2594	{
2595	set_del(head, "exchange_number");
2596	}
2597
2598	void oscar_initmodule()
2599	{
2600	struct prpl *ret = g_new0(struct prpl, 1);
2601	ret->name = "oscar";
2602	ret->away_states = oscar_away_states;
2603	ret->init = oscar_init;
2604	ret->login = oscar_login;
2605	ret->keepalive = oscar_keepalive;
2606	ret->logout = oscar_logout;
2607	ret->buddy_msg = oscar_buddy_msg;
2608	ret->get_info = oscar_get_info;
2609	ret->set_away = oscar_set_away;
2610	ret->get_away = oscar_get_away;
2611	ret->add_buddy = oscar_add_buddy;
2612	ret->remove_buddy = oscar_remove_buddy;
2613	ret->chat_msg = oscar_chat_msg;
2614	ret->chat_invite = oscar_chat_invite;
2615	ret->chat_leave = oscar_chat_leave;
2616	ret->chat_with = oscar_chat_with;
2617	ret->chat_join = oscar_chat_join;
2618	ret->chat_add_settings = oscar_chat_add_settings;
2619	ret->chat_free_settings = oscar_chat_free_settings;
2620	ret->add_permit = oscar_add_permit;
2621	ret->add_deny = oscar_add_deny;
2622	ret->rem_permit = oscar_rem_permit;
2623	ret->rem_deny = oscar_rem_deny;
2624	ret->set_permit_deny = oscar_set_permit_deny;
2625	ret->send_typing = oscar_send_typing;
2626
2627	ret->handle_cmp = aim_sncmp;
2628
2629	register_protocol(ret);
2630	}

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

Download in other formats: