Context Navigation

source: protocols/oscar/oscar.c @ ab4afba

Last change on this file since ab4afba was b8ef1b1, checked in by Nelson Elhage <nelhage@…>, at 2005-12-04T19:32:14Z
Merging the Hanji groupchat patch
Property mode set to `100644`
File size: 75.4 KB

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

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

Download in other formats: