Context Navigation

source: protocols/oscar/oscar.c @ 5674207

Last change on this file since 5674207 was e046390, checked in by Wilmer van der Gaast <wilmer@…>, at 2009-10-10T23:25:54Z

Make purple use BitlBee's event handling API. Since the APIs never really
diverged too much this is fairly transparent. I did rename and redefine
GAIM_INPUT_* variables to really make it work without adding another stupid
layer in between.

One problem left, the new libpurple input API doesn't care about return
values. Fixing that in the next CL.

Property mode set to 100644

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

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

Download in other formats: