Context Navigation

source: protocols/yahoo/libyahoo2.c @ dde9d571

Last change on this file since dde9d571 was be915f5, checked in by Wilmer van der Gaast <wilmer@…>, at 2010-03-06T18:19:31Z
Yahoo! fixes. Turns out the protocol really is somewhat odd.
Property mode set to `100644`
File size: 130.0 KB

Rev	Line
[b7d3cc34]	1	/*
	2	* libyahoo2: libyahoo2.c
	3	*
	4	* Some code copyright (C) 2002-2004, Philip S Tellis <philip.tellis AT gmx.net>
	5	*
	6	* Yahoo Search copyright (C) 2003, Konstantin Klyagin <konst AT konst.org.ua>
	7	*
	8	* Much of this code was taken and adapted from the yahoo module for
	9	* gaim released under the GNU GPL. This code is also released under the
	10	* GNU GPL.
	11	*
	12	* This code is derivitive of Gaim <http://gaim.sourceforge.net>
	13	* copyright (C) 1998-1999, Mark Spencer <markster@marko.net>
	14	* 1998-1999, Adam Fritzler <afritz@marko.net>
	15	* 1998-2002, Rob Flynn <rob@marko.net>
	16	* 2000-2002, Eric Warmenhoven <eric@warmenhoven.org>
	17	* 2001-2002, Brian Macke <macke@strangelove.net>
	18	* 2001, Anand Biligiri S <abiligiri@users.sf.net>
	19	* 2001, Valdis Kletnieks
	20	* 2002, Sean Egan <bj91704@binghamton.edu>
	21	* 2002, Toby Gray <toby.gray@ntlworld.com>
	22	*
	23	* This library also uses code from other libraries, namely:
	24	* Portions from libfaim copyright 1998, 1999 Adam Fritzler
	25	* <afritz@auk.cx>
	26	* Portions of Sylpheed copyright 2000-2002 Hiroyuki Yamamoto
	27	* <hiro-y@kcn.ne.jp>
	28	*
	29	*
	30	* This program is free software; you can redistribute it and/or modify
	31	* it under the terms of the GNU General Public License as published by
	32	* the Free Software Foundation; either version 2 of the License, or
	33	* (at your option) any later version.
	34	*
	35	* This program is distributed in the hope that it will be useful,
	36	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	37	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	38	* GNU General Public License for more details.
	39	*
	40	* You should have received a copy of the GNU General Public License
	41	* along with this program; if not, write to the Free Software
	42	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	43	*
	44	*/
	45
	46	#ifndef _WIN32
	47	#include <unistd.h>
	48	#endif
	49	#include <errno.h>
	50	#include <stdio.h>
	51	#include <stdarg.h>
	52
	53	#if STDC_HEADERS
	54	# include <string.h>
	55	#else
	56	# if !HAVE_STRCHR
	57	# define strchr index
	58	# define strrchr rindex
	59	# endif
	60	char strchr (), strrchr ();
	61	# if !HAVE_MEMCPY
	62	# define memcpy(d, s, n) bcopy ((s), (d), (n))
	63	# define memmove(d, s, n) bcopy ((s), (d), (n))
	64	# endif
	65	#endif
	66
	67	#include <sys/types.h>
	68
	69	#ifdef __MINGW32__
	70	# include <winsock2.h>
	71	#endif
	72
	73	#include <stdlib.h>
	74	#include <ctype.h>
	75
[77bfd07]	76	#include "sha1.h"
[b7d3cc34]	77	#include "md5.h"
	78	#include "yahoo2.h"
	79	#include "yahoo_httplib.h"
	80	#include "yahoo_util.h"
	81	#include "yahoo_fn.h"
	82
	83	#include "yahoo2_callbacks.h"
	84	#include "yahoo_debug.h"
	85	#if defined(__MINGW32__) && !defined(HAVE_GLIB)
	86	#define snprintf _snprintf
	87	#define vsnprintf _vsnprintf
	88	#endif
	89
[7ed3199]	90	#include "base64.h"
[4fefb77]	91	#include "http_client.h"
	92
[b7d3cc34]	93	#ifdef USE_STRUCT_CALLBACKS
	94	struct yahoo_callbacks *yc=NULL;
	95
	96	void yahoo_register_callbacks(struct yahoo_callbacks * tyc)
	97	{
	98	yc = tyc;
	99	}
	100
	101	#define YAHOO_CALLBACK(x) yc->x
	102	#else
	103	#define YAHOO_CALLBACK(x) x
	104	#endif
	105
[cfc8d58]	106	static int yahoo_send_data(int fd, void *data, int len);
	107
[b7d3cc34]	108	int yahoo_log_message(char * fmt, ...)
	109	{
	110	char out[1024];
	111	va_list ap;
	112	va_start(ap, fmt);
	113	vsnprintf(out, sizeof(out), fmt, ap);
	114	va_end(ap);
	115	return YAHOO_CALLBACK(ext_yahoo_log)("%s", out);
	116	}
	117
	118	int yahoo_connect(char * host, int port)
	119	{
	120	return YAHOO_CALLBACK(ext_yahoo_connect)(host, port);
	121	}
	122
	123	static enum yahoo_log_level log_level = YAHOO_LOG_NONE;
	124
	125	enum yahoo_log_level yahoo_get_log_level()
	126	{
	127	return log_level;
	128	}
	129
	130	int yahoo_set_log_level(enum yahoo_log_level level)
	131	{
	132	enum yahoo_log_level l = log_level;
	133	log_level = level;
	134	return l;
	135	}
	136
	137	/* default values for servers */
	138	static char pager_host[] = "scs.msg.yahoo.com";
	139	static int pager_port = 5050;
	140	static int fallback_ports[]={23, 25, 80, 20, 119, 8001, 8002, 5050, 0};
	141	static char filetransfer_host[]="filetransfer.msg.yahoo.com";
	142	static int filetransfer_port=80;
	143	static char webcam_host[]="webcam.yahoo.com";
	144	static int webcam_port=5100;
	145	static char webcam_description[]="";
	146	static char local_host[]="";
	147	static int conn_type=Y_WCM_DSL;
	148
	149	static char profile_url[] = "http://profiles.yahoo.com/";
	150
	151	enum yahoo_service { /* these are easier to see in hex */
	152	YAHOO_SERVICE_LOGON = 1,
	153	YAHOO_SERVICE_LOGOFF,
	154	YAHOO_SERVICE_ISAWAY,
	155	YAHOO_SERVICE_ISBACK,
	156	YAHOO_SERVICE_IDLE, /* 5 (placemarker) */
	157	YAHOO_SERVICE_MESSAGE,
	158	YAHOO_SERVICE_IDACT,
	159	YAHOO_SERVICE_IDDEACT,
	160	YAHOO_SERVICE_MAILSTAT,
	161	YAHOO_SERVICE_USERSTAT, /* 0xa */
	162	YAHOO_SERVICE_NEWMAIL,
	163	YAHOO_SERVICE_CHATINVITE,
	164	YAHOO_SERVICE_CALENDAR,
	165	YAHOO_SERVICE_NEWPERSONALMAIL,
	166	YAHOO_SERVICE_NEWCONTACT,
	167	YAHOO_SERVICE_ADDIDENT, /* 0x10 */
	168	YAHOO_SERVICE_ADDIGNORE,
	169	YAHOO_SERVICE_PING,
	170	YAHOO_SERVICE_GOTGROUPRENAME, /* < 1, 36(old), 37(new) */
	171	YAHOO_SERVICE_SYSMESSAGE = 0x14,
[4fefb77]	172	YAHOO_SERVICE_SKINNAME = 0x15,
[b7d3cc34]	173	YAHOO_SERVICE_PASSTHROUGH2 = 0x16,
	174	YAHOO_SERVICE_CONFINVITE = 0x18,
	175	YAHOO_SERVICE_CONFLOGON,
	176	YAHOO_SERVICE_CONFDECLINE,
	177	YAHOO_SERVICE_CONFLOGOFF,
	178	YAHOO_SERVICE_CONFADDINVITE,
	179	YAHOO_SERVICE_CONFMSG,
	180	YAHOO_SERVICE_CHATLOGON,
	181	YAHOO_SERVICE_CHATLOGOFF,
	182	YAHOO_SERVICE_CHATMSG = 0x20,
	183	YAHOO_SERVICE_GAMELOGON = 0x28,
	184	YAHOO_SERVICE_GAMELOGOFF,
	185	YAHOO_SERVICE_GAMEMSG = 0x2a,
	186	YAHOO_SERVICE_FILETRANSFER = 0x46,
	187	YAHOO_SERVICE_VOICECHAT = 0x4A,
	188	YAHOO_SERVICE_NOTIFY,
	189	YAHOO_SERVICE_VERIFY,
	190	YAHOO_SERVICE_P2PFILEXFER,
	191	YAHOO_SERVICE_PEERTOPEER = 0x4F, /* Checks if P2P possible */
	192	YAHOO_SERVICE_WEBCAM,
	193	YAHOO_SERVICE_AUTHRESP = 0x54,
	194	YAHOO_SERVICE_LIST,
	195	YAHOO_SERVICE_AUTH = 0x57,
[4fefb77]	196	YAHOO_SERVICE_AUTHBUDDY = 0x6d,
[b7d3cc34]	197	YAHOO_SERVICE_ADDBUDDY = 0x83,
	198	YAHOO_SERVICE_REMBUDDY,
	199	YAHOO_SERVICE_IGNORECONTACT, /* > 1, 7, 13 < 1, 66, 13, 0*/
	200	YAHOO_SERVICE_REJECTCONTACT,
	201	YAHOO_SERVICE_GROUPRENAME = 0x89, /* > 1, 65(new), 66(0), 67(old) */
[4fefb77]	202	YAHOO_SERVICE_Y7_PING = 0x8A, /* 0 - id and that's it?? */
[b7d3cc34]	203	YAHOO_SERVICE_CHATONLINE = 0x96, /* > 109(id), 1, 6(abcde) < 0,1*/
	204	YAHOO_SERVICE_CHATGOTO,
	205	YAHOO_SERVICE_CHATJOIN, /* > 1 104-room 129-1600326591 62-2 */
	206	YAHOO_SERVICE_CHATLEAVE,
	207	YAHOO_SERVICE_CHATEXIT = 0x9b,
[4fefb77]	208	YAHOO_SERVICE_CHATADDINVITE = 0x9d,
[b7d3cc34]	209	YAHOO_SERVICE_CHATLOGOUT = 0xa0,
	210	YAHOO_SERVICE_CHATPING,
[cfc8d58]	211	YAHOO_SERVICE_COMMENT = 0xa8,
[ba16895]	212	YAHOO_SERVICE_STEALTH = 0xb9,
[cfc8d58]	213	YAHOO_SERVICE_PICTURE_CHECKSUM = 0xbd,
	214	YAHOO_SERVICE_PICTURE = 0xbe,
	215	YAHOO_SERVICE_PICTURE_UPDATE = 0xc1,
[4fefb77]	216	YAHOO_SERVICE_PICTURE_UPLOAD = 0xc2,
[ba16895]	217	YAHOO_SERVICE_Y6_VISIBILITY=0xc5,
	218	YAHOO_SERVICE_Y6_STATUS_UPDATE=0xc6,
	219	YAHOO_PHOTOSHARE_INIT=0xd2,
	220	YAHOO_SERVICE_CONTACT_YMSG13=0xd6,
	221	YAHOO_PHOTOSHARE_PREV=0xd7,
	222	YAHOO_PHOTOSHARE_KEY=0xd8,
	223	YAHOO_PHOTOSHARE_TRANS=0xda,
	224	YAHOO_FILE_TRANSFER_INIT_YMSG13=0xdc,
	225	YAHOO_FILE_TRANSFER_GET_YMSG13=0xdd,
	226	YAHOO_FILE_TRANSFER_PUT_YMSG13=0xde,
	227	YAHOO_SERVICE_YMSG15_STATUS=0xf0,
	228	YAHOO_SERVICE_YMSG15_BUDDY_LIST=0xf1,
[b7d3cc34]	229	};
	230
	231	struct yahoo_pair {
	232	int key;
	233	char *value;
	234	};
	235
	236	struct yahoo_packet {
	237	unsigned short int service;
	238	unsigned int status;
	239	unsigned int id;
	240	YList *hash;
	241	};
	242
	243	struct yahoo_search_state {
	244	int lsearch_type;
	245	char *lsearch_text;
	246	int lsearch_gender;
	247	int lsearch_agerange;
	248	int lsearch_photo;
	249	int lsearch_yahoo_only;
	250	int lsearch_nstart;
	251	int lsearch_nfound;
	252	int lsearch_ntotal;
	253	};
	254
	255	struct data_queue {
	256	unsigned char *queue;
	257	int len;
	258	};
	259
	260	struct yahoo_input_data {
	261	struct yahoo_data *yd;
	262	struct yahoo_webcam *wcm;
	263	struct yahoo_webcam_data *wcd;
	264	struct yahoo_search_state *ys;
	265
	266	int fd;
	267	enum yahoo_connection_type type;
	268
	269	unsigned char *rxqueue;
	270	int rxlen;
	271	int read_tag;
	272
	273	YList *txqueues;
	274	int write_tag;
	275	};
	276
	277	struct yahoo_server_settings {
	278	char *pager_host;
	279	int pager_port;
	280	char *filetransfer_host;
	281	int filetransfer_port;
	282	char *webcam_host;
	283	int webcam_port;
	284	char *webcam_description;
	285	char *local_host;
	286	int conn_type;
	287	};
	288
	289	static void * _yahoo_default_server_settings()
	290	{
	291	struct yahoo_server_settings *yss = y_new0(struct yahoo_server_settings, 1);
	292
	293	yss->pager_host = strdup(pager_host);
	294	yss->pager_port = pager_port;
	295	yss->filetransfer_host = strdup(filetransfer_host);
	296	yss->filetransfer_port = filetransfer_port;
	297	yss->webcam_host = strdup(webcam_host);
	298	yss->webcam_port = webcam_port;
	299	yss->webcam_description = strdup(webcam_description);
	300	yss->local_host = strdup(local_host);
	301	yss->conn_type = conn_type;
	302
	303	return yss;
	304	}
	305
	306	static void * _yahoo_assign_server_settings(va_list ap)
	307	{
	308	struct yahoo_server_settings *yss = _yahoo_default_server_settings();
	309	char *key;
	310	char *svalue;
	311	int nvalue;
	312
	313	while(1) {
	314	key = va_arg(ap, char *);
	315	if(key == NULL)
	316	break;
	317
	318	if(!strcmp(key, "pager_host")) {
	319	svalue = va_arg(ap, char *);
	320	free(yss->pager_host);
	321	yss->pager_host = strdup(svalue);
	322	} else if(!strcmp(key, "pager_port")) {
	323	nvalue = va_arg(ap, int);
	324	yss->pager_port = nvalue;
	325	} else if(!strcmp(key, "filetransfer_host")) {
	326	svalue = va_arg(ap, char *);
	327	free(yss->filetransfer_host);
	328	yss->filetransfer_host = strdup(svalue);
	329	} else if(!strcmp(key, "filetransfer_port")) {
	330	nvalue = va_arg(ap, int);
	331	yss->filetransfer_port = nvalue;
	332	} else if(!strcmp(key, "webcam_host")) {
	333	svalue = va_arg(ap, char *);
	334	free(yss->webcam_host);
	335	yss->webcam_host = strdup(svalue);
	336	} else if(!strcmp(key, "webcam_port")) {
	337	nvalue = va_arg(ap, int);
	338	yss->webcam_port = nvalue;
	339	} else if(!strcmp(key, "webcam_description")) {
	340	svalue = va_arg(ap, char *);
	341	free(yss->webcam_description);
	342	yss->webcam_description = strdup(svalue);
	343	} else if(!strcmp(key, "local_host")) {
	344	svalue = va_arg(ap, char *);
	345	free(yss->local_host);
	346	yss->local_host = strdup(svalue);
	347	} else if(!strcmp(key, "conn_type")) {
	348	nvalue = va_arg(ap, int);
	349	yss->conn_type = nvalue;
	350	} else {
	351	WARNING(("Unknown key passed to yahoo_init, "
	352	"perhaps you didn't terminate the list "
	353	"with NULL"));
	354	}
	355	}
	356
	357	return yss;
	358	}
	359
	360	static void yahoo_free_server_settings(struct yahoo_server_settings *yss)
	361	{
	362	if(!yss)
	363	return;
	364
	365	free(yss->pager_host);
	366	free(yss->filetransfer_host);
	367	free(yss->webcam_host);
	368	free(yss->webcam_description);
	369	free(yss->local_host);
	370
	371	free(yss);
	372	}
	373
	374	static YList *conns=NULL;
	375	static YList *inputs=NULL;
	376	static int last_id=0;
	377
	378	static void add_to_list(struct yahoo_data *yd)
	379	{
	380	conns = y_list_prepend(conns, yd);
	381	}
	382	static struct yahoo_data * find_conn_by_id(int id)
	383	{
	384	YList *l;
	385	for(l = conns; l; l = y_list_next(l)) {
	386	struct yahoo_data *yd = l->data;
	387	if(yd->client_id == id)
	388	return yd;
	389	}
	390	return NULL;
	391	}
	392	static void del_from_list(struct yahoo_data *yd)
	393	{
	394	conns = y_list_remove(conns, yd);
	395	}
	396
	397	/* call repeatedly to get the next one */
	398	static struct yahoo_input_data * find_input_by_id(int id)
	399	{
	400	YList *l;
	401	for(l = inputs; l; l = y_list_next(l)) {
	402	struct yahoo_input_data *yid = l->data;
	403	if(yid->yd->client_id == id)
	404	return yid;
	405	}
	406	return NULL;
	407	}
	408
	409	static struct yahoo_input_data * find_input_by_id_and_webcam_user(int id, const char * who)
	410	{
	411	YList *l;
	412	LOG(("find_input_by_id_and_webcam_user"));
	413	for(l = inputs; l; l = y_list_next(l)) {
	414	struct yahoo_input_data *yid = l->data;
	415	if(yid->type == YAHOO_CONNECTION_WEBCAM && yid->yd->client_id == id
	416	&& yid->wcm &&
	417	((who && yid->wcm->user && !strcmp(who, yid->wcm->user)) \|\|
	418	!(yid->wcm->user && !who)))
	419	return yid;
	420	}
	421	return NULL;
	422	}
	423
	424	static struct yahoo_input_data * find_input_by_id_and_type(int id, enum yahoo_connection_type type)
	425	{
	426	YList *l;
	427	LOG(("find_input_by_id_and_type"));
	428	for(l = inputs; l; l = y_list_next(l)) {
	429	struct yahoo_input_data *yid = l->data;
	430	if(yid->type == type && yid->yd->client_id == id)
	431	return yid;
	432	}
	433	return NULL;
	434	}
	435
	436	static struct yahoo_input_data * find_input_by_id_and_fd(int id, int fd)
	437	{
	438	YList *l;
	439	LOG(("find_input_by_id_and_fd"));
	440	for(l = inputs; l; l = y_list_next(l)) {
	441	struct yahoo_input_data *yid = l->data;
	442	if(yid->fd == fd && yid->yd->client_id == id)
	443	return yid;
	444	}
	445	return NULL;
	446	}
	447
	448	static int count_inputs_with_id(int id)
	449	{
	450	int c=0;
	451	YList *l;
	452	LOG(("counting %d", id));
	453	for(l = inputs; l; l = y_list_next(l)) {
	454	struct yahoo_input_data *yid = l->data;
	455	if(yid->yd->client_id == id)
	456	c++;
	457	}
	458	LOG(("%d", c));
	459	return c;
	460	}
	461
	462
	463	extern char yahoo_crypt(char , char *);
	464
	465	/* Free a buddy list */
	466	static void yahoo_free_buddies(YList * list)
	467	{
	468	YList *l;
	469
	470	for(l = list; l; l = l->next)
	471	{
	472	struct yahoo_buddy *bud = l->data;
	473	if(!bud)
	474	continue;
	475
	476	FREE(bud->group);
	477	FREE(bud->id);
	478	FREE(bud->real_name);
	479	if(bud->yab_entry) {
	480	FREE(bud->yab_entry->fname);
	481	FREE(bud->yab_entry->lname);
	482	FREE(bud->yab_entry->nname);
	483	FREE(bud->yab_entry->id);
	484	FREE(bud->yab_entry->email);
	485	FREE(bud->yab_entry->hphone);
	486	FREE(bud->yab_entry->wphone);
	487	FREE(bud->yab_entry->mphone);
	488	FREE(bud->yab_entry);
	489	}
	490	FREE(bud);
	491	l->data = bud = NULL;
	492	}
	493
	494	y_list_free(list);
	495	}
	496
	497	/* Free an identities list */
	498	static void yahoo_free_identities(YList * list)
	499	{
	500	while (list) {
	501	YList *n = list;
	502	FREE(list->data);
	503	list = y_list_remove_link(list, list);
	504	y_list_free_1(n);
	505	}
	506	}
	507
	508	/* Free webcam data */
	509	static void yahoo_free_webcam(struct yahoo_webcam *wcm)
	510	{
	511	if (wcm) {
	512	FREE(wcm->user);
	513	FREE(wcm->server);
	514	FREE(wcm->key);
	515	FREE(wcm->description);
	516	FREE(wcm->my_ip);
	517	}
	518	FREE(wcm);
	519	}
	520
	521	static void yahoo_free_data(struct yahoo_data *yd)
	522	{
	523	FREE(yd->user);
	524	FREE(yd->password);
	525	FREE(yd->cookie_y);
	526	FREE(yd->cookie_t);
	527	FREE(yd->cookie_c);
	528	FREE(yd->login_cookie);
	529	FREE(yd->login_id);
	530
	531	yahoo_free_buddies(yd->buddies);
	532	yahoo_free_buddies(yd->ignore);
	533	yahoo_free_identities(yd->identities);
	534
	535	yahoo_free_server_settings(yd->server_settings);
	536
	537	FREE(yd);
	538	}
	539
	540	#define YAHOO_PACKET_HDRLEN (4 + 2 + 2 + 2 + 2 + 4 + 4)
	541
	542	static struct yahoo_packet *yahoo_packet_new(enum yahoo_service service,
	543	enum yahoo_status status, int id)
	544	{
	545	struct yahoo_packet *pkt = y_new0(struct yahoo_packet, 1);
	546
	547	pkt->service = service;
	548	pkt->status = status;
	549	pkt->id = id;
	550
	551	return pkt;
	552	}
	553
	554	static void yahoo_packet_hash(struct yahoo_packet pkt, int key, const char value)
	555	{
	556	struct yahoo_pair *pair = y_new0(struct yahoo_pair, 1);
	557	pair->key = key;
	558	pair->value = strdup(value);
	559	pkt->hash = y_list_append(pkt->hash, pair);
	560	}
	561
	562	static int yahoo_packet_length(struct yahoo_packet *pkt)
	563	{
	564	YList *l;
	565
	566	int len = 0;
	567
	568	for (l = pkt->hash; l; l = l->next) {
	569	struct yahoo_pair *pair = l->data;
	570	int tmp = pair->key;
	571	do {
	572	tmp /= 10;
	573	len++;
	574	} while (tmp);
	575	len += 2;
	576	len += strlen(pair->value);
	577	len += 2;
	578	}
	579
	580	return len;
	581	}
	582
	583	#define yahoo_put16(buf, data) ( \
	584	(*(buf) = (unsigned char)((data)>>8)&0xff), \
	585	(*((buf)+1) = (unsigned char)(data)&0xff), \
	586	2)
	587	#define yahoo_get16(buf) (((((buf))&0xff)<<8) + ((((buf)+1)) & 0xff))
	588	#define yahoo_put32(buf, data) ( \
	589	(*((buf)) = (unsigned char)((data)>>24)&0xff), \
	590	(*((buf)+1) = (unsigned char)((data)>>16)&0xff), \
	591	(*((buf)+2) = (unsigned char)((data)>>8)&0xff), \
	592	(*((buf)+3) = (unsigned char)(data)&0xff), \
	593	4)
	594	#define yahoo_get32(buf) ((((*(buf) )&0xff)<<24) + \
	595	(((*((buf)+1))&0xff)<<16) + \
	596	(((*((buf)+2))&0xff)<< 8) + \
	597	(((*((buf)+3))&0xff)))
	598
	599	static void yahoo_packet_read(struct yahoo_packet pkt, unsigned char data, int len)
	600	{
	601	int pos = 0;
	602
	603	while (pos + 1 < len) {
	604	char key, value = NULL;
	605	int accept;
	606	int x;
	607
	608	struct yahoo_pair *pair = y_new0(struct yahoo_pair, 1);
	609
	610	key = malloc(len + 1);
	611	x = 0;
	612	while (pos + 1 < len) {
	613	if (data[pos] == 0xc0 && data[pos + 1] == 0x80)
	614	break;
	615	key[x++] = data[pos++];
	616	}
	617	key[x] = 0;
	618	pos += 2;
	619	pair->key = strtol(key, NULL, 10);
	620	free(key);
	621
	622	/* Libyahoo2 developer(s) don't seem to have the time to fix
	623	this problem, so for now try to work around it:
	624
	625	Sometimes we receive an invalid packet with not any more
	626	data at this point. I don't know how to handle this in a
	627	clean way, but let's hope this is clean enough: */
	628
	629	if (pos + 1 < len) {
	630	accept = x;
	631	/* if x is 0 there was no key, so don't accept it */
	632	if (accept)
	633	value = malloc(len - pos + 1);
	634	x = 0;
	635	while (pos + 1 < len) {
	636	if (data[pos] == 0xc0 && data[pos + 1] == 0x80)
	637	break;
	638	if (accept)
	639	value[x++] = data[pos++];
	640	}
	641	if (accept)
	642	value[x] = 0;
	643	pos += 2;
	644	} else {
	645	accept = 0;
	646	}
	647
	648	if (accept) {
	649	pair->value = strdup(value);
	650	FREE(value);
	651	pkt->hash = y_list_append(pkt->hash, pair);
	652	DEBUG_MSG(("Key: %d \tValue: %s", pair->key, pair->value));
	653	} else {
	654	FREE(pair);
	655	}
	656	}
	657	}
	658
	659	static void yahoo_packet_write(struct yahoo_packet pkt, unsigned char data)
	660	{
	661	YList *l;
	662	int pos = 0;
	663
	664	for (l = pkt->hash; l; l = l->next) {
	665	struct yahoo_pair *pair = l->data;
	666	unsigned char buf[100];
	667
	668	snprintf((char *)buf, sizeof(buf), "%d", pair->key);
	669	strcpy((char )data + pos, (char )buf);
	670	pos += strlen((char *)buf);
	671	data[pos++] = 0xc0;
	672	data[pos++] = 0x80;
	673
	674	strcpy((char *)data + pos, pair->value);
	675	pos += strlen(pair->value);
	676	data[pos++] = 0xc0;
	677	data[pos++] = 0x80;
	678	}
	679	}
	680
	681	static void yahoo_dump_unhandled(struct yahoo_packet *pkt)
	682	{
	683	YList *l;
	684
	685	NOTICE(("Service: 0x%02x\tStatus: %d", pkt->service, pkt->status));
	686	for (l = pkt->hash; l; l = l->next) {
	687	struct yahoo_pair *pair = l->data;
	688	NOTICE(("\t%d => %s", pair->key, pair->value));
	689	}
	690	}
	691
	692
	693	static void yahoo_packet_dump(unsigned char *data, int len)
	694	{
	695	if(yahoo_get_log_level() >= YAHOO_LOG_DEBUG) {
	696	int i;
	697	for (i = 0; i < len; i++) {
	698	if ((i % 8 == 0) && i)
	699	YAHOO_CALLBACK(ext_yahoo_log)(" ");
	700	if ((i % 16 == 0) && i)
	701	YAHOO_CALLBACK(ext_yahoo_log)("\n");
	702	YAHOO_CALLBACK(ext_yahoo_log)("%02x ", data[i]);
	703	}
	704	YAHOO_CALLBACK(ext_yahoo_log)("\n");
	705	for (i = 0; i < len; i++) {
	706	if ((i % 8 == 0) && i)
	707	YAHOO_CALLBACK(ext_yahoo_log)(" ");
	708	if ((i % 16 == 0) && i)
	709	YAHOO_CALLBACK(ext_yahoo_log)("\n");
	710	if (isprint(data[i]))
	711	YAHOO_CALLBACK(ext_yahoo_log)(" %c ", data[i]);
	712	else
	713	YAHOO_CALLBACK(ext_yahoo_log)(" . ");
	714	}
	715	YAHOO_CALLBACK(ext_yahoo_log)("\n");
	716	}
	717	}
	718
	719	/* raw bytes in quasi-big-endian order to base 64 string (NUL-terminated) */
[812a413]	720	static void to_y64(unsigned char out, const unsigned char in, int inlen)
[b7d3cc34]	721	{
[7ed3199]	722	base64_encode_real(in, inlen, out, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._-");
[b7d3cc34]	723	}
	724
	725	static void yahoo_add_to_send_queue(struct yahoo_input_data yid, void data, int length)
	726	{
	727	struct data_queue *tx = y_new0(struct data_queue, 1);
	728	tx->queue = y_new0(unsigned char, length);
	729	tx->len = length;
	730	memcpy(tx->queue, data, length);
	731
	732	yid->txqueues = y_list_append(yid->txqueues, tx);
	733
	734	if(!yid->write_tag)
	735	yid->write_tag=YAHOO_CALLBACK(ext_yahoo_add_handler)(yid->yd->client_id, yid->fd, YAHOO_INPUT_WRITE, yid);
	736	}
	737
	738	static void yahoo_send_packet(struct yahoo_input_data yid, struct yahoo_packet pkt, int extra_pad)
	739	{
	740	int pktlen = yahoo_packet_length(pkt);
	741	int len = YAHOO_PACKET_HDRLEN + pktlen;
	742
	743	unsigned char *data;
	744	int pos = 0;
	745
	746	if (yid->fd < 0)
	747	return;
	748
	749	data = y_new0(unsigned char, len + 1);
	750
	751	memcpy(data + pos, "YMSG", 4); pos += 4;
[4fefb77]	752	pos += yahoo_put16(data + pos, YAHOO_PROTO_VER);
[b7d3cc34]	753	pos += yahoo_put16(data + pos, 0x0000);
	754	pos += yahoo_put16(data + pos, pktlen + extra_pad);
	755	pos += yahoo_put16(data + pos, pkt->service);
	756	pos += yahoo_put32(data + pos, pkt->status);
	757	pos += yahoo_put32(data + pos, pkt->id);
	758
	759	yahoo_packet_write(pkt, data + pos);
	760
	761	yahoo_packet_dump(data, len);
	762
[cfc8d58]	763	if( yid->type == YAHOO_CONNECTION_FT )
	764	yahoo_send_data(yid->fd, data, len);
	765	else
[ba16895]	766	yahoo_add_to_send_queue(yid, data, len);
[b7d3cc34]	767	FREE(data);
	768	}
	769
	770	static void yahoo_packet_free(struct yahoo_packet *pkt)
	771	{
	772	while (pkt->hash) {
	773	struct yahoo_pair *pair = pkt->hash->data;
	774	YList *tmp;
	775	FREE(pair->value);
	776	FREE(pair);
	777	tmp = pkt->hash;
	778	pkt->hash = y_list_remove_link(pkt->hash, pkt->hash);
	779	y_list_free_1(tmp);
	780	}
	781	FREE(pkt);
	782	}
	783
	784	static int yahoo_send_data(int fd, void *data, int len)
	785	{
	786	int ret;
	787	int e;
	788
	789	if (fd < 0)
	790	return -1;
	791
	792	yahoo_packet_dump(data, len);
	793
	794	do {
	795	ret = write(fd, data, len);
	796	} while(ret == -1 && errno==EINTR);
	797	e=errno;
	798
	799	if (ret == -1) {
	800	LOG(("wrote data: ERR %s", strerror(errno)));
	801	} else {
	802	LOG(("wrote data: OK"));
	803	}
	804
	805	errno=e;
	806	return ret;
	807	}
	808
	809	void yahoo_close(int id)
	810	{
	811	struct yahoo_data *yd = find_conn_by_id(id);
[52df5df]	812
[b7d3cc34]	813	if(!yd)
	814	return;
	815
	816	del_from_list(yd);
	817
	818	yahoo_free_data(yd);
	819	if(id == last_id)
	820	last_id--;
	821	}
	822
	823	static void yahoo_input_close(struct yahoo_input_data *yid)
	824	{
	825	inputs = y_list_remove(inputs, yid);
	826
	827	LOG(("yahoo_input_close(read)"));
	828	YAHOO_CALLBACK(ext_yahoo_remove_handler)(yid->yd->client_id, yid->read_tag);
	829	LOG(("yahoo_input_close(write)"));
	830	YAHOO_CALLBACK(ext_yahoo_remove_handler)(yid->yd->client_id, yid->write_tag);
	831	yid->read_tag = yid->write_tag = 0;
	832	if(yid->fd)
	833	close(yid->fd);
	834	yid->fd = 0;
	835	FREE(yid->rxqueue);
	836	if(count_inputs_with_id(yid->yd->client_id) == 0) {
	837	LOG(("closing %d", yid->yd->client_id));
	838	yahoo_close(yid->yd->client_id);
	839	}
	840	yahoo_free_webcam(yid->wcm);
	841	if(yid->wcd)
	842	FREE(yid->wcd);
	843	if(yid->ys) {
	844	FREE(yid->ys->lsearch_text);
	845	FREE(yid->ys);
	846	}
	847	FREE(yid);
	848	}
	849
	850	static int is_same_bud(const void * a, const void * b) {
	851	const struct yahoo_buddy *subject = a;
	852	const struct yahoo_buddy *object = b;
	853
	854	return strcmp(subject->id, object->id);
	855	}
	856
	857	static YList * bud_str2list(char *rawlist)
	858	{
	859	YList * l = NULL;
	860
	861	char **lines;
	862	char **split;
	863	char **buddies;
	864	char tmp, bud;
	865
	866	lines = y_strsplit(rawlist, "\n", -1);
	867	for (tmp = lines; *tmp; tmp++) {
	868	struct yahoo_buddy *newbud;
	869
	870	split = y_strsplit(*tmp, ":", 2);
	871	if (!split)
	872	continue;
	873	if (!split[0] \|\| !split[1]) {
	874	y_strfreev(split);
	875	continue;
	876	}
	877	buddies = y_strsplit(split[1], ",", -1);
	878
	879	for (bud = buddies; bud && *bud; bud++) {
	880	newbud = y_new0(struct yahoo_buddy, 1);
	881	newbud->id = strdup(*bud);
	882	newbud->group = strdup(split[0]);
	883
	884	if(y_list_find_custom(l, newbud, is_same_bud)) {
	885	FREE(newbud->id);
	886	FREE(newbud->group);
	887	FREE(newbud);
	888	continue;
	889	}
	890
	891	newbud->real_name = NULL;
	892
	893	l = y_list_append(l, newbud);
	894
	895	NOTICE(("Added buddy %s to group %s", newbud->id, newbud->group));
	896	}
	897
	898	y_strfreev(buddies);
	899	y_strfreev(split);
	900	}
	901	y_strfreev(lines);
	902
	903	return l;
	904	}
	905
	906	static char * getcookie(char *rawcookie)
	907	{
	908	char * cookie=NULL;
	909	char * tmpcookie;
	910	char * cookieend;
	911
	912	if (strlen(rawcookie) < 2)
	913	return NULL;
	914
	915	tmpcookie = strdup(rawcookie+2);
	916	cookieend = strchr(tmpcookie, ';');
	917
	918	if(cookieend)
	919	*cookieend = '\0';
	920
	921	cookie = strdup(tmpcookie);
	922	FREE(tmpcookie);
	923	/* cookieend=NULL; not sure why this was there since the value is not preserved in the stack -dd */
	924
	925	return cookie;
	926	}
	927
	928	static char * getlcookie(char *cookie)
	929	{
	930	char *tmp;
	931	char *tmpend;
	932	char *login_cookie = NULL;
	933
	934	tmpend = strstr(cookie, "n=");
	935	if(tmpend) {
	936	tmp = strdup(tmpend+2);
	937	tmpend = strchr(tmp, '&');
	938	if(tmpend)
	939	*tmpend='\0';
	940	login_cookie = strdup(tmp);
	941	FREE(tmp);
	942	}
	943
	944	return login_cookie;
	945	}
	946
	947	static void yahoo_process_notify(struct yahoo_input_data yid, struct yahoo_packet pkt)
	948	{
	949	struct yahoo_data *yd = yid->yd;
	950	char *msg = NULL;
	951	char *from = NULL;
[cfc8d58]	952	char *to = NULL;
[b7d3cc34]	953	int stat = 0;
	954	int accept = 0;
	955	char *ind = NULL;
	956	YList *l;
	957	for (l = pkt->hash; l; l = l->next) {
	958	struct yahoo_pair *pair = l->data;
	959	if (pair->key == 4)
	960	from = pair->value;
[cfc8d58]	961	if (pair->key == 5)
	962	to = pair->value;
[b7d3cc34]	963	if (pair->key == 49)
	964	msg = pair->value;
	965	if (pair->key == 13)
	966	stat = atoi(pair->value);
	967	if (pair->key == 14)
	968	ind = pair->value;
	969	if (pair->key == 16) { /* status == -1 */
	970	NOTICE((pair->value));
	971	return;
	972	}
	973
	974	}
	975
	976	if (!msg)
	977	return;
	978
	979	if (!strncasecmp(msg, "TYPING", strlen("TYPING")))
[cfc8d58]	980	YAHOO_CALLBACK(ext_yahoo_typing_notify)(yd->client_id, to, from, stat);
[b7d3cc34]	981	else if (!strncasecmp(msg, "GAME", strlen("GAME")))
[cfc8d58]	982	YAHOO_CALLBACK(ext_yahoo_game_notify)(yd->client_id, to, from, stat);
[b7d3cc34]	983	else if (!strncasecmp(msg, "WEBCAMINVITE", strlen("WEBCAMINVITE")))
	984	{
	985	if (!strcmp(ind, " ")) {
[cfc8d58]	986	YAHOO_CALLBACK(ext_yahoo_webcam_invite)(yd->client_id, to, from);
[b7d3cc34]	987	} else {
	988	accept = atoi(ind);
	989	/* accept the invitation (-1 = deny 1 = accept) */
	990	if (accept < 0)
	991	accept = 0;
[cfc8d58]	992	YAHOO_CALLBACK(ext_yahoo_webcam_invite_reply)(yd->client_id, to, from, accept);
[b7d3cc34]	993	}
	994	}
	995	else
	996	LOG(("Got unknown notification: %s", msg));
	997	}
	998
	999	static void yahoo_process_filetransfer(struct yahoo_input_data yid, struct yahoo_packet pkt)
	1000	{
	1001	struct yahoo_data *yd = yid->yd;
	1002	char *from=NULL;
	1003	char *to=NULL;
	1004	char *msg=NULL;
	1005	char *url=NULL;
	1006	long expires=0;
	1007
	1008	char *service=NULL;
	1009
	1010	char *filename=NULL;
	1011	unsigned long filesize=0L;
	1012
	1013	YList *l;
	1014	for (l = pkt->hash; l; l = l->next) {
	1015	struct yahoo_pair *pair = l->data;
	1016	if (pair->key == 4)
	1017	from = pair->value;
	1018	if (pair->key == 5)
	1019	to = pair->value;
	1020	if (pair->key == 14)
	1021	msg = pair->value;
	1022	if (pair->key == 20)
	1023	url = pair->value;
	1024	if (pair->key == 38)
	1025	expires = atol(pair->value);
	1026
	1027	if (pair->key == 27)
	1028	filename = pair->value;
	1029	if (pair->key == 28)
	1030	filesize = atol(pair->value);
	1031
	1032	if (pair->key == 49)
	1033	service = pair->value;
	1034	}
	1035
	1036	if(pkt->service == YAHOO_SERVICE_P2PFILEXFER) {
	1037	if(strcmp("FILEXFER", service) != 0) {
	1038	WARNING(("unhandled service 0x%02x", pkt->service));
	1039	yahoo_dump_unhandled(pkt);
	1040	return;
	1041	}
	1042	}
	1043
	1044	if(msg) {
	1045	char *tmp;
	1046	tmp = strchr(msg, '\006');
	1047	if(tmp)
	1048	*tmp = '\0';
	1049	}
	1050	if(url && from)
[cfc8d58]	1051	YAHOO_CALLBACK(ext_yahoo_got_file)(yd->client_id, to, from, url, expires, msg, filename, filesize);
[b7d3cc34]	1052
	1053	}
	1054
	1055	static void yahoo_process_conference(struct yahoo_input_data yid, struct yahoo_packet pkt)
	1056	{
	1057	struct yahoo_data *yd = yid->yd;
	1058	char *msg = NULL;
	1059	char *host = NULL;
	1060	char *who = NULL;
	1061	char *room = NULL;
	1062	char *id = NULL;
	1063	int utf8 = 0;
	1064	YList *members = NULL;
	1065	YList *l;
	1066
	1067	for (l = pkt->hash; l; l = l->next) {
	1068	struct yahoo_pair *pair = l->data;
	1069	if (pair->key == 50)
	1070	host = pair->value;
	1071
	1072	if (pair->key == 52) { /* invite */
	1073	members = y_list_append(members, strdup(pair->value));
	1074	}
	1075	if (pair->key == 53) /* logon */
	1076	who = pair->value;
	1077	if (pair->key == 54) /* decline */
	1078	who = pair->value;
	1079	if (pair->key == 55) /* unavailable (status == 2) */
	1080	who = pair->value;
	1081	if (pair->key == 56) /* logoff */
	1082	who = pair->value;
	1083
	1084	if (pair->key == 57)
	1085	room = pair->value;
	1086
	1087	if (pair->key == 58) /* join message */
	1088	msg = pair->value;
	1089	if (pair->key == 14) /* decline/conf message */
	1090	msg = pair->value;
	1091
	1092	if (pair->key == 13)
	1093	;
	1094	if (pair->key == 16) /* error */
	1095	msg = pair->value;
	1096
	1097	if (pair->key == 1) /* my id */
	1098	id = pair->value;
	1099	if (pair->key == 3) /* message sender */
	1100	who = pair->value;
	1101
	1102	if (pair->key == 97)
	1103	utf8 = atoi(pair->value);
	1104	}
	1105
	1106	if(!room)
	1107	return;
	1108
	1109	if(host) {
	1110	for(l = members; l; l = l->next) {
	1111	char * w = l->data;
	1112	if(!strcmp(w, host))
	1113	break;
	1114	}
	1115	if(!l)
	1116	members = y_list_append(members, strdup(host));
	1117	}
	1118	/* invite, decline, join, left, message -> status == 1 */
	1119
	1120	switch(pkt->service) {
	1121	case YAHOO_SERVICE_CONFINVITE:
	1122	if(pkt->status == 2)
	1123	;
	1124	else if(members)
[cfc8d58]	1125	YAHOO_CALLBACK(ext_yahoo_got_conf_invite)(yd->client_id, id, host, room, msg, members);
[b7d3cc34]	1126	else if(msg)
[cfc8d58]	1127	YAHOO_CALLBACK(ext_yahoo_error)(yd->client_id, msg, 0, E_CONFNOTAVAIL);
[b7d3cc34]	1128	break;
	1129	case YAHOO_SERVICE_CONFADDINVITE:
	1130	if(pkt->status == 2)
	1131	;
	1132	else
[cfc8d58]	1133	YAHOO_CALLBACK(ext_yahoo_got_conf_invite)(yd->client_id, id, host, room, msg, members);
[b7d3cc34]	1134	break;
	1135	case YAHOO_SERVICE_CONFDECLINE:
	1136	if(who)
[cfc8d58]	1137	YAHOO_CALLBACK(ext_yahoo_conf_userdecline)(yd->client_id, id, who, room, msg);
[b7d3cc34]	1138	break;
	1139	case YAHOO_SERVICE_CONFLOGON:
	1140	if(who)
[cfc8d58]	1141	YAHOO_CALLBACK(ext_yahoo_conf_userjoin)(yd->client_id, id, who, room);
[b7d3cc34]	1142	break;
	1143	case YAHOO_SERVICE_CONFLOGOFF:
	1144	if(who)
[cfc8d58]	1145	YAHOO_CALLBACK(ext_yahoo_conf_userleave)(yd->client_id, id, who, room);
[b7d3cc34]	1146	break;
	1147	case YAHOO_SERVICE_CONFMSG:
	1148	if(who)
[cfc8d58]	1149	YAHOO_CALLBACK(ext_yahoo_conf_message)(yd->client_id, id, who, room, msg, utf8);
[b7d3cc34]	1150	break;
	1151	}
	1152	}
	1153
	1154	static void yahoo_process_chat(struct yahoo_input_data yid, struct yahoo_packet pkt)
	1155	{
	1156	char *msg = NULL;
[cfc8d58]	1157	char *id = NULL;
[b7d3cc34]	1158	char *who = NULL;
	1159	char *room = NULL;
	1160	char *topic = NULL;
	1161	YList *members = NULL;
	1162	struct yahoo_chat_member *currentmember = NULL;
	1163	int msgtype = 1;
	1164	int utf8 = 0;
	1165	int firstjoin = 0;
	1166	int membercount = 0;
	1167	int chaterr=0;
	1168	YList *l;
	1169
	1170	yahoo_dump_unhandled(pkt);
	1171	for (l = pkt->hash; l; l = l->next) {
	1172	struct yahoo_pair *pair = l->data;
	1173
[cfc8d58]	1174	if (pair->key == 1) {
	1175	/* My identity */
	1176	id = pair->value;
	1177	}
	1178
[b7d3cc34]	1179	if (pair->key == 104) {
	1180	/* Room name */
	1181	room = pair->value;
	1182	}
	1183
	1184	if (pair->key == 105) {
	1185	/* Room topic */
	1186	topic = pair->value;
	1187	}
	1188
	1189	if (pair->key == 108) {
	1190	/* Number of members in this packet */
	1191	membercount = atoi(pair->value);
	1192	}
	1193
	1194	if (pair->key == 109) {
	1195	/* message sender */
	1196	who = pair->value;
	1197
	1198	if (pkt->service == YAHOO_SERVICE_CHATJOIN) {
	1199	currentmember = y_new0(struct yahoo_chat_member, 1);
	1200	currentmember->id = strdup(pair->value);
	1201	members = y_list_append(members, currentmember);
	1202	}
	1203	}
	1204
	1205	if (pair->key == 110) {
	1206	/* age */
	1207	if (pkt->service == YAHOO_SERVICE_CHATJOIN)
	1208	currentmember->age = atoi(pair->value);
	1209	}
	1210
	1211	if (pair->key == 113) {
	1212	/* attribs */
	1213	if (pkt->service == YAHOO_SERVICE_CHATJOIN)
	1214	currentmember->attribs = atoi(pair->value);
	1215	}
	1216
	1217	if (pair->key == 141) {
	1218	/* alias */
	1219	if (pkt->service == YAHOO_SERVICE_CHATJOIN)
	1220	currentmember->alias = strdup(pair->value);
	1221	}
	1222
	1223	if (pair->key == 142) {
	1224	/* location */
	1225	if (pkt->service == YAHOO_SERVICE_CHATJOIN)
	1226	currentmember->location = strdup(pair->value);
	1227	}
	1228
	1229
	1230	if (pair->key == 130) {
	1231	/* first join */
	1232	firstjoin = 1;
	1233	}
	1234
	1235	if (pair->key == 117) {
	1236	/* message */
	1237	msg = pair->value;
	1238	}
	1239
	1240	if (pair->key == 124) {
	1241	/* Message type */
	1242	msgtype = atoi(pair->value);
	1243	}
	1244	if (pair->key == 114) {
	1245	/* message error not sure what all the pair values mean */
	1246	/* but -1 means no session in room */
	1247	chaterr= atoi(pair->value);
	1248	}
	1249	}
	1250
	1251	if(!room) {
	1252	if (pkt->service == YAHOO_SERVICE_CHATLOGOUT) { /* yahoo originated chat logout */
[cfc8d58]	1253	YAHOO_CALLBACK(ext_yahoo_chat_yahoologout)(yid->yd->client_id, id);
[b7d3cc34]	1254	return ;
	1255	}
	1256	if (pkt->service == YAHOO_SERVICE_COMMENT && chaterr) {
[cfc8d58]	1257	YAHOO_CALLBACK(ext_yahoo_chat_yahooerror)(yid->yd->client_id, id);
	1258	return;
[b7d3cc34]	1259	}
	1260
	1261	WARNING(("We didn't get a room name, ignoring packet"));
	1262	return;
	1263	}
	1264
	1265	switch(pkt->service) {
	1266	case YAHOO_SERVICE_CHATJOIN:
	1267	if(y_list_length(members) != membercount) {
	1268	WARNING(("Count of members doesn't match No. of members we got"));
	1269	}
	1270	if(firstjoin && members) {
[cfc8d58]	1271	YAHOO_CALLBACK(ext_yahoo_chat_join)(yid->yd->client_id, id, room, topic, members, yid->fd);
[b7d3cc34]	1272	} else if(who) {
	1273	if(y_list_length(members) != 1) {
	1274	WARNING(("Got more than 1 member on a normal join"));
	1275	}
	1276	/* this should only ever have one, but just in case */
	1277	while(members) {
	1278	YList *n = members->next;
	1279	currentmember = members->data;
[cfc8d58]	1280	YAHOO_CALLBACK(ext_yahoo_chat_userjoin)(yid->yd->client_id, id, room, currentmember);
[b7d3cc34]	1281	y_list_free_1(members);
	1282	members=n;
	1283	}
	1284	}
	1285	break;
	1286	case YAHOO_SERVICE_CHATEXIT:
	1287	if(who) {
[cfc8d58]	1288	YAHOO_CALLBACK(ext_yahoo_chat_userleave)(yid->yd->client_id, id, room, who);
[b7d3cc34]	1289	}
	1290	break;
	1291	case YAHOO_SERVICE_COMMENT:
	1292	if(who) {
[cfc8d58]	1293	YAHOO_CALLBACK(ext_yahoo_chat_message)(yid->yd->client_id, id, who, room, msg, msgtype, utf8);
[b7d3cc34]	1294	}
	1295	break;
	1296	}
	1297	}
	1298
	1299	static void yahoo_process_message(struct yahoo_input_data yid, struct yahoo_packet pkt)
	1300	{
	1301	struct yahoo_data *yd = yid->yd;
	1302	YList *l;
	1303	YList * messages = NULL;
	1304
	1305	struct m {
	1306	int i_31;
	1307	int i_32;
	1308	char *to;
	1309	char *from;
	1310	long tm;
	1311	char *msg;
	1312	int utf8;
	1313	} *message = y_new0(struct m, 1);
	1314
	1315	for (l = pkt->hash; l; l = l->next) {
	1316	struct yahoo_pair *pair = l->data;
	1317	if (pair->key == 1 \|\| pair->key == 4)
	1318	{
	1319	if(!message->from)
	1320	message->from = pair->value;
	1321	}
	1322	else if (pair->key == 5)
	1323	message->to = pair->value;
	1324	else if (pair->key == 15)
	1325	message->tm = strtol(pair->value, NULL, 10);
	1326	else if (pair->key == 97)
	1327	message->utf8 = atoi(pair->value);
	1328	/* user message / / sys message */
	1329	else if (pair->key == 14 \|\| pair->key == 16)
	1330	message->msg = pair->value;
	1331	else if (pair->key == 31) {
	1332	if(message->i_31) {
	1333	messages = y_list_append(messages, message);
	1334	message = y_new0(struct m, 1);
	1335	}
	1336	message->i_31 = atoi(pair->value);
	1337	}
	1338	else if (pair->key == 32)
	1339	message->i_32 = atoi(pair->value);
	1340	else
	1341	LOG(("yahoo_process_message: status: %d, key: %d, value: %s",
	1342	pkt->status, pair->key, pair->value));
	1343	}
	1344
	1345	messages = y_list_append(messages, message);
	1346
	1347	for (l = messages; l; l=l->next) {
	1348	message = l->data;
	1349	if (pkt->service == YAHOO_SERVICE_SYSMESSAGE) {
	1350	YAHOO_CALLBACK(ext_yahoo_system_message)(yd->client_id, message->msg);
	1351	} else if (pkt->status <= 2 \|\| pkt->status == 5) {
[cfc8d58]	1352	YAHOO_CALLBACK(ext_yahoo_got_im)(yd->client_id, message->to, message->from, message->msg, message->tm, pkt->status, message->utf8);
[b7d3cc34]	1353	} else if (pkt->status == 0xffffffff) {
[cfc8d58]	1354	YAHOO_CALLBACK(ext_yahoo_error)(yd->client_id, message->msg, 0, E_SYSTEM);
[b7d3cc34]	1355	}
	1356	free(message);
	1357	}
	1358
	1359	y_list_free(messages);
	1360	}
	1361
	1362
	1363	static void yahoo_process_status(struct yahoo_input_data yid, struct yahoo_packet pkt)
	1364	{
	1365	YList *l;
	1366	struct yahoo_data *yd = yid->yd;
[cfc8d58]	1367
	1368	struct user
	1369	{
	1370	char name; / 7 name */
	1371	int state; /* 10 state */
	1372	int flags; /* 13 flags, bit 0 = pager, bit 1 = chat, bit 2 = game */
	1373	int mobile; /* 60 mobile */
	1374	char msg; / 19 custom status message */
	1375	int away; /* 47 away (or invisible)*/
	1376	int buddy_session; /* 11 state */
	1377	int f17; /* 17 in chat? then what about flags? */
	1378	int idle; /* 137 seconds idle */
	1379	int f138; /* 138 state */
	1380	char f184; / 184 state */
	1381	int f192; /* 192 state */
	1382	int f10001; /* 10001 state */
	1383	int f10002; /* 10002 state */
	1384	int f198; /* 198 state */
	1385	char f197; / 197 state */
	1386	char f205; / 205 state */
	1387	int f213; /* 213 state */
	1388	} *u;
	1389
	1390	YList *users = 0;
[b7d3cc34]	1391
[cfc8d58]	1392	if (pkt->service == YAHOO_SERVICE_LOGOFF && pkt->status == -1) {
[b7d3cc34]	1393	YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, YAHOO_LOGIN_DUPL, NULL);
	1394	return;
	1395	}
	1396
	1397	for (l = pkt->hash; l; l = l->next) {
	1398	struct yahoo_pair *pair = l->data;
	1399
	1400	switch (pair->key) {
	1401	case 0: /* we won't actually do anything with this */
	1402	NOTICE(("key %d:%s", pair->key, pair->value));
	1403	break;
	1404	case 1: /* we don't get the full buddy list here. */
	1405	if (!yd->logged_in) {
	1406	yd->logged_in = TRUE;
	1407	if(yd->current_status < 0)
	1408	yd->current_status = yd->initial_status;
	1409	YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, YAHOO_LOGIN_OK, NULL);
	1410	}
	1411	break;
	1412	case 8: /* how many online buddies we have */
	1413	NOTICE(("key %d:%s", pair->key, pair->value));
	1414	break;
	1415	case 7: /* the current buddy */
[cfc8d58]	1416	u = y_new0(struct user, 1);
	1417	u->name = pair->value;
	1418	users = y_list_prepend(users, u);
[b7d3cc34]	1419	break;
	1420	case 10: /* state */
[cfc8d58]	1421	((struct user*)users->data)->state = strtol(pair->value, NULL, 10);
[b7d3cc34]	1422	break;
	1423	case 19: /* custom status message */
[cfc8d58]	1424	((struct user*)users->data)->msg = pair->value;
[b7d3cc34]	1425	break;
	1426	case 47: /* is it an away message or not */
[cfc8d58]	1427	((struct user*)users->data)->away = atoi(pair->value);
[b7d3cc34]	1428	break;
	1429	case 137: /* seconds idle */
[cfc8d58]	1430	((struct user*)users->data)->idle = atoi(pair->value);
[b7d3cc34]	1431	break;
[cfc8d58]	1432	case 11: /* this is the buddy's session id */
	1433	((struct user*)users->data)->buddy_session = atoi(pair->value);
[b7d3cc34]	1434	break;
	1435	case 17: /* in chat? */
[cfc8d58]	1436	((struct user*)users->data)->f17 = atoi(pair->value);
[b7d3cc34]	1437	break;
[cfc8d58]	1438	case 13: /* bitmask, bit 0 = pager, bit 1 = chat, bit 2 = game */
	1439	((struct user*)users->data)->flags = atoi(pair->value);
[b7d3cc34]	1440	break;
[cfc8d58]	1441	case 60: /* SMS -> 1 MOBILE USER */
[b7d3cc34]	1442	/* sometimes going offline makes this 2, but invisible never sends it */
[cfc8d58]	1443	((struct user*)users->data)->mobile = atoi(pair->value);
	1444	break;
	1445	case 138:
	1446	((struct user*)users->data)->f138 = atoi(pair->value);
	1447	break;
	1448	case 184:
	1449	((struct user*)users->data)->f184 = pair->value;
	1450	break;
	1451	case 192:
	1452	((struct user*)users->data)->f192 = atoi(pair->value);
	1453	break;
	1454	case 10001:
	1455	((struct user*)users->data)->f10001 = atoi(pair->value);
	1456	break;
	1457	case 10002:
	1458	((struct user*)users->data)->f10002 = atoi(pair->value);
	1459	break;
	1460	case 198:
	1461	((struct user*)users->data)->f198 = atoi(pair->value);
	1462	break;
	1463	case 197:
	1464	((struct user*)users->data)->f197 = pair->value;
	1465	break;
	1466	case 205:
	1467	((struct user*)users->data)->f205 = pair->value;
	1468	break;
	1469	case 213:
	1470	((struct user*)users->data)->f213 = atoi(pair->value);
	1471	break;
[b7d3cc34]	1472	case 16: /* Custom error message */
[cfc8d58]	1473	YAHOO_CALLBACK(ext_yahoo_error)(yd->client_id, pair->value, 0, E_CUSTOM);
[b7d3cc34]	1474	break;
	1475	default:
	1476	WARNING(("unknown status key %d:%s", pair->key, pair->value));
	1477	break;
	1478	}
	1479	}
[cfc8d58]	1480
	1481	while (users) {
	1482	YList *t = users;
	1483	struct user *u = users->data;
	1484
	1485	if (u->name != NULL) {
[ba16895]	1486	if (pkt->service == YAHOO_SERVICE_LOGOFF) { /* \|\| u->flags == 0) { Not in YMSG16 */
[cfc8d58]	1487	YAHOO_CALLBACK(ext_yahoo_status_changed)(yd->client_id, u->name, YAHOO_STATUS_OFFLINE, NULL, 1, 0, 0);
	1488	} else {
[ba16895]	1489	/* Key 47 always seems to be 1 for YMSG16 */
	1490	if(!u->state)
	1491	u->away = 0;
	1492	else
	1493	u->away = 1;
	1494
[cfc8d58]	1495	YAHOO_CALLBACK(ext_yahoo_status_changed)(yd->client_id, u->name, u->state, u->msg, u->away, u->idle, u->mobile);
	1496	}
	1497	}
	1498
	1499	users = y_list_remove_link(users, users);
	1500	y_list_free_1(t);
	1501	FREE(u);
	1502	}
[b7d3cc34]	1503	}
	1504
[4fefb77]	1505	static void yahoo_process_buddy_list(struct yahoo_input_data yid, struct yahoo_packet pkt)
	1506	{
	1507	struct yahoo_data *yd = yid->yd;
	1508	YList *l;
	1509	int last_packet = 0;
	1510	char *cur_group = NULL;
	1511	struct yahoo_buddy *newbud = NULL;
	1512
	1513	/* we could be getting multiple packets here */
	1514	for (l = pkt->hash; l; l = l->next) {
	1515	struct yahoo_pair *pair = l->data;
	1516
	1517	switch(pair->key) {
	1518	case 300:
	1519	case 301:
	1520	case 302:
	1521	case 303:
	1522	if ( 315 == atoi(pair->value) )
	1523	last_packet = 1;
	1524	break;
	1525	case 65:
[c3e349e]	1526	g_free(cur_group);
[4fefb77]	1527	cur_group = strdup(pair->value);
	1528	break;
	1529	case 7:
	1530	newbud = y_new0(struct yahoo_buddy, 1);
	1531	newbud->id = strdup(pair->value);
[ccba980]	1532	if (cur_group) {
[4fefb77]	1533	newbud->group = strdup(cur_group);
[ccba980]	1534	} else {
	1535	YList *last;
	1536	struct yahoo_buddy *lastbud;
	1537
	1538	for (last = yd->buddies; last && last->next; last = last->next);
	1539	if (last) {
	1540	lastbud = last->data;
	1541	newbud->group = strdup(lastbud->group);
	1542	} else {
	1543	newbud->group = strdup("Buddies");
	1544	}
[4fefb77]	1545	}
	1546
	1547	yd->buddies = y_list_append(yd->buddies, newbud);
	1548
	1549	break;
	1550	}
	1551	}
[c3e349e]	1552
	1553	g_free(cur_group);
[4fefb77]	1554
	1555	/* we could be getting multiple packets here */
	1556	if (last_packet)
	1557	return;
	1558
	1559	YAHOO_CALLBACK(ext_yahoo_got_buddies)(yd->client_id, yd->buddies);
	1560
	1561	/*** We login at the very end of the packet communication */
	1562	if (!yd->logged_in) {
	1563	yd->logged_in = TRUE;
	1564	if(yd->current_status < 0)
	1565	yd->current_status = yd->initial_status;
	1566	YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, YAHOO_LOGIN_OK, NULL);
	1567	}
	1568	}
	1569
[b7d3cc34]	1570	static void yahoo_process_list(struct yahoo_input_data yid, struct yahoo_packet pkt)
	1571	{
	1572	struct yahoo_data *yd = yid->yd;
	1573	YList *l;
	1574
	1575	if (!yd->logged_in) {
	1576	yd->logged_in = TRUE;
	1577	if(yd->current_status < 0)
	1578	yd->current_status = yd->initial_status;
	1579	YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, YAHOO_LOGIN_OK, NULL);
	1580	}
	1581
	1582	for (l = pkt->hash; l; l = l->next) {
	1583	struct yahoo_pair *pair = l->data;
	1584
	1585	switch(pair->key) {
	1586	case 87: /* buddies */
	1587	if(!yd->rawbuddylist)
	1588	yd->rawbuddylist = strdup(pair->value);
	1589	else {
	1590	yd->rawbuddylist = y_string_append(yd->rawbuddylist, pair->value);
	1591	}
	1592	break;
	1593
	1594	case 88: /* ignore list */
	1595	if(!yd->ignorelist)
	1596	yd->ignorelist = strdup("Ignore:");
	1597	yd->ignorelist = y_string_append(yd->ignorelist, pair->value);
	1598	break;
	1599
	1600	case 89: /* identities */
	1601	{
	1602	char **identities = y_strsplit(pair->value, ",", -1);
	1603	int i;
	1604	for(i=0; identities[i]; i++)
	1605	yd->identities = y_list_append(yd->identities,
	1606	strdup(identities[i]));
	1607	y_strfreev(identities);
	1608	}
	1609	YAHOO_CALLBACK(ext_yahoo_got_identities)(yd->client_id, yd->identities);
	1610	break;
	1611	case 59: /* cookies */
	1612	if(yd->ignorelist) {
	1613	yd->ignore = bud_str2list(yd->ignorelist);
	1614	FREE(yd->ignorelist);
	1615	YAHOO_CALLBACK(ext_yahoo_got_ignore)(yd->client_id, yd->ignore);
	1616	}
	1617	if(yd->rawbuddylist) {
	1618	yd->buddies = bud_str2list(yd->rawbuddylist);
	1619	FREE(yd->rawbuddylist);
	1620	YAHOO_CALLBACK(ext_yahoo_got_buddies)(yd->client_id, yd->buddies);
	1621	}
	1622
	1623	if(pair->value[0]=='Y') {
	1624	FREE(yd->cookie_y);
	1625	FREE(yd->login_cookie);
	1626
	1627	yd->cookie_y = getcookie(pair->value);
	1628	yd->login_cookie = getlcookie(yd->cookie_y);
	1629
	1630	} else if(pair->value[0]=='T') {
	1631	FREE(yd->cookie_t);
	1632	yd->cookie_t = getcookie(pair->value);
	1633
	1634	} else if(pair->value[0]=='C') {
	1635	FREE(yd->cookie_c);
	1636	yd->cookie_c = getcookie(pair->value);
	1637	}
	1638
[4fefb77]	1639	if(yd->cookie_y && yd->cookie_t)
[b7d3cc34]	1640	YAHOO_CALLBACK(ext_yahoo_got_cookies)(yd->client_id);
	1641
	1642	break;
	1643	case 3: /* my id */
	1644	case 90: /* 1 */
	1645	case 100: /* 0 */
	1646	case 101: /* NULL */
	1647	case 102: /* NULL */
	1648	case 93: /* 86400/1440 */
	1649	break;
	1650	}
	1651	}
	1652	}
	1653
	1654	static void yahoo_process_verify(struct yahoo_input_data yid, struct yahoo_packet pkt)
	1655	{
	1656	struct yahoo_data *yd = yid->yd;
	1657
	1658	if(pkt->status != 0x01) {
	1659	DEBUG_MSG(("expected status: 0x01, got: %d", pkt->status));
	1660	YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, YAHOO_LOGIN_LOCK, "");
	1661	return;
	1662	}
	1663
	1664	pkt = yahoo_packet_new(YAHOO_SERVICE_AUTH, YAHOO_STATUS_AVAILABLE, yd->session_id);
	1665
	1666	yahoo_packet_hash(pkt, 1, yd->user);
	1667	yahoo_send_packet(yid, pkt, 0);
	1668
	1669	yahoo_packet_free(pkt);
	1670
	1671	}
	1672
[cfc8d58]	1673	static void yahoo_process_picture_checksum( struct yahoo_input_data yid, struct yahoo_packet pkt)
	1674	{
	1675	struct yahoo_data *yd = yid->yd;
	1676	char *from = NULL;
	1677	char *to = NULL;
	1678	int checksum = 0;
	1679	YList *l;
	1680
	1681	for(l = pkt->hash; l; l = l->next)
	1682	{
	1683	struct yahoo_pair *pair = l->data;
	1684
	1685	switch(pair->key)
	1686	{
	1687	case 1:
	1688	case 4:
	1689	from = pair->value;
	1690	case 5:
	1691	to = pair->value;
	1692	break;
	1693	case 212:
	1694	break;
	1695	case 192:
	1696	checksum = atoi( pair->value );
	1697	break;
	1698	}
	1699	}
	1700
	1701	YAHOO_CALLBACK(ext_yahoo_got_buddyicon_checksum)(yd->client_id,to,from,checksum);
	1702	}
	1703
	1704	static void yahoo_process_picture(struct yahoo_input_data yid, struct yahoo_packet pkt)
	1705	{
	1706	struct yahoo_data *yd = yid->yd;
	1707	char *url = NULL;
	1708	char *from = NULL;
	1709	char *to = NULL;
	1710	int status = 0;
	1711	int checksum = 0;
	1712	YList *l;
	1713
	1714	for(l = pkt->hash; l; l = l->next)
	1715	{
	1716	struct yahoo_pair *pair = l->data;
	1717
	1718	switch(pair->key)
	1719	{
	1720	case 1:
	1721	case 4: /* sender */
	1722	from = pair->value;
	1723	break;
	1724	case 5: /* we */
	1725	to = pair->value;
	1726	break;
	1727	case 13: /* request / sending */
	1728	status = atoi( pair->value );
	1729	break;
	1730	case 20: /* url */
	1731	url = pair->value;
	1732	break;
	1733	case 192: /checksum /
	1734	checksum = atoi( pair->value );
	1735	break;
	1736	}
	1737	}
	1738
	1739	switch( status )
	1740	{
	1741	case 1: /* this is a request, ignore for now */
	1742	YAHOO_CALLBACK(ext_yahoo_got_buddyicon_request)(yd->client_id, to, from);
	1743	break;
	1744	case 2: /* this is cool - we get a picture :) */
	1745	YAHOO_CALLBACK(ext_yahoo_got_buddyicon)(yd->client_id,to, from, url, checksum);
	1746	break;
	1747	}
	1748	}
	1749
	1750	static void yahoo_process_picture_upload(struct yahoo_input_data yid, struct yahoo_packet pkt)
	1751	{
	1752	struct yahoo_data *yd = yid->yd;
	1753	YList *l;
	1754	char *url = NULL;
	1755
	1756	if ( pkt->status != 1 )
	1757	return; /* something went wrong */
	1758
	1759	for(l = pkt->hash; l; l = l->next)
	1760	{
	1761	struct yahoo_pair *pair = l->data;
	1762
	1763	switch(pair->key)
	1764	{
	1765	case 5: /* we */
	1766	break;
	1767	case 20: /* url */
	1768	url = pair->value;
	1769	break;
	1770	case 27: /* local filename */
	1771	break;
	1772	case 38: /* time */
	1773	break;
	1774	}
	1775	}
	1776
	1777	YAHOO_CALLBACK(ext_yahoo_buddyicon_uploaded)(yd->client_id, url);
	1778	}
	1779
[b7d3cc34]	1780	static void yahoo_process_auth_pre_0x0b(struct yahoo_input_data *yid,
	1781	const char seed, const char sn)
	1782	{
	1783	struct yahoo_data *yd = yid->yd;
	1784
	1785	/* So, Yahoo has stopped supporting its older clients in India, and
	1786	* undoubtedly will soon do so in the rest of the world.
	1787	*
	1788	* The new clients use this authentication method. I warn you in
	1789	* advance, it's bizzare, convoluted, inordinately complicated.
	1790	* It's also no more secure than crypt() was. The only purpose this
	1791	* scheme could serve is to prevent third part clients from connecting
	1792	* to their servers.
	1793	*
	1794	* Sorry, Yahoo.
	1795	*/
	1796
	1797	struct yahoo_packet *pack;
	1798
	1799	md5_byte_t result[16];
	1800	md5_state_t ctx;
	1801	char *crypt_result;
	1802	unsigned char *password_hash = malloc(25);
	1803	unsigned char *crypt_hash = malloc(25);
	1804	unsigned char *hash_string_p = malloc(50 + strlen(sn));
	1805	unsigned char *hash_string_c = malloc(50 + strlen(sn));
	1806
	1807	char checksum;
	1808
	1809	int sv;
	1810
	1811	unsigned char *result6 = malloc(25);
	1812	unsigned char *result96 = malloc(25);
	1813
	1814	sv = seed[15];
	1815	sv = (sv % 8) % 5;
	1816
	1817	md5_init(&ctx);
	1818	md5_append(&ctx, (md5_byte_t *)yd->password, strlen(yd->password));
	1819	md5_finish(&ctx, result);
	1820	to_y64(password_hash, result, 16);
	1821
	1822	md5_init(&ctx);
	1823	crypt_result = yahoo_crypt(yd->password, "$1$_2S43d5f$");
	1824	md5_append(&ctx, (md5_byte_t *)crypt_result, strlen(crypt_result));
	1825	md5_finish(&ctx, result);
	1826	to_y64(crypt_hash, result, 16);
	1827	free(crypt_result);
	1828
	1829	switch (sv) {
	1830	case 0:
	1831	checksum = seed[seed[7] % 16];
	1832	snprintf((char *)hash_string_p, strlen(sn) + 50,
	1833	"%c%s%s%s", checksum, password_hash, yd->user, seed);
	1834	snprintf((char *)hash_string_c, strlen(sn) + 50,
	1835	"%c%s%s%s", checksum, crypt_hash, yd->user, seed);
	1836	break;
	1837	case 1:
	1838	checksum = seed[seed[9] % 16];
	1839	snprintf((char *)hash_string_p, strlen(sn) + 50,
	1840	"%c%s%s%s", checksum, yd->user, seed, password_hash);
	1841	snprintf((char *)hash_string_c, strlen(sn) + 50,
	1842	"%c%s%s%s", checksum, yd->user, seed, crypt_hash);
	1843	break;
	1844	case 2:
	1845	checksum = seed[seed[15] % 16];
	1846	snprintf((char *)hash_string_p, strlen(sn) + 50,
	1847	"%c%s%s%s", checksum, seed, password_hash, yd->user);
	1848	snprintf((char *)hash_string_c, strlen(sn) + 50,
	1849	"%c%s%s%s", checksum, seed, crypt_hash, yd->user);
	1850	break;
	1851	case 3:
	1852	checksum = seed[seed[1] % 16];
	1853	snprintf((char *)hash_string_p, strlen(sn) + 50,
	1854	"%c%s%s%s", checksum, yd->user, password_hash, seed);
	1855	snprintf((char *)hash_string_c, strlen(sn) + 50,
	1856	"%c%s%s%s", checksum, yd->user, crypt_hash, seed);
	1857	break;
	1858	case 4:
	1859	checksum = seed[seed[3] % 16];
	1860	snprintf((char *)hash_string_p, strlen(sn) + 50,
	1861	"%c%s%s%s", checksum, password_hash, seed, yd->user);
	1862	snprintf((char *)hash_string_c, strlen(sn) + 50,
	1863	"%c%s%s%s", checksum, crypt_hash, seed, yd->user);
	1864	break;
	1865	}
	1866
	1867	md5_init(&ctx);
	1868	md5_append(&ctx, (md5_byte_t )hash_string_p, strlen((char )hash_string_p));
	1869	md5_finish(&ctx, result);
	1870	to_y64(result6, result, 16);
	1871
	1872	md5_init(&ctx);
	1873	md5_append(&ctx, (md5_byte_t )hash_string_c, strlen((char )hash_string_c));
	1874	md5_finish(&ctx, result);
	1875	to_y64(result96, result, 16);
	1876
	1877	pack = yahoo_packet_new(YAHOO_SERVICE_AUTHRESP, yd->initial_status, yd->session_id);
	1878	yahoo_packet_hash(pack, 0, yd->user);
	1879	yahoo_packet_hash(pack, 6, (char *)result6);
	1880	yahoo_packet_hash(pack, 96, (char *)result96);
	1881	yahoo_packet_hash(pack, 1, yd->user);
	1882
	1883	yahoo_send_packet(yid, pack, 0);
	1884
	1885	FREE(result6);
	1886	FREE(result96);
	1887	FREE(password_hash);
	1888	FREE(crypt_hash);
	1889	FREE(hash_string_p);
	1890	FREE(hash_string_c);
	1891
	1892	yahoo_packet_free(pack);
	1893
	1894	}
	1895
	1896	/*
	1897	* New auth protocol cracked by Cerulean Studios and sent in to Gaim
	1898	*/
	1899	static void yahoo_process_auth_0x0b(struct yahoo_input_data yid, const char seed, const char *sn)
	1900	{
	1901	struct yahoo_packet *pack = NULL;
	1902	struct yahoo_data *yd = yid->yd;
	1903
	1904	md5_byte_t result[16];
	1905	md5_state_t ctx;
	1906
[77bfd07]	1907	sha1_state_t ctx1;
	1908	sha1_state_t ctx2;
[b7d3cc34]	1909
	1910	char *alphabet1 = "FBZDWAGHrJTLMNOPpRSKUVEXYChImkwQ";
	1911	char *alphabet2 = "F0E1D2C3B4A59687abcdefghijklmnop";
	1912
	1913	char *challenge_lookup = "qzec2tb3um1olpar8whx4dfgijknsvy5";
	1914	char operand_lookup = "+\|&%/^-";
	1915	char *delimit_lookup = ",;";
	1916
	1917	unsigned char *password_hash = malloc(25);
	1918	unsigned char *crypt_hash = malloc(25);
	1919	char *crypt_result = NULL;
	1920	unsigned char pass_hash_xor1[64];
	1921	unsigned char pass_hash_xor2[64];
	1922	unsigned char crypt_hash_xor1[64];
	1923	unsigned char crypt_hash_xor2[64];
	1924	unsigned char chal[7];
	1925	char resp_6[100];
	1926	char resp_96[100];
	1927
	1928	unsigned char digest1[20];
	1929	unsigned char digest2[20];
	1930	unsigned char magic_key_char[4];
	1931	const unsigned char *magic_ptr;
	1932
	1933	unsigned int magic[64];
	1934	unsigned int magic_work=0;
	1935
	1936	char comparison_src[20];
	1937
	1938	int x, j, i;
	1939	int cnt = 0;
	1940	int magic_cnt = 0;
	1941	int magic_len;
	1942	int depth =0, table =0;
	1943
	1944	memset(&pass_hash_xor1, 0, 64);
	1945	memset(&pass_hash_xor2, 0, 64);
	1946	memset(&crypt_hash_xor1, 0, 64);
	1947	memset(&crypt_hash_xor2, 0, 64);
	1948	memset(&digest1, 0, 20);
	1949	memset(&digest2, 0, 20);
	1950	memset(&magic, 0, 64);
	1951	memset(&resp_6, 0, 100);
	1952	memset(&resp_96, 0, 100);
	1953	memset(&magic_key_char, 0, 4);
	1954
	1955	/*
	1956	* Magic: Phase 1. Generate what seems to be a 30
	1957	* byte value (could change if base64
	1958	* ends up differently? I don't remember and I'm
	1959	* tired, so use a 64 byte buffer.
	1960	*/
	1961
	1962	magic_ptr = (unsigned char *)seed;
	1963
[77bfd07]	1964	while (*magic_ptr != 0) {
[b7d3cc34]	1965	char *loc;
	1966
	1967	/* Ignore parentheses. */
	1968
	1969	if (magic_ptr == '(' \|\| magic_ptr == ')') {
	1970	magic_ptr++;
	1971	continue;
	1972	}
	1973
	1974	/* Characters and digits verify against
	1975	the challenge lookup.
	1976	*/
	1977
	1978	if (isalpha(magic_ptr) \|\| isdigit(magic_ptr)) {
	1979	loc = strchr(challenge_lookup, *magic_ptr);
	1980	if (!loc) {
	1981	/* This isn't good */
	1982	continue;
	1983	}
	1984
	1985	/* Get offset into lookup table and lsh 3. */
	1986
	1987	magic_work = loc - challenge_lookup;
	1988	magic_work <<= 3;
	1989
	1990	magic_ptr++;
	1991	continue;
	1992	} else {
	1993	unsigned int local_store;
	1994
	1995	loc = strchr(operand_lookup, *magic_ptr);
	1996	if (!loc) {
	1997	/* Also not good. */
	1998	continue;
	1999	}
	2000
	2001	local_store = loc - operand_lookup;
	2002
	2003	/* Oops; how did this happen? */
	2004	if (magic_cnt >= 64)
	2005	break;
	2006
	2007	magic[magic_cnt++] = magic_work \| local_store;
	2008	magic_ptr++;
	2009	continue;
	2010	}
	2011	}
	2012
	2013	magic_len = magic_cnt;
	2014	magic_cnt = 0;
	2015
	2016	/* Magic: Phase 2. Take generated magic value and
	2017	* sprinkle fairy dust on the values. */
	2018
	2019	for (magic_cnt = magic_len-2; magic_cnt >= 0; magic_cnt--) {
	2020	unsigned char byte1;
	2021	unsigned char byte2;
	2022
	2023	/* Bad. Abort.
	2024	*/
	2025	if (magic_cnt >= magic_len) {
	2026	WARNING(("magic_cnt(%d) magic_len(%d)", magic_cnt, magic_len))
	2027	break;
	2028	}
	2029
	2030	byte1 = magic[magic_cnt];
	2031	byte2 = magic[magic_cnt+1];
	2032
	2033	byte1 *= 0xcd;
	2034	byte1 ^= byte2;
	2035
	2036	magic[magic_cnt+1] = byte1;
	2037	}
	2038
	2039	/* Magic: Phase 3. This computes 20 bytes. The first 4 bytes are used as our magic
	2040	* key (and may be changed later); the next 16 bytes are an MD5 sum of the magic key
	2041	* plus 3 bytes. The 3 bytes are found by looping, and they represent the offsets
	2042	* into particular functions we'll later call to potentially alter the magic key.
	2043	*
	2044	* %-)
	2045	*/
	2046
	2047	magic_cnt = 1;
	2048	x = 0;
	2049
	2050	do {
	2051	unsigned int bl = 0;
	2052	unsigned int cl = magic[magic_cnt++];
	2053
	2054	if (magic_cnt >= magic_len)
	2055	break;
	2056
	2057	if (cl > 0x7F) {
	2058	if (cl < 0xe0)
	2059	bl = cl = (cl & 0x1f) << 6;
	2060	else {
	2061	bl = magic[magic_cnt++];
	2062	cl = (cl & 0x0f) << 6;
	2063	bl = ((bl & 0x3f) + cl) << 6;
	2064	}
	2065
	2066	cl = magic[magic_cnt++];
	2067	bl = (cl & 0x3f) + bl;
	2068	} else
	2069	bl = cl;
	2070
	2071	comparison_src[x++] = (bl & 0xff00) >> 8;
	2072	comparison_src[x++] = bl & 0xff;
	2073	} while (x < 20);
	2074
	2075	/* Dump magic key into a char for SHA1 action. */
	2076
	2077
	2078	for(x = 0; x < 4; x++)
	2079	magic_key_char[x] = comparison_src[x];
	2080
	2081	/* Compute values for recursive function table! */
	2082	memcpy( chal, magic_key_char, 4 );
	2083	x = 1;
	2084	for( i = 0; i < 0xFFFF && x; i++ )
	2085	{
	2086	for( j = 0; j < 5 && x; j++ )
	2087	{
	2088	chal[4] = i;
	2089	chal[5] = i >> 8;
	2090	chal[6] = j;
	2091	md5_init( &ctx );
	2092	md5_append( &ctx, chal, 7 );
	2093	md5_finish( &ctx, result );
	2094	if( memcmp( comparison_src + 4, result, 16 ) == 0 )
	2095	{
	2096	depth = i;
	2097	table = j;
	2098	x = 0;
	2099	}
	2100	}
	2101	}
	2102
	2103	/* Transform magic_key_char using transform table */
	2104	x = magic_key_char[3] << 24 \| magic_key_char[2] << 16
	2105	\| magic_key_char[1] << 8 \| magic_key_char[0];
	2106	x = yahoo_xfrm( table, depth, x );
	2107	x = yahoo_xfrm( table, depth, x );
	2108	magic_key_char[0] = x & 0xFF;
	2109	magic_key_char[1] = x >> 8 & 0xFF;
	2110	magic_key_char[2] = x >> 16 & 0xFF;
	2111	magic_key_char[3] = x >> 24 & 0xFF;
	2112
	2113	/* Get password and crypt hashes as per usual. */
	2114	md5_init(&ctx);
	2115	md5_append(&ctx, (md5_byte_t *)yd->password, strlen(yd->password));
	2116	md5_finish(&ctx, result);
	2117	to_y64(password_hash, result, 16);
	2118
	2119	md5_init(&ctx);
	2120	crypt_result = yahoo_crypt(yd->password, "$1$_2S43d5f$");
	2121	md5_append(&ctx, (md5_byte_t *)crypt_result, strlen(crypt_result));
	2122	md5_finish(&ctx, result);
	2123	to_y64(crypt_hash, result, 16);
	2124	free(crypt_result);
	2125
	2126	/* Our first authentication response is based off
	2127	* of the password hash. */
	2128
	2129	for (x = 0; x < (int)strlen((char *)password_hash); x++)
	2130	pass_hash_xor1[cnt++] = password_hash[x] ^ 0x36;
	2131
	2132	if (cnt < 64)
	2133	memset(&(pass_hash_xor1[cnt]), 0x36, 64-cnt);
	2134
	2135	cnt = 0;
	2136
	2137	for (x = 0; x < (int)strlen((char *)password_hash); x++)
	2138	pass_hash_xor2[cnt++] = password_hash[x] ^ 0x5c;
	2139
	2140	if (cnt < 64)
	2141	memset(&(pass_hash_xor2[cnt]), 0x5c, 64-cnt);
	2142
[77bfd07]	2143	sha1_init(&ctx1);
	2144	sha1_init(&ctx2);
[b7d3cc34]	2145
	2146	/* The first context gets the password hash XORed
	2147	* with 0x36 plus a magic value
	2148	* which we previously extrapolated from our
	2149	* challenge. */
	2150
[77bfd07]	2151	sha1_append(&ctx1, pass_hash_xor1, 64);
[b7d3cc34]	2152	if (j >= 3 )
[77bfd07]	2153	ctx1.Length_Low = 0x1ff;
	2154	sha1_append(&ctx1, magic_key_char, 4);
	2155	sha1_finish(&ctx1, digest1);
[b7d3cc34]	2156
	2157	/* The second context gets the password hash XORed
	2158	* with 0x5c plus the SHA-1 digest
	2159	* of the first context. */
	2160
[77bfd07]	2161	sha1_append(&ctx2, pass_hash_xor2, 64);
	2162	sha1_append(&ctx2, digest1, 20);
	2163	sha1_finish(&ctx2, digest2);
[b7d3cc34]	2164
	2165	/* Now that we have digest2, use it to fetch
	2166	* characters from an alphabet to construct
	2167	* our first authentication response. */
	2168
	2169	for (x = 0; x < 20; x += 2) {
	2170	unsigned int val = 0;
	2171	unsigned int lookup = 0;
	2172	char byte[6];
	2173
	2174	memset(&byte, 0, 6);
	2175
	2176	/* First two bytes of digest stuffed
	2177	* together.
	2178	*/
	2179
	2180	val = digest2[x];
	2181	val <<= 8;
	2182	val += digest2[x+1];
	2183
	2184	lookup = (val >> 0x0b);
	2185	lookup &= 0x1f;
	2186	if (lookup >= strlen(alphabet1))
	2187	break;
	2188	sprintf(byte, "%c", alphabet1[lookup]);
	2189	strcat(resp_6, byte);
	2190	strcat(resp_6, "=");
	2191
	2192	lookup = (val >> 0x06);
	2193	lookup &= 0x1f;
	2194	if (lookup >= strlen(alphabet2))
	2195	break;
	2196	sprintf(byte, "%c", alphabet2[lookup]);
	2197	strcat(resp_6, byte);
	2198
	2199	lookup = (val >> 0x01);
	2200	lookup &= 0x1f;
	2201	if (lookup >= strlen(alphabet2))
	2202	break;
	2203	sprintf(byte, "%c", alphabet2[lookup]);
	2204	strcat(resp_6, byte);
	2205
	2206	lookup = (val & 0x01);
	2207	if (lookup >= strlen(delimit_lookup))
	2208	break;
	2209	sprintf(byte, "%c", delimit_lookup[lookup]);
	2210	strcat(resp_6, byte);
	2211	}
	2212
	2213	/* Our second authentication response is based off
	2214	* of the crypto hash. */
	2215
	2216	cnt = 0;
	2217	memset(&digest1, 0, 20);
	2218	memset(&digest2, 0, 20);
	2219
	2220	for (x = 0; x < (int)strlen((char *)crypt_hash); x++)
	2221	crypt_hash_xor1[cnt++] = crypt_hash[x] ^ 0x36;
	2222
	2223	if (cnt < 64)
	2224	memset(&(crypt_hash_xor1[cnt]), 0x36, 64-cnt);
	2225
	2226	cnt = 0;
	2227
	2228	for (x = 0; x < (int)strlen((char *)crypt_hash); x++)
	2229	crypt_hash_xor2[cnt++] = crypt_hash[x] ^ 0x5c;
	2230
	2231	if (cnt < 64)
	2232	memset(&(crypt_hash_xor2[cnt]), 0x5c, 64-cnt);
	2233
[77bfd07]	2234	sha1_init(&ctx1);
	2235	sha1_init(&ctx2);
[b7d3cc34]	2236
	2237	/* The first context gets the password hash XORed
	2238	* with 0x36 plus a magic value
	2239	* which we previously extrapolated from our
	2240	* challenge. */
	2241
[77bfd07]	2242	sha1_append(&ctx1, crypt_hash_xor1, 64);
[b7d3cc34]	2243	if (j >= 3 )
[77bfd07]	2244	ctx1.Length_Low = 0x1ff;
	2245	sha1_append(&ctx1, magic_key_char, 4);
	2246	sha1_finish(&ctx1, digest1);
[b7d3cc34]	2247
	2248	/* The second context gets the password hash XORed
	2249	* with 0x5c plus the SHA-1 digest
	2250	* of the first context. */
	2251
[77bfd07]	2252	sha1_append(&ctx2, crypt_hash_xor2, 64);
	2253	sha1_append(&ctx2, digest1, 20);
	2254	sha1_finish(&ctx2, digest2);
[b7d3cc34]	2255
	2256	/* Now that we have digest2, use it to fetch
	2257	* characters from an alphabet to construct
	2258	* our first authentication response. */
	2259
	2260	for (x = 0; x < 20; x += 2) {
	2261	unsigned int val = 0;
	2262	unsigned int lookup = 0;
	2263
	2264	char byte[6];
	2265
	2266	memset(&byte, 0, 6);
	2267
	2268	/* First two bytes of digest stuffed
	2269	* together. */
	2270
	2271	val = digest2[x];
	2272	val <<= 8;
	2273	val += digest2[x+1];
	2274
	2275	lookup = (val >> 0x0b);
	2276	lookup &= 0x1f;
	2277	if (lookup >= strlen(alphabet1))
	2278	break;
	2279	sprintf(byte, "%c", alphabet1[lookup]);
	2280	strcat(resp_96, byte);
	2281	strcat(resp_96, "=");
	2282
	2283	lookup = (val >> 0x06);
	2284	lookup &= 0x1f;
	2285	if (lookup >= strlen(alphabet2))
	2286	break;
	2287	sprintf(byte, "%c", alphabet2[lookup]);
	2288	strcat(resp_96, byte);
	2289
	2290	lookup = (val >> 0x01);
	2291	lookup &= 0x1f;
	2292	if (lookup >= strlen(alphabet2))
	2293	break;
	2294	sprintf(byte, "%c", alphabet2[lookup]);
	2295	strcat(resp_96, byte);
	2296
	2297	lookup = (val & 0x01);
	2298	if (lookup >= strlen(delimit_lookup))
	2299	break;
	2300	sprintf(byte, "%c", delimit_lookup[lookup]);
	2301	strcat(resp_96, byte);
	2302	}
	2303
	2304	pack = yahoo_packet_new(YAHOO_SERVICE_AUTHRESP, yd->initial_status, yd->session_id);
	2305	yahoo_packet_hash(pack, 0, sn);
	2306	yahoo_packet_hash(pack, 6, resp_6);
	2307	yahoo_packet_hash(pack, 96, resp_96);
	2308	yahoo_packet_hash(pack, 1, sn);
	2309	yahoo_send_packet(yid, pack, 0);
	2310	yahoo_packet_free(pack);
	2311
	2312	free(password_hash);
	2313	free(crypt_hash);
	2314	}
	2315
[e71cfbc]	2316	struct yahoo_https_auth_data
	2317	{
	2318	struct yahoo_input_data *yid;
	2319	char *token;
	2320	char *chal;
	2321	};
	2322
	2323	static void yahoo_https_auth_token_init(struct yahoo_https_auth_data *had);
	2324	static void yahoo_https_auth_token_finish(struct http_request *req);
	2325	static void yahoo_https_auth_init(struct yahoo_https_auth_data *had);
	2326	static void yahoo_https_auth_finish(struct http_request *req);
	2327
	2328	/* Extract a value from a login.yahoo.com response. Assume CRLF-linebreaks
	2329	and FAIL miserably if they're not there... */
	2330	static char yahoo_ha_find_key(char response, char *key)
	2331	{
	2332	char s, end;
	2333	int len = strlen(key);
	2334
	2335	s = response;
	2336	do {
	2337	if (strncmp(s, key, len) == 0 && s[len] == '=') {
	2338	s += len + 1;
	2339	if ((end = strchr(s, '\r')))
	2340	return g_strndup(s, end - s);
	2341	else
	2342	return g_strdup(s);
	2343	}
	2344
	2345	if ((s = strchr(s, '\n')))
	2346	s ++;
	2347	} while (s && *s);
	2348
	2349	return NULL;
	2350	}
	2351
	2352	static enum yahoo_status yahoo_https_status_parse(int code)
	2353	{
	2354	switch (code)
	2355	{
	2356	case 1212: return YAHOO_LOGIN_PASSWD;
	2357	case 1213: return YAHOO_LOGIN_LOCK;
	2358	case 1235: return YAHOO_LOGIN_UNAME;
	2359	default: return (enum yahoo_status) code;
	2360	}
	2361	}
	2362
[4fefb77]	2363	static void yahoo_process_auth_0x10(struct yahoo_input_data yid, const char seed, const char *sn)
	2364	{
[e71cfbc]	2365	struct yahoo_https_auth_data *had = g_new0(struct yahoo_https_auth_data, 1);
	2366
	2367	had->yid = yid;
	2368	had->chal = g_strdup(seed);
	2369
	2370	yahoo_https_auth_token_init(had);
	2371	}
[4fefb77]	2372
[e71cfbc]	2373	static void yahoo_https_auth_token_init(struct yahoo_https_auth_data *had)
	2374	{
	2375	struct yahoo_input_data *yid = had->yid;
	2376	struct yahoo_data *yd = yid->yd;
	2377	struct http_request *req;
	2378	char login, passwd, *chal;
	2379	char *url;
	2380
	2381	login = g_strndup(yd->user, 3 * strlen(yd->user));
	2382	http_encode(login);
	2383	passwd = g_strndup(yd->password, 3 * strlen(yd->password));
	2384	http_encode(passwd);
	2385	chal = g_strndup(had->chal, 3 * strlen(had->chal));
	2386	http_encode(chal);
	2387
	2388	url = g_strdup_printf("https://login.yahoo.com/config/pwtoken_get?src=ymsgr&ts=%d&login=%s&passwd=%s&chal=%s",
	2389	(int) time(NULL), login, passwd, chal);
	2390
	2391	req = http_dorequest_url(url, yahoo_https_auth_token_finish, had);
	2392
	2393	g_free(url);
	2394	g_free(chal);
	2395	g_free(passwd);
	2396	g_free(login);
	2397	}
[4fefb77]	2398
[e71cfbc]	2399	static void yahoo_https_auth_token_finish(struct http_request *req)
	2400	{
	2401	struct yahoo_https_auth_data *had = req->data;
[ccba980]	2402	struct yahoo_input_data *yid;
	2403	struct yahoo_data *yd;
[e71cfbc]	2404	int st;
	2405
[ccba980]	2406	if (y_list_find(inputs, had->yid) == NULL)
	2407	return;
	2408
	2409	yid = had->yid;
	2410	yd = yid->yd;
	2411
[e71cfbc]	2412	if (req->status_code != 200) {
	2413	YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, 2000 + req->status_code, NULL);
	2414	goto fail;
	2415	}
	2416
	2417	if (sscanf(req->reply_body, "%d", &st) != 1 \|\| st != 0) {
	2418	YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, yahoo_https_status_parse(st), NULL);
	2419	goto fail;
	2420	}
	2421
	2422	if ((had->token = yahoo_ha_find_key(req->reply_body, "ymsgr")) == NULL) {
	2423	YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, 3001, NULL);
	2424	goto fail;
	2425	}
	2426
	2427	return yahoo_https_auth_init(had);
	2428
	2429	fail:
	2430	g_free(had->token);
	2431	g_free(had->chal);
	2432	g_free(had);
	2433	}
[4fefb77]	2434
[e71cfbc]	2435	static void yahoo_https_auth_init(struct yahoo_https_auth_data *had)
	2436	{
	2437	struct http_request *req;
	2438	char *url;
	2439
	2440	url = g_strdup_printf("https://login.yahoo.com/config/pwtoken_login?src=ymsgr&ts=%d&token=%s",
	2441	(int) time(NULL), had->token);
	2442
	2443	req = http_dorequest_url(url, yahoo_https_auth_finish, had);
[4fefb77]	2444
	2445	g_free(url);
	2446	}
	2447
[e71cfbc]	2448	static void yahoo_https_auth_finish(struct http_request *req)
	2449	{
	2450	struct yahoo_https_auth_data *had = req->data;
[ccba980]	2451	struct yahoo_input_data *yid;
	2452	struct yahoo_data *yd;
[e71cfbc]	2453	struct yahoo_packet *pack;
[ccba980]	2454	char *crumb = NULL;
[e71cfbc]	2455	int st;
	2456
[ccba980]	2457	if (y_list_find(inputs, had->yid) == NULL)
	2458	return;
	2459
	2460	yid = had->yid;
	2461	yd = yid->yd;
	2462
[e71cfbc]	2463	md5_byte_t result[16];
	2464	md5_state_t ctx;
	2465
	2466	unsigned char yhash[32];
	2467
	2468	if (req->status_code != 200) {
	2469	YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, 2000 + req->status_code, NULL);
	2470	goto fail;
	2471	}
	2472
	2473	if (sscanf(req->reply_body, "%d", &st) != 1 \|\| st != 0) {
	2474	YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, yahoo_https_status_parse(st), NULL);
	2475	goto fail;
	2476	}
	2477
	2478	if ((yd->cookie_y = yahoo_ha_find_key(req->reply_body, "Y")) == NULL \|\|
	2479	(yd->cookie_t = yahoo_ha_find_key(req->reply_body, "T")) == NULL \|\|
	2480	(crumb = yahoo_ha_find_key(req->reply_body, "crumb")) == NULL) {
	2481	YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, 3002, NULL);
	2482	goto fail;
	2483	}
	2484
	2485	md5_init(&ctx);
	2486	md5_append(&ctx, (unsigned char*) crumb, 11);
	2487	md5_append(&ctx, (unsigned char*) had->chal, strlen(had->chal));
	2488	md5_finish(&ctx, result);
	2489	to_y64(yhash, result, 16);
	2490
	2491	pack = yahoo_packet_new(YAHOO_SERVICE_AUTHRESP, yd->initial_status, yd->session_id);
	2492	yahoo_packet_hash(pack, 1, yd->user);
	2493	yahoo_packet_hash(pack, 0, yd->user);
	2494	yahoo_packet_hash(pack, 277, yd->cookie_y);
	2495	yahoo_packet_hash(pack, 278, yd->cookie_t);
	2496	yahoo_packet_hash(pack, 307, (char*) yhash);
	2497	yahoo_packet_hash(pack, 244, "524223");
	2498	yahoo_packet_hash(pack, 2, yd->user);
	2499	yahoo_packet_hash(pack, 2, "1");
	2500	yahoo_packet_hash(pack, 98, "us");
	2501	yahoo_packet_hash(pack, 135, "7.5.0.647");
	2502
	2503	yahoo_send_packet(yid, pack, 0);
	2504
	2505	yahoo_packet_free(pack);
	2506
	2507	fail:
[99c8f13]	2508	g_free(crumb);
[e71cfbc]	2509	g_free(had->token);
	2510	g_free(had->chal);
	2511	g_free(had);
	2512	}
	2513
[b7d3cc34]	2514	static void yahoo_process_auth(struct yahoo_input_data yid, struct yahoo_packet pkt)
	2515	{
	2516	char *seed = NULL;
	2517	char *sn = NULL;
	2518	YList *l = pkt->hash;
	2519	int m = 0;
	2520
	2521	while (l) {
	2522	struct yahoo_pair *pair = l->data;
	2523	if (pair->key == 94)
	2524	seed = pair->value;
	2525	if (pair->key == 1)
	2526	sn = pair->value;
	2527	if (pair->key == 13)
	2528	m = atoi(pair->value);
	2529	l = l->next;
	2530	}
	2531
	2532	if (!seed)
	2533	return;
	2534
	2535	switch (m) {
	2536	case 0:
	2537	yahoo_process_auth_pre_0x0b(yid, seed, sn);
	2538	break;
	2539	case 1:
	2540	yahoo_process_auth_0x0b(yid, seed, sn);
	2541	break;
[4fefb77]	2542	case 2:
	2543	yahoo_process_auth_0x10(yid, seed, sn);
	2544	break;
[b7d3cc34]	2545	default:
	2546	/* call error */
	2547	WARNING(("unknown auth type %d", m));
	2548	yahoo_process_auth_0x0b(yid, seed, sn);
	2549	break;
	2550	}
	2551	}
	2552
	2553	static void yahoo_process_auth_resp(struct yahoo_input_data yid, struct yahoo_packet pkt)
	2554	{
	2555	struct yahoo_data *yd = yid->yd;
	2556	char *login_id;
	2557	char *handle;
	2558	char *url=NULL;
	2559	int login_status=0;
	2560
	2561	YList *l;
	2562
	2563	for (l = pkt->hash; l; l = l->next) {
	2564	struct yahoo_pair *pair = l->data;
	2565	if (pair->key == 0)
	2566	login_id = pair->value;
	2567	else if (pair->key == 1)
	2568	handle = pair->value;
	2569	else if (pair->key == 20)
	2570	url = pair->value;
	2571	else if (pair->key == 66)
	2572	login_status = atoi(pair->value);
	2573	}
	2574
	2575	if(pkt->status == 0xffffffff) {
	2576	YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, login_status, url);
	2577	/* yahoo_logoff(yd->client_id);*/
	2578	}
	2579	}
	2580
	2581	static void yahoo_process_mail(struct yahoo_input_data yid, struct yahoo_packet pkt)
	2582	{
	2583	struct yahoo_data *yd = yid->yd;
	2584	char *who = NULL;
	2585	char *email = NULL;
	2586	char *subj = NULL;
	2587	int count = 0;
	2588	YList *l;
	2589
	2590	for (l = pkt->hash; l; l = l->next) {
	2591	struct yahoo_pair *pair = l->data;
	2592	if (pair->key == 9)
	2593	count = strtol(pair->value, NULL, 10);
	2594	else if (pair->key == 43)
	2595	who = pair->value;
	2596	else if (pair->key == 42)
	2597	email = pair->value;
	2598	else if (pair->key == 18)
	2599	subj = pair->value;
	2600	else
	2601	LOG(("key: %d => value: %s", pair->key, pair->value));
	2602	}
	2603
	2604	if (who && email && subj) {
	2605	char from[1024];
	2606	snprintf(from, sizeof(from), "%s (%s)", who, email);
	2607	YAHOO_CALLBACK(ext_yahoo_mail_notify)(yd->client_id, from, subj, count);
	2608	} else if(count > 0)
	2609	YAHOO_CALLBACK(ext_yahoo_mail_notify)(yd->client_id, NULL, NULL, count);
	2610	}
	2611
	2612	static void yahoo_process_contact(struct yahoo_input_data yid, struct yahoo_packet pkt)
	2613	{
	2614	struct yahoo_data *yd = yid->yd;
	2615	char *id = NULL;
	2616	char *who = NULL;
	2617	char *msg = NULL;
	2618	char *name = NULL;
	2619	long tm = 0L;
	2620	int state = YAHOO_STATUS_AVAILABLE;
	2621	int online = FALSE;
	2622	int away = 0;
[cfc8d58]	2623	int idle = 0;
	2624	int mobile = 0;
[b7d3cc34]	2625
	2626	YList *l;
	2627
	2628	for (l = pkt->hash; l; l = l->next) {
	2629	struct yahoo_pair *pair = l->data;
	2630	if (pair->key == 1)
	2631	id = pair->value;
	2632	else if (pair->key == 3)
	2633	who = pair->value;
	2634	else if (pair->key == 14)
	2635	msg = pair->value;
	2636	else if (pair->key == 7)
	2637	name = pair->value;
	2638	else if (pair->key == 10)
	2639	state = strtol(pair->value, NULL, 10);
	2640	else if (pair->key == 15)
	2641	tm = strtol(pair->value, NULL, 10);
	2642	else if (pair->key == 13)
	2643	online = strtol(pair->value, NULL, 10);
	2644	else if (pair->key == 47)
	2645	away = strtol(pair->value, NULL, 10);
[cfc8d58]	2646	else if (pair->key == 137)
	2647	idle = strtol(pair->value, NULL, 10);
	2648	else if (pair->key == 60)
	2649	mobile = strtol(pair->value, NULL, 10);
	2650
[b7d3cc34]	2651	}
	2652
	2653	if (id)
	2654	YAHOO_CALLBACK(ext_yahoo_contact_added)(yd->client_id, id, who, msg);
	2655	else if (name)
[cfc8d58]	2656	YAHOO_CALLBACK(ext_yahoo_status_changed)(yd->client_id, name, state, msg, away, idle, mobile);
[b7d3cc34]	2657	else if(pkt->status == 0x07)
	2658	YAHOO_CALLBACK(ext_yahoo_rejected)(yd->client_id, who, msg);
	2659	}
	2660
	2661	static void yahoo_process_buddyadd(struct yahoo_input_data yid, struct yahoo_packet pkt)
	2662	{
	2663	struct yahoo_data *yd = yid->yd;
	2664	char *who = NULL;
	2665	char *where = NULL;
	2666	int status = 0;
	2667	char *me = NULL;
	2668
	2669	struct yahoo_buddy *bud=NULL;
	2670
	2671	YList *l;
	2672	for (l = pkt->hash; l; l = l->next) {
	2673	struct yahoo_pair *pair = l->data;
	2674	if (pair->key == 1)
	2675	me = pair->value;
	2676	if (pair->key == 7)
	2677	who = pair->value;
	2678	if (pair->key == 65)
	2679	where = pair->value;
	2680	if (pair->key == 66)
	2681	status = strtol(pair->value, NULL, 10);
	2682	}
	2683
	2684	yahoo_dump_unhandled(pkt);
	2685
	2686	if(!who)
	2687	return;
	2688	if(!where)
	2689	where = "Unknown";
	2690
[f0cb961]	2691	/* status: 0 == Successful, 1 == Error (does not exist), 2 == Already in list */
	2692	if( status == 0 ) {
	2693	bud = y_new0(struct yahoo_buddy, 1);
	2694	bud->id = strdup(who);
	2695	bud->group = strdup(where);
	2696	bud->real_name = NULL;
	2697
	2698	yd->buddies = y_list_append(yd->buddies, bud);
[ba16895]	2699
[f0cb961]	2700	/* Possibly called already, but at least the call above doesn't
	2701	seem to happen every time (not anytime I tried). */
	2702	YAHOO_CALLBACK(ext_yahoo_contact_added)(yd->client_id, me, who, NULL);
	2703	}
[b7d3cc34]	2704
	2705	/* YAHOO_CALLBACK(ext_yahoo_status_changed)(yd->client_id, who, status, NULL, (status==YAHOO_STATUS_AVAILABLE?0:1)); */
	2706	}
	2707
[ba16895]	2708	static void yahoo_process_contact_ymsg13(struct yahoo_input_data yid, struct yahoo_packet pkt)
	2709	{
	2710	char* who=NULL;
	2711	char* me=NULL;
	2712	char* msg=NULL;
	2713	YList *l;
	2714	for (l = pkt->hash; l; l = l->next) {
	2715	struct yahoo_pair *pair = l->data;
	2716	if (pair->key == 4)
	2717	who = pair->value;
	2718	else if (pair->key == 5)
	2719	me = pair->value;
	2720	else
	2721	DEBUG_MSG(("unknown key: %d = %s", pair->key, pair->value));
	2722	}
	2723
	2724	if(pkt->status==3)
	2725	YAHOO_CALLBACK(ext_yahoo_contact_auth_request)(yid->yd->client_id, me, who, msg);
	2726	}
	2727
[b7d3cc34]	2728	static void yahoo_process_buddydel(struct yahoo_input_data yid, struct yahoo_packet pkt)
	2729	{
	2730	struct yahoo_data *yd = yid->yd;
	2731	char *who = NULL;
	2732	char *where = NULL;
	2733	int unk_66 = 0;
	2734	char *me = NULL;
	2735	struct yahoo_buddy *bud;
	2736
	2737	YList *buddy;
	2738
	2739	YList *l;
	2740	for (l = pkt->hash; l; l = l->next) {
	2741	struct yahoo_pair *pair = l->data;
	2742	if (pair->key == 1)
	2743	me = pair->value;
	2744	else if (pair->key == 7)
	2745	who = pair->value;
	2746	else if (pair->key == 65)
	2747	where = pair->value;
	2748	else if (pair->key == 66)
	2749	unk_66 = strtol(pair->value, NULL, 10);
	2750	else
	2751	DEBUG_MSG(("unknown key: %d = %s", pair->key, pair->value));
	2752	}
	2753
	2754	if(!who \|\| !where)
	2755	return;
	2756
	2757	bud = y_new0(struct yahoo_buddy, 1);
	2758	bud->id = strdup(who);
	2759	bud->group = strdup(where);
	2760
	2761	buddy = y_list_find_custom(yd->buddies, bud, is_same_bud);
	2762
	2763	FREE(bud->id);
	2764	FREE(bud->group);
	2765	FREE(bud);
	2766
	2767	if(buddy) {
	2768	bud = buddy->data;
	2769	yd->buddies = y_list_remove_link(yd->buddies, buddy);
	2770	y_list_free_1(buddy);
	2771
	2772	FREE(bud->id);
	2773	FREE(bud->group);
	2774	FREE(bud->real_name);
	2775	FREE(bud);
	2776
	2777	bud=NULL;
	2778	}
	2779	}
	2780
	2781	static void yahoo_process_ignore(struct yahoo_input_data yid, struct yahoo_packet pkt)
	2782	{
	2783	char *who = NULL;
	2784	int status = 0;
	2785	char *me = NULL;
	2786	int un_ignore = 0;
	2787
	2788	YList *l;
	2789	for (l = pkt->hash; l; l = l->next) {
	2790	struct yahoo_pair *pair = l->data;
	2791	if (pair->key == 0)
	2792	who = pair->value;
	2793	if (pair->key == 1)
	2794	me = pair->value;
	2795	if (pair->key == 13) /* 1 == ignore, 2 == unignore */
	2796	un_ignore = strtol(pair->value, NULL, 10);
	2797	if (pair->key == 66)
	2798	status = strtol(pair->value, NULL, 10);
	2799	}
	2800
	2801
	2802	/*
	2803	* status
	2804	* 0 - ok
	2805	* 2 - already in ignore list, could not add
	2806	* 3 - not in ignore list, could not delete
	2807	* 12 - is a buddy, could not add
	2808	*/
	2809
	2810	/* if(status)
[cfc8d58]	2811	YAHOO_CALLBACK(ext_yahoo_error)(yd->client_id, who, 0, status);
[b7d3cc34]	2812	*/
	2813	}
	2814
	2815	static void yahoo_process_voicechat(struct yahoo_input_data yid, struct yahoo_packet pkt)
	2816	{
	2817	char *who = NULL;
	2818	char *me = NULL;
	2819	char *room = NULL;
	2820	char *voice_room = NULL;
	2821
	2822	YList *l;
	2823	for (l = pkt->hash; l; l = l->next) {
	2824	struct yahoo_pair *pair = l->data;
	2825	if (pair->key == 4)
	2826	who = pair->value;
	2827	if (pair->key == 5)
	2828	me = pair->value;
	2829	if (pair->key == 13)
	2830	voice_room=pair->value;
	2831	if (pair->key == 57)
	2832	room=pair->value;
	2833	}
	2834
[cfc8d58]	2835	NOTICE(("got voice chat invite from %s in %s to identity %s", who, room, me));
[b7d3cc34]	2836	/*
	2837	* send: s:0 1:me 5:who 57:room 13:1
	2838	* ???? s:4 5:who 10:99 19:-1615114531
	2839	* gotr: s:4 5:who 10:99 19:-1615114615
	2840	* ???? s:1 5:me 4:who 57:room 13:3room
	2841	* got: s:1 5:me 4:who 57:room 13:1room
	2842	* rej: s:0 1:me 5:who 57:room 13:3
	2843	* rejr: s:4 5:who 10:99 19:-1617114599
	2844	*/
	2845	}
	2846
[cfc8d58]	2847	static void yahoo_process_ping(struct yahoo_input_data yid, struct yahoo_packet pkt)
	2848	{
	2849	char *errormsg = NULL;
	2850
	2851	YList *l;
	2852	for (l = pkt->hash; l; l = l->next) {
	2853	struct yahoo_pair *pair = l->data;
	2854	if (pair->key == 16)
	2855	errormsg = pair->value;
	2856	}
	2857
	2858	NOTICE(("got ping packet"));
	2859	YAHOO_CALLBACK(ext_yahoo_got_ping)(yid->yd->client_id, errormsg);
	2860	}
	2861
[b7d3cc34]	2862	static void _yahoo_webcam_get_server_connected(int fd, int error, void *d)
	2863	{
	2864	struct yahoo_input_data *yid = d;
	2865	char *who = yid->wcm->user;
	2866	char *data = NULL;
	2867	char *packet = NULL;
	2868	unsigned char magic_nr[] = {0, 1, 0};
	2869	unsigned char header_len = 8;
	2870	unsigned int len = 0;
	2871	unsigned int pos = 0;
	2872
	2873	if(error \|\| fd <= 0) {
	2874	FREE(who);
	2875	FREE(yid);
	2876	return;
	2877	}
	2878
	2879	yid->fd = fd;
	2880	inputs = y_list_prepend(inputs, yid);
	2881
	2882	/* send initial packet */
	2883	if (who)
	2884	data = strdup("<RVWCFG>");
	2885	else
	2886	data = strdup("<RUPCFG>");
	2887	yahoo_add_to_send_queue(yid, data, strlen(data));
	2888	FREE(data);
	2889
	2890	/* send data */
	2891	if (who)
	2892	{
	2893	data = strdup("g=");
	2894	data = y_string_append(data, who);
	2895	data = y_string_append(data, "\r\n");
	2896	} else {
	2897	data = strdup("f=1\r\n");
	2898	}
	2899	len = strlen(data);
	2900	packet = y_new0(char, header_len + len);
	2901	packet[pos++] = header_len;
	2902	memcpy(packet + pos, magic_nr, sizeof(magic_nr));
	2903	pos += sizeof(magic_nr);
	2904	pos += yahoo_put32(packet + pos, len);
	2905	memcpy(packet + pos, data, len);
	2906	pos += len;
	2907	yahoo_add_to_send_queue(yid, packet, pos);
	2908	FREE(packet);
	2909	FREE(data);
	2910
	2911	yid->read_tag=YAHOO_CALLBACK(ext_yahoo_add_handler)(yid->yd->client_id, fd, YAHOO_INPUT_READ, yid);
	2912	}
	2913
	2914	static void yahoo_webcam_get_server(struct yahoo_input_data y, char who, char *key)
	2915	{
	2916	struct yahoo_input_data *yid = y_new0(struct yahoo_input_data, 1);
	2917	struct yahoo_server_settings *yss = y->yd->server_settings;
	2918
	2919	yid->type = YAHOO_CONNECTION_WEBCAM_MASTER;
	2920	yid->yd = y->yd;
	2921	yid->wcm = y_new0(struct yahoo_webcam, 1);
	2922	yid->wcm->user = who?strdup(who):NULL;
	2923	yid->wcm->direction = who?YAHOO_WEBCAM_DOWNLOAD:YAHOO_WEBCAM_UPLOAD;
	2924	yid->wcm->key = strdup(key);
	2925
	2926	YAHOO_CALLBACK(ext_yahoo_connect_async)(yid->yd->client_id, yss->webcam_host, yss->webcam_port,
	2927	_yahoo_webcam_get_server_connected, yid);
	2928
	2929	}
	2930
	2931	static YList *webcam_queue=NULL;
	2932	static void yahoo_process_webcam_key(struct yahoo_input_data yid, struct yahoo_packet pkt)
	2933	{
	2934	char *me = NULL;
	2935	char *key = NULL;
	2936	char *who = NULL;
	2937
	2938	YList *l;
[ba16895]	2939	// yahoo_dump_unhandled(pkt);
[b7d3cc34]	2940	for (l = pkt->hash; l; l = l->next) {
	2941	struct yahoo_pair *pair = l->data;
	2942	if (pair->key == 5)
	2943	me = pair->value;
	2944	if (pair->key == 61)
	2945	key=pair->value;
	2946	}
	2947
	2948	l = webcam_queue;
	2949	if(!l)
	2950	return;
	2951	who = l->data;
	2952	webcam_queue = y_list_remove_link(webcam_queue, webcam_queue);
	2953	y_list_free_1(l);
	2954	yahoo_webcam_get_server(yid, who, key);
	2955	FREE(who);
	2956	}
	2957
	2958	static void yahoo_packet_process(struct yahoo_input_data yid, struct yahoo_packet pkt)
	2959	{
	2960	DEBUG_MSG(("yahoo_packet_process: 0x%02x", pkt->service));
[ba16895]	2961	yahoo_dump_unhandled(pkt);
[b7d3cc34]	2962	switch (pkt->service)
	2963	{
	2964	case YAHOO_SERVICE_USERSTAT:
	2965	case YAHOO_SERVICE_LOGON:
	2966	case YAHOO_SERVICE_LOGOFF:
	2967	case YAHOO_SERVICE_ISAWAY:
	2968	case YAHOO_SERVICE_ISBACK:
	2969	case YAHOO_SERVICE_GAMELOGON:
	2970	case YAHOO_SERVICE_GAMELOGOFF:
	2971	case YAHOO_SERVICE_IDACT:
	2972	case YAHOO_SERVICE_IDDEACT:
[4fefb77]	2973	case YAHOO_SERVICE_Y6_STATUS_UPDATE:
[ba16895]	2974	case YAHOO_SERVICE_YMSG15_STATUS:
[b7d3cc34]	2975	yahoo_process_status(yid, pkt);
	2976	break;
	2977	case YAHOO_SERVICE_NOTIFY:
	2978	yahoo_process_notify(yid, pkt);
	2979	break;
	2980	case YAHOO_SERVICE_MESSAGE:
	2981	case YAHOO_SERVICE_GAMEMSG:
	2982	case YAHOO_SERVICE_SYSMESSAGE:
	2983	yahoo_process_message(yid, pkt);
	2984	break;
	2985	case YAHOO_SERVICE_NEWMAIL:
	2986	yahoo_process_mail(yid, pkt);
	2987	break;
[ba16895]	2988	case YAHOO_SERVICE_REJECTCONTACT:
[b7d3cc34]	2989	case YAHOO_SERVICE_NEWCONTACT:
	2990	yahoo_process_contact(yid, pkt);
	2991	break;
	2992	case YAHOO_SERVICE_LIST:
	2993	yahoo_process_list(yid, pkt);
	2994	break;
	2995	case YAHOO_SERVICE_VERIFY:
	2996	yahoo_process_verify(yid, pkt);
	2997	break;
	2998	case YAHOO_SERVICE_AUTH:
	2999	yahoo_process_auth(yid, pkt);
	3000	break;
	3001	case YAHOO_SERVICE_AUTHRESP:
	3002	yahoo_process_auth_resp(yid, pkt);
	3003	break;
	3004	case YAHOO_SERVICE_CONFINVITE:
	3005	case YAHOO_SERVICE_CONFADDINVITE:
	3006	case YAHOO_SERVICE_CONFDECLINE:
	3007	case YAHOO_SERVICE_CONFLOGON:
	3008	case YAHOO_SERVICE_CONFLOGOFF:
	3009	case YAHOO_SERVICE_CONFMSG:
	3010	yahoo_process_conference(yid, pkt);
	3011	break;
	3012	case YAHOO_SERVICE_CHATONLINE:
	3013	case YAHOO_SERVICE_CHATGOTO:
	3014	case YAHOO_SERVICE_CHATJOIN:
	3015	case YAHOO_SERVICE_CHATLEAVE:
	3016	case YAHOO_SERVICE_CHATEXIT:
	3017	case YAHOO_SERVICE_CHATLOGOUT:
	3018	case YAHOO_SERVICE_CHATPING:
	3019	case YAHOO_SERVICE_COMMENT:
	3020	yahoo_process_chat(yid, pkt);
	3021	break;
	3022	case YAHOO_SERVICE_P2PFILEXFER:
	3023	case YAHOO_SERVICE_FILETRANSFER:
	3024	yahoo_process_filetransfer(yid, pkt);
	3025	break;
	3026	case YAHOO_SERVICE_ADDBUDDY:
	3027	yahoo_process_buddyadd(yid, pkt);
	3028	break;
[ba16895]	3029	case YAHOO_SERVICE_CONTACT_YMSG13:
	3030	yahoo_process_contact_ymsg13(yid,pkt);
	3031	break;
[b7d3cc34]	3032	case YAHOO_SERVICE_REMBUDDY:
	3033	yahoo_process_buddydel(yid, pkt);
	3034	break;
	3035	case YAHOO_SERVICE_IGNORECONTACT:
	3036	yahoo_process_ignore(yid, pkt);
	3037	break;
	3038	case YAHOO_SERVICE_VOICECHAT:
	3039	yahoo_process_voicechat(yid, pkt);
	3040	break;
	3041	case YAHOO_SERVICE_WEBCAM:
	3042	yahoo_process_webcam_key(yid, pkt);
	3043	break;
[cfc8d58]	3044	case YAHOO_SERVICE_PING:
	3045	yahoo_process_ping(yid, pkt);
	3046	break;
[b7d3cc34]	3047	case YAHOO_SERVICE_IDLE:
	3048	case YAHOO_SERVICE_MAILSTAT:
	3049	case YAHOO_SERVICE_CHATINVITE:
	3050	case YAHOO_SERVICE_CALENDAR:
	3051	case YAHOO_SERVICE_NEWPERSONALMAIL:
	3052	case YAHOO_SERVICE_ADDIDENT:
	3053	case YAHOO_SERVICE_ADDIGNORE:
	3054	case YAHOO_SERVICE_GOTGROUPRENAME:
	3055	case YAHOO_SERVICE_GROUPRENAME:
	3056	case YAHOO_SERVICE_PASSTHROUGH2:
	3057	case YAHOO_SERVICE_CHATLOGON:
	3058	case YAHOO_SERVICE_CHATLOGOFF:
	3059	case YAHOO_SERVICE_CHATMSG:
	3060	case YAHOO_SERVICE_PEERTOPEER:
	3061	WARNING(("unhandled service 0x%02x", pkt->service));
	3062	yahoo_dump_unhandled(pkt);
	3063	break;
[cfc8d58]	3064	case YAHOO_SERVICE_PICTURE:
	3065	yahoo_process_picture(yid, pkt);
	3066	break;
	3067	case YAHOO_SERVICE_PICTURE_CHECKSUM:
	3068	yahoo_process_picture_checksum(yid, pkt);
	3069	break;
	3070	case YAHOO_SERVICE_PICTURE_UPLOAD:
	3071	yahoo_process_picture_upload(yid, pkt);
	3072	break;
[ba16895]	3073	case YAHOO_SERVICE_YMSG15_BUDDY_LIST: /* Buddy List */
[4fefb77]	3074	yahoo_process_buddy_list(yid, pkt);
[b7d3cc34]	3075	default:
	3076	WARNING(("unknown service 0x%02x", pkt->service));
	3077	yahoo_dump_unhandled(pkt);
	3078	break;
	3079	}
	3080	}
	3081
	3082	static struct yahoo_packet * yahoo_getdata(struct yahoo_input_data * yid)
	3083	{
	3084	struct yahoo_packet *pkt;
	3085	struct yahoo_data *yd = yid->yd;
	3086	int pos = 0;
	3087	int pktlen;
	3088
	3089	if(!yd)
	3090	return NULL;
	3091
	3092	DEBUG_MSG(("rxlen is %d", yid->rxlen));
	3093	if (yid->rxlen < YAHOO_PACKET_HDRLEN) {
	3094	DEBUG_MSG(("len < YAHOO_PACKET_HDRLEN"));
	3095	return NULL;
	3096	}
	3097
	3098	pos += 4; /* YMSG */
	3099	pos += 2;
	3100	pos += 2;
	3101
	3102	pktlen = yahoo_get16(yid->rxqueue + pos); pos += 2;
	3103	DEBUG_MSG(("%d bytes to read, rxlen is %d",
	3104	pktlen, yid->rxlen));
	3105
	3106	if (yid->rxlen < (YAHOO_PACKET_HDRLEN + pktlen)) {
	3107	DEBUG_MSG(("len < YAHOO_PACKET_HDRLEN + pktlen"));
	3108	return NULL;
	3109	}
	3110
	3111	LOG(("reading packet"));
	3112	yahoo_packet_dump(yid->rxqueue, YAHOO_PACKET_HDRLEN + pktlen);
	3113
	3114	pkt = yahoo_packet_new(0, 0, 0);
	3115
	3116	pkt->service = yahoo_get16(yid->rxqueue + pos); pos += 2;
	3117	pkt->status = yahoo_get32(yid->rxqueue + pos); pos += 4;
	3118	DEBUG_MSG(("Yahoo Service: 0x%02x Status: %d", pkt->service,
	3119	pkt->status));
	3120	pkt->id = yahoo_get32(yid->rxqueue + pos); pos += 4;
	3121
	3122	yd->session_id = pkt->id;
	3123
	3124	yahoo_packet_read(pkt, yid->rxqueue + pos, pktlen);
	3125
	3126	yid->rxlen -= YAHOO_PACKET_HDRLEN + pktlen;
	3127	DEBUG_MSG(("rxlen == %d, rxqueue == %p", yid->rxlen, yid->rxqueue));
	3128	if (yid->rxlen>0) {
	3129	unsigned char *tmp = y_memdup(yid->rxqueue + YAHOO_PACKET_HDRLEN
	3130	+ pktlen, yid->rxlen);
	3131	FREE(yid->rxqueue);
	3132	yid->rxqueue = tmp;
	3133	DEBUG_MSG(("new rxlen == %d, rxqueue == %p", yid->rxlen, yid->rxqueue));
	3134	} else {
	3135	DEBUG_MSG(("freed rxqueue == %p", yid->rxqueue));
	3136	FREE(yid->rxqueue);
	3137	}
	3138
	3139	return pkt;
	3140	}
	3141
	3142	static void yahoo_yab_read(struct yab yab, unsigned char d, int len)
	3143	{
	3144	char st, en;
	3145	char data = (char )d;
	3146	data[len]='\0';
	3147
	3148	DEBUG_MSG(("Got yab: %s", data));
	3149	st = en = strstr(data, "userid=\"");
	3150	if(st) {
	3151	st += strlen("userid=\"");
	3152	en = strchr(st, '"'); *en++ = '\0';
	3153	yab->id = yahoo_xmldecode(st);
	3154	}
	3155
	3156	st = strstr(en, "fname=\"");
	3157	if(st) {
	3158	st += strlen("fname=\"");
	3159	en = strchr(st, '"'); *en++ = '\0';
	3160	yab->fname = yahoo_xmldecode(st);
	3161	}
	3162
	3163	st = strstr(en, "lname=\"");
	3164	if(st) {
	3165	st += strlen("lname=\"");
	3166	en = strchr(st, '"'); *en++ = '\0';
	3167	yab->lname = yahoo_xmldecode(st);
	3168	}
	3169
	3170	st = strstr(en, "nname=\"");
	3171	if(st) {
	3172	st += strlen("nname=\"");
	3173	en = strchr(st, '"'); *en++ = '\0';
	3174	yab->nname = yahoo_xmldecode(st);
	3175	}
	3176
	3177	st = strstr(en, "email=\"");
	3178	if(st) {
	3179	st += strlen("email=\"");
	3180	en = strchr(st, '"'); *en++ = '\0';
	3181	yab->email = yahoo_xmldecode(st);
	3182	}
	3183
	3184	st = strstr(en, "hphone=\"");
	3185	if(st) {
	3186	st += strlen("hphone=\"");
	3187	en = strchr(st, '"'); *en++ = '\0';
	3188	yab->hphone = yahoo_xmldecode(st);
	3189	}
	3190
	3191	st = strstr(en, "wphone=\"");
	3192	if(st) {
	3193	st += strlen("wphone=\"");
	3194	en = strchr(st, '"'); *en++ = '\0';
	3195	yab->wphone = yahoo_xmldecode(st);
	3196	}
	3197
	3198	st = strstr(en, "mphone=\"");
	3199	if(st) {
	3200	st += strlen("mphone=\"");
	3201	en = strchr(st, '"'); *en++ = '\0';
	3202	yab->mphone = yahoo_xmldecode(st);
	3203	}
	3204
	3205	st = strstr(en, "dbid=\"");
	3206	if(st) {
	3207	st += strlen("dbid=\"");
	3208	en = strchr(st, '"'); *en++ = '\0';
	3209	yab->dbid = atoi(st);
	3210	}
	3211	}
	3212
	3213	static struct yab * yahoo_getyab(struct yahoo_input_data *yid)
	3214	{
	3215	struct yab *yab = NULL;
	3216	int pos = 0, end=0;
	3217	struct yahoo_data *yd = yid->yd;
	3218
	3219	if(!yd)
	3220	return NULL;
	3221
	3222	DEBUG_MSG(("rxlen is %d", yid->rxlen));
	3223
	3224	if(yid->rxlen <= strlen("<record"))
	3225	return NULL;
	3226
	3227	/* start with <record */
	3228	while(pos < yid->rxlen-strlen("<record")+1
	3229	&& memcmp(yid->rxqueue + pos, "<record", strlen("<record")))
	3230	pos++;
	3231
	3232	if(pos >= yid->rxlen-1)
	3233	return NULL;
	3234
	3235	end = pos+2;
	3236	/* end with /> */
	3237	while(end < yid->rxlen-strlen("/>")+1 && memcmp(yid->rxqueue + end, "/>", strlen("/>")))
	3238	end++;
	3239
	3240	if(end >= yid->rxlen-1)
	3241	return NULL;
	3242
	3243	yab = y_new0(struct yab, 1);
	3244	yahoo_yab_read(yab, yid->rxqueue + pos, end+2-pos);
	3245
	3246
	3247	yid->rxlen -= end+1;
	3248	DEBUG_MSG(("rxlen == %d, rxqueue == %p", yid->rxlen, yid->rxqueue));
	3249	if (yid->rxlen>0) {
	3250	unsigned char *tmp = y_memdup(yid->rxqueue + end + 1, yid->rxlen);
	3251	FREE(yid->rxqueue);
	3252	yid->rxqueue = tmp;
	3253	DEBUG_MSG(("new rxlen == %d, rxqueue == %p", yid->rxlen, yid->rxqueue));
	3254	} else {
	3255	DEBUG_MSG(("freed rxqueue == %p", yid->rxqueue));
	3256	FREE(yid->rxqueue);
	3257	}
	3258
	3259
	3260	return yab;
	3261	}
	3262
	3263	static char * yahoo_getwebcam_master(struct yahoo_input_data *yid)
	3264	{
	3265	unsigned int pos=0;
	3266	unsigned int len=0;
	3267	unsigned int status=0;
	3268	char *server=NULL;
	3269	struct yahoo_data *yd = yid->yd;
	3270
	3271	if(!yid \|\| !yd)
	3272	return NULL;
	3273
	3274	DEBUG_MSG(("rxlen is %d", yid->rxlen));
	3275
	3276	len = yid->rxqueue[pos++];
	3277	if (yid->rxlen < len)
	3278	return NULL;
	3279
	3280	/* extract status (0 = ok, 6 = webcam not online) */
	3281	status = yid->rxqueue[pos++];
	3282
	3283	if (status == 0)
	3284	{
	3285	pos += 2; /* skip next 2 bytes */
	3286	server = y_memdup(yid->rxqueue+pos, 16);
	3287	pos += 16;
	3288	}
	3289	else if (status == 6)
	3290	{
	3291	YAHOO_CALLBACK(ext_yahoo_webcam_closed)
	3292	(yd->client_id, yid->wcm->user, 4);
	3293	}
	3294
	3295	/* skip rest of the data */
	3296
	3297	yid->rxlen -= len;
	3298	DEBUG_MSG(("rxlen == %d, rxqueue == %p", yid->rxlen, yid->rxqueue));
	3299	if (yid->rxlen>0) {
	3300	unsigned char *tmp = y_memdup(yid->rxqueue + pos, yid->rxlen);
	3301	FREE(yid->rxqueue);
	3302	yid->rxqueue = tmp;
	3303	DEBUG_MSG(("new rxlen == %d, rxqueue == %p", yid->rxlen, yid->rxqueue));
	3304	} else {
	3305	DEBUG_MSG(("freed rxqueue == %p", yid->rxqueue));
	3306	FREE(yid->rxqueue);
	3307	}
	3308
	3309	return server;
	3310	}
	3311
	3312	static int yahoo_get_webcam_data(struct yahoo_input_data *yid)
	3313	{
	3314	unsigned char reason=0;
	3315	unsigned int pos=0;
	3316	unsigned int begin=0;
	3317	unsigned int end=0;
	3318	unsigned int closed=0;
	3319	unsigned char header_len=0;
	3320	char *who;
	3321	int connect=0;
	3322	struct yahoo_data *yd = yid->yd;
	3323
	3324	if(!yd)
	3325	return -1;
	3326
	3327	if(!yid->wcm \|\| !yid->wcd \|\| !yid->rxlen)
	3328	return -1;
	3329
	3330	DEBUG_MSG(("rxlen is %d", yid->rxlen));
	3331
	3332	/* if we are not reading part of image then read header */
	3333	if (!yid->wcd->to_read)
	3334	{
	3335	header_len=yid->rxqueue[pos++];
	3336	yid->wcd->packet_type=0;
	3337
	3338	if (yid->rxlen < header_len)
	3339	return 0;
	3340
	3341	if (header_len >= 8)
	3342	{
	3343	reason = yid->rxqueue[pos++];
	3344	/* next 2 bytes should always be 05 00 */
	3345	pos += 2;
	3346	yid->wcd->data_size = yahoo_get32(yid->rxqueue + pos);
	3347	pos += 4;
	3348	yid->wcd->to_read = yid->wcd->data_size;
	3349	}
	3350	if (header_len >= 13)
	3351	{
	3352	yid->wcd->packet_type = yid->rxqueue[pos++];
	3353	yid->wcd->timestamp = yahoo_get32(yid->rxqueue + pos);
	3354	pos += 4;
	3355	}
	3356
	3357	/* skip rest of header */
	3358	pos = header_len;
	3359	}
	3360
	3361	begin = pos;
	3362	pos += yid->wcd->to_read;
	3363	if (pos > yid->rxlen) pos = yid->rxlen;
	3364
	3365	/* if it is not an image then make sure we have the whole packet */
	3366	if (yid->wcd->packet_type != 0x02) {
	3367	if ((pos - begin) != yid->wcd->data_size) {
	3368	yid->wcd->to_read = 0;
	3369	return 0;
	3370	} else {
	3371	yahoo_packet_dump(yid->rxqueue + begin, pos - begin);
	3372	}
	3373	}
	3374
	3375	DEBUG_MSG(("packet type %.2X, data length %d", yid->wcd->packet_type,
	3376	yid->wcd->data_size));
	3377
	3378	/* find out what kind of packet we got */
	3379	switch (yid->wcd->packet_type)
	3380	{
	3381	case 0x00:
	3382	/* user requests to view webcam (uploading) */
	3383	if (yid->wcd->data_size &&
	3384	yid->wcm->direction == YAHOO_WEBCAM_UPLOAD) {
	3385	end = begin;
	3386	while (end <= yid->rxlen &&
	3387	yid->rxqueue[end++] != 13);
	3388	if (end > begin)
	3389	{
	3390	who = y_memdup(yid->rxqueue + begin, end - begin);
	3391	who[end - begin - 1] = 0;
	3392	YAHOO_CALLBACK(ext_yahoo_webcam_viewer)(yd->client_id, who + 2, 2);
	3393	FREE(who);
	3394	}
	3395	}
	3396
	3397	if (yid->wcm->direction == YAHOO_WEBCAM_DOWNLOAD) {
	3398	/* timestamp/status field */
	3399	/* 0 = declined viewing permission */
	3400	/* 1 = accepted viewing permission */
	3401	if (yid->wcd->timestamp == 0) {
	3402	YAHOO_CALLBACK(ext_yahoo_webcam_closed)(yd->client_id, yid->wcm->user, 3);
	3403	}
	3404	}
	3405	break;
	3406	case 0x01: /* status packets?? */
	3407	/* timestamp contains status info */
	3408	/* 00 00 00 01 = we have data?? */
	3409	break;
	3410	case 0x02: /* image data */
	3411	YAHOO_CALLBACK(ext_yahoo_got_webcam_image)(yd->client_id,
	3412	yid->wcm->user, yid->rxqueue + begin,
	3413	yid->wcd->data_size, pos - begin,
	3414	yid->wcd->timestamp);
	3415	break;
	3416	case 0x05: /* response packets when uploading */
	3417	if (!yid->wcd->data_size) {
	3418	YAHOO_CALLBACK(ext_yahoo_webcam_data_request)(yd->client_id, yid->wcd->timestamp);
	3419	}
	3420	break;
	3421	case 0x07: /* connection is closing */
	3422	switch(reason)
	3423	{
	3424	case 0x01: /* user closed connection */
	3425	closed = 1;
	3426	break;
	3427	case 0x0F: /* user cancelled permission */
	3428	closed = 2;
	3429	break;
	3430	}
	3431	YAHOO_CALLBACK(ext_yahoo_webcam_closed)(yd->client_id, yid->wcm->user, closed);
	3432	break;
	3433	case 0x0C: /* user connected */
	3434	case 0x0D: /* user disconnected */
	3435	if (yid->wcd->data_size) {
	3436	who = y_memdup(yid->rxqueue + begin, pos - begin + 1);
	3437	who[pos - begin] = 0;
	3438	if (yid->wcd->packet_type == 0x0C)
	3439	connect=1;
	3440	else
	3441	connect=0;
	3442	YAHOO_CALLBACK(ext_yahoo_webcam_viewer)(yd->client_id, who, connect);
	3443	FREE(who);
	3444	}
	3445	break;
	3446	case 0x13: /* user data */
	3447	/* i=user_ip (ip of the user we are viewing) */
	3448	/* j=user_ext_ip (external ip of the user we */
	3449	/* are viewing) */
	3450	break;
	3451	case 0x17: /* ?? */
	3452	break;
	3453	}
	3454	yid->wcd->to_read -= pos - begin;
	3455
	3456	yid->rxlen -= pos;
	3457	DEBUG_MSG(("rxlen == %d, rxqueue == %p", yid->rxlen, yid->rxqueue));
	3458	if (yid->rxlen>0) {
	3459	unsigned char *tmp = y_memdup(yid->rxqueue + pos, yid->rxlen);
	3460	FREE(yid->rxqueue);
	3461	yid->rxqueue = tmp;
	3462	DEBUG_MSG(("new rxlen == %d, rxqueue == %p", yid->rxlen, yid->rxqueue));
	3463	} else {
	3464	DEBUG_MSG(("freed rxqueue == %p", yid->rxqueue));
	3465	FREE(yid->rxqueue);
	3466	}
	3467
	3468	/* If we read a complete packet return success */
	3469	if (!yid->wcd->to_read)
	3470	return 1;
	3471
	3472	return 0;
	3473	}
	3474
	3475	int yahoo_write_ready(int id, int fd, void *data)
	3476	{
	3477	struct yahoo_input_data *yid = data;
	3478	int len;
	3479	struct data_queue *tx;
	3480
	3481	LOG(("write callback: id=%d fd=%d data=%p", id, fd, data));
[52df5df]	3482	if(!yid \|\| !yid->txqueues \|\| !find_conn_by_id(id))
[b7d3cc34]	3483	return -2;
	3484
	3485	tx = yid->txqueues->data;
	3486	LOG(("writing %d bytes", tx->len));
	3487	len = yahoo_send_data(fd, tx->queue, MIN(1024, tx->len));
	3488
	3489	if(len == -1 && errno == EAGAIN)
	3490	return 1;
	3491
	3492	if(len <= 0) {
	3493	int e = errno;
	3494	DEBUG_MSG(("len == %d (<= 0)", len));
	3495	while(yid->txqueues) {
	3496	YList *l=yid->txqueues;
	3497	tx = l->data;
	3498	free(tx->queue);
	3499	free(tx);
	3500	yid->txqueues = y_list_remove_link(yid->txqueues, yid->txqueues);
	3501	y_list_free_1(l);
	3502	}
	3503	LOG(("yahoo_write_ready(%d, %d) len < 0", id, fd));
	3504	YAHOO_CALLBACK(ext_yahoo_remove_handler)(id, yid->write_tag);
	3505	yid->write_tag = 0;
	3506	errno=e;
	3507	return 0;
	3508	}
	3509
	3510
	3511	tx->len -= len;
	3512	if(tx->len > 0) {
	3513	unsigned char *tmp = y_memdup(tx->queue + len, tx->len);
	3514	FREE(tx->queue);
	3515	tx->queue = tmp;
	3516	} else {
	3517	YList *l=yid->txqueues;
	3518	free(tx->queue);
	3519	free(tx);
	3520	yid->txqueues = y_list_remove_link(yid->txqueues, yid->txqueues);
	3521	y_list_free_1(l);
	3522	/*
	3523	if(!yid->txqueues)
	3524	LOG(("yahoo_write_ready(%d, %d) !yxqueues", id, fd));
	3525	*/
	3526	if(!yid->txqueues) {
	3527	LOG(("yahoo_write_ready(%d, %d) !yxqueues", id, fd));
	3528	YAHOO_CALLBACK(ext_yahoo_remove_handler)(id, yid->write_tag);
	3529	yid->write_tag = 0;
	3530	}
	3531	}
	3532
	3533	return 1;
	3534	}
	3535
	3536	static void yahoo_process_pager_connection(struct yahoo_input_data *yid, int over)
	3537	{
	3538	struct yahoo_packet *pkt;
	3539	struct yahoo_data *yd = yid->yd;
	3540	int id = yd->client_id;
	3541
	3542	if(over)
	3543	return;
	3544
	3545	while (find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER)
	3546	&& (pkt = yahoo_getdata(yid)) != NULL) {
	3547
	3548	yahoo_packet_process(yid, pkt);
	3549
	3550	yahoo_packet_free(pkt);
	3551	}
	3552	}
	3553
	3554	static void yahoo_process_ft_connection(struct yahoo_input_data *yid, int over)
	3555	{
	3556	}
	3557
	3558	static void yahoo_process_chatcat_connection(struct yahoo_input_data *yid, int over)
	3559	{
	3560	if(over)
	3561	return;
	3562
	3563	if (strstr((char*)yid->rxqueue+(yid->rxlen-20), "</content>")) {
	3564	YAHOO_CALLBACK(ext_yahoo_chat_cat_xml)(yid->yd->client_id, (char*)yid->rxqueue);
	3565	}
	3566	}
	3567
	3568	static void yahoo_process_yab_connection(struct yahoo_input_data *yid, int over)
	3569	{
	3570	struct yahoo_data *yd = yid->yd;
	3571	struct yab *yab;
	3572	YList *buds;
	3573	int changed=0;
	3574	int id = yd->client_id;
	3575
	3576	if(over)
	3577	return;
	3578
	3579	while(find_input_by_id_and_type(id, YAHOO_CONNECTION_YAB)
	3580	&& (yab = yahoo_getyab(yid)) != NULL) {
	3581	if(!yab->id)
	3582	continue;
	3583	changed=1;
	3584	for(buds = yd->buddies; buds; buds=buds->next) {
	3585	struct yahoo_buddy * bud = buds->data;
	3586	if(!strcmp(bud->id, yab->id)) {
	3587	bud->yab_entry = yab;
	3588	if(yab->nname) {
	3589	bud->real_name = strdup(yab->nname);
	3590	} else if(yab->fname && yab->lname) {
	3591	bud->real_name = y_new0(char,
	3592	strlen(yab->fname)+
	3593	strlen(yab->lname)+2
	3594	);
	3595	sprintf(bud->real_name, "%s %s",
	3596	yab->fname, yab->lname);
	3597	} else if(yab->fname) {
	3598	bud->real_name = strdup(yab->fname);
	3599	}
	3600	break; /* for */
	3601	}
	3602	}
	3603	}
	3604
	3605	if(changed)
	3606	YAHOO_CALLBACK(ext_yahoo_got_buddies)(yd->client_id, yd->buddies);
	3607	}
	3608
	3609	static void yahoo_process_search_connection(struct yahoo_input_data *yid, int over)
	3610	{
	3611	struct yahoo_found_contact *yct=NULL;
	3612	char p = (char )yid->rxqueue, np, cp;
	3613	int k, n;
	3614	int start=0, found=0, total=0;
	3615	YList *contacts=NULL;
	3616	struct yahoo_input_data *pyid = find_input_by_id_and_type(yid->yd->client_id, YAHOO_CONNECTION_PAGER);
	3617
	3618	if(!over \|\| !pyid)
	3619	return;
	3620
	3621	if(p && (p=strstr(p, "\r\n\r\n"))) {
	3622	p += 4;
	3623
	3624	for(k = 0; (p = strchr(p, 4)) && (k < 4); k++) {
	3625	p++;
	3626	n = atoi(p);
	3627	switch(k) {
	3628	case 0: found = pyid->ys->lsearch_nfound = n; break;
	3629	case 2: start = pyid->ys->lsearch_nstart = n; break;
	3630	case 3: total = pyid->ys->lsearch_ntotal = n; break;
	3631	}
	3632	}
	3633
	3634	if(p)
	3635	p++;
	3636
	3637	k=0;
	3638	while(p && *p) {
	3639	cp = p;
	3640	np = strchr(p, 4);
	3641
	3642	if(!np)
	3643	break;
	3644	*np = 0;
	3645	p = np+1;
	3646
	3647	switch(k++) {
	3648	case 1:
	3649	if(strlen(cp) > 2 && y_list_length(contacts) < total) {
	3650	yct = y_new0(struct yahoo_found_contact, 1);
	3651	contacts = y_list_append(contacts, yct);
	3652	yct->id = cp+2;
	3653	} else {
	3654	*p = 0;
	3655	}
	3656	break;
	3657	case 2:
	3658	yct->online = !strcmp(cp, "2") ? 1 : 0;
	3659	break;
	3660	case 3:
	3661	yct->gender = cp;
	3662	break;
	3663	case 4:
	3664	yct->age = atoi(cp);
	3665	break;
	3666	case 5:
[4bb50ef]	3667	if(strcmp(cp, "5") != 0)
[b7d3cc34]	3668	yct->location = cp;
	3669	k = 0;
	3670	break;
	3671	}
	3672	}
	3673	}
	3674
	3675	YAHOO_CALLBACK(ext_yahoo_got_search_result)(yid->yd->client_id, found, start, total, contacts);
	3676
	3677	while(contacts) {
	3678	YList *node = contacts;
	3679	contacts = y_list_remove_link(contacts, node);
	3680	free(node->data);
	3681	y_list_free_1(node);
	3682	}
	3683	}
	3684
	3685	static void _yahoo_webcam_connected(int fd, int error, void *d)
	3686	{
	3687	struct yahoo_input_data *yid = d;
	3688	struct yahoo_webcam *wcm = yid->wcm;
	3689	struct yahoo_data *yd = yid->yd;
	3690	char conn_type[100];
	3691	char *data=NULL;
	3692	char *packet=NULL;
	3693	unsigned char magic_nr[] = {1, 0, 0, 0, 1};
	3694	unsigned header_len=0;
	3695	unsigned int len=0;
	3696	unsigned int pos=0;
	3697
	3698	if(error \|\| fd <= 0) {
	3699	FREE(yid);
	3700	return;
	3701	}
	3702
	3703	yid->fd = fd;
	3704	inputs = y_list_prepend(inputs, yid);
	3705
	3706	LOG(("Connected"));
	3707	/* send initial packet */
	3708	switch (wcm->direction)
	3709	{
	3710	case YAHOO_WEBCAM_DOWNLOAD:
	3711	data = strdup("<REQIMG>");
	3712	break;
	3713	case YAHOO_WEBCAM_UPLOAD:
	3714	data = strdup("<SNDIMG>");
	3715	break;
	3716	default:
	3717	return;
	3718	}
	3719	yahoo_add_to_send_queue(yid, data, strlen(data));
	3720	FREE(data);
	3721
	3722	/* send data */
	3723	switch (wcm->direction)
	3724	{
	3725	case YAHOO_WEBCAM_DOWNLOAD:
	3726	header_len = 8;
	3727	data = strdup("a=2\r\nc=us\r\ne=21\r\nu=");
	3728	data = y_string_append(data, yd->user);
	3729	data = y_string_append(data, "\r\nt=");
	3730	data = y_string_append(data, wcm->key);
	3731	data = y_string_append(data, "\r\ni=");
	3732	data = y_string_append(data, wcm->my_ip);
	3733	data = y_string_append(data, "\r\ng=");
	3734	data = y_string_append(data, wcm->user);
	3735	data = y_string_append(data, "\r\no=w-2-5-1\r\np=");
	3736	snprintf(conn_type, sizeof(conn_type), "%d", wcm->conn_type);
	3737	data = y_string_append(data, conn_type);
	3738	data = y_string_append(data, "\r\n");
	3739	break;
	3740	case YAHOO_WEBCAM_UPLOAD:
	3741	header_len = 13;
	3742	data = strdup("a=2\r\nc=us\r\nu=");
	3743	data = y_string_append(data, yd->user);
	3744	data = y_string_append(data, "\r\nt=");
	3745	data = y_string_append(data, wcm->key);
	3746	data = y_string_append(data, "\r\ni=");
	3747	data = y_string_append(data, wcm->my_ip);
	3748	data = y_string_append(data, "\r\no=w-2-5-1\r\np=");
	3749	snprintf(conn_type, sizeof(conn_type), "%d", wcm->conn_type);
	3750	data = y_string_append(data, conn_type);
	3751	data = y_string_append(data, "\r\nb=");
	3752	data = y_string_append(data, wcm->description);
	3753	data = y_string_append(data, "\r\n");
	3754	break;
	3755	}
	3756
	3757	len = strlen(data);
	3758	packet = y_new0(char, header_len + len);
	3759	packet[pos++] = header_len;
	3760	packet[pos++] = 0;
	3761	switch (wcm->direction)
	3762	{
	3763	case YAHOO_WEBCAM_DOWNLOAD:
	3764	packet[pos++] = 1;
	3765	packet[pos++] = 0;
	3766	break;
	3767	case YAHOO_WEBCAM_UPLOAD:
	3768	packet[pos++] = 5;
	3769	packet[pos++] = 0;
	3770	break;
	3771	}
	3772
	3773	pos += yahoo_put32(packet + pos, len);
	3774	if (wcm->direction == YAHOO_WEBCAM_UPLOAD)
	3775	{
	3776	memcpy(packet + pos, magic_nr, sizeof(magic_nr));
	3777	pos += sizeof(magic_nr);
	3778	}
	3779	memcpy(packet + pos, data, len);
	3780	yahoo_add_to_send_queue(yid, packet, header_len + len);
	3781	FREE(packet);
	3782	FREE(data);
	3783
	3784	yid->read_tag=YAHOO_CALLBACK(ext_yahoo_add_handler)(yid->yd->client_id, yid->fd, YAHOO_INPUT_READ, yid);
	3785	}
	3786
	3787	static void yahoo_webcam_connect(struct yahoo_input_data *y)
	3788	{
	3789	struct yahoo_webcam *wcm = y->wcm;
	3790	struct yahoo_input_data *yid;
	3791	struct yahoo_server_settings *yss;
	3792
	3793	if (!wcm \|\| !wcm->server \|\| !wcm->key)
	3794	return;
	3795
	3796	yid = y_new0(struct yahoo_input_data, 1);
	3797	yid->type = YAHOO_CONNECTION_WEBCAM;
	3798	yid->yd = y->yd;
	3799
	3800	/* copy webcam data to new connection */
	3801	yid->wcm = y->wcm;
	3802	y->wcm = NULL;
	3803
	3804	yss = y->yd->server_settings;
	3805
	3806	yid->wcd = y_new0(struct yahoo_webcam_data, 1);
	3807
	3808	LOG(("Connecting to: %s:%d", wcm->server, wcm->port));
	3809	YAHOO_CALLBACK(ext_yahoo_connect_async)(y->yd->client_id, wcm->server, wcm->port,
	3810	_yahoo_webcam_connected, yid);
	3811
	3812	}
	3813
	3814	static void yahoo_process_webcam_master_connection(struct yahoo_input_data *yid, int over)
	3815	{
	3816	char* server;
	3817	struct yahoo_server_settings *yss;
	3818
	3819	if(over)
	3820	return;
	3821
	3822	server = yahoo_getwebcam_master(yid);
	3823
	3824	if (server)
	3825	{
	3826	yss = yid->yd->server_settings;
	3827	yid->wcm->server = strdup(server);
	3828	yid->wcm->port = yss->webcam_port;
	3829	yid->wcm->conn_type = yss->conn_type;
	3830	yid->wcm->my_ip = strdup(yss->local_host);
	3831	if (yid->wcm->direction == YAHOO_WEBCAM_UPLOAD)
	3832	yid->wcm->description = strdup(yss->webcam_description);
	3833	yahoo_webcam_connect(yid);
	3834	FREE(server);
	3835	}
	3836	}
	3837
	3838	static void yahoo_process_webcam_connection(struct yahoo_input_data *yid, int over)
	3839	{
	3840	int id = yid->yd->client_id;
	3841	int fd = yid->fd;
	3842
	3843	if(over)
	3844	return;
	3845
	3846	/* as long as we still have packets available keep processing them */
	3847	while (find_input_by_id_and_fd(id, fd)
	3848	&& yahoo_get_webcam_data(yid) == 1);
	3849	}
	3850
	3851	static void (yahoo_process_connection[])(struct yahoo_input_data , int over) = {
	3852	yahoo_process_pager_connection,
	3853	yahoo_process_ft_connection,
	3854	yahoo_process_yab_connection,
	3855	yahoo_process_webcam_master_connection,
	3856	yahoo_process_webcam_connection,
	3857	yahoo_process_chatcat_connection,
[4fefb77]	3858	yahoo_process_search_connection,
[b7d3cc34]	3859	};
	3860
	3861	int yahoo_read_ready(int id, int fd, void *data)
	3862	{
	3863	struct yahoo_input_data *yid = data;
	3864	char buf[1024];
	3865	int len;
	3866
	3867	LOG(("read callback: id=%d fd=%d data=%p", id, fd, data));
	3868	if(!yid)
	3869	return -2;
	3870
	3871
	3872	do {
	3873	len = read(fd, buf, sizeof(buf));
	3874	} while(len == -1 && errno == EINTR);
	3875
[4fefb77]	3876	if(len == -1 && (errno == EAGAIN\|\|errno == EINTR)) /* we'll try again later */
[b7d3cc34]	3877	return 1;
	3878
	3879	if (len <= 0) {
	3880	int e = errno;
	3881	DEBUG_MSG(("len == %d (<= 0)", len));
	3882
	3883	if(yid->type == YAHOO_CONNECTION_PAGER) {
[cfc8d58]	3884	YAHOO_CALLBACK(ext_yahoo_error)(yid->yd->client_id, "Connection closed by server", 1, E_CONNECTION);
[b7d3cc34]	3885	}
	3886
	3887	yahoo_process_connection[yid->type](yid, 1);
	3888	yahoo_input_close(yid);
	3889
	3890	/* no need to return an error, because we've already fixed it */
	3891	if(len == 0)
	3892	return 1;
	3893
	3894	errno=e;
	3895	LOG(("read error: %s", strerror(errno)));
	3896	return -1;
	3897	}
	3898
	3899	yid->rxqueue = y_renew(unsigned char, yid->rxqueue, len + yid->rxlen);
	3900	memcpy(yid->rxqueue + yid->rxlen, buf, len);
	3901	yid->rxlen += len;
	3902
	3903	yahoo_process_connection[yid->type](yid, 0);
	3904
	3905	return len;
	3906	}
	3907
	3908	int yahoo_init_with_attributes(const char username, const char password, ...)
	3909	{
	3910	va_list ap;
	3911	struct yahoo_data *yd;
	3912
	3913	yd = y_new0(struct yahoo_data, 1);
	3914
	3915	if(!yd)
	3916	return 0;
	3917
	3918	yd->user = strdup(username);
	3919	yd->password = strdup(password);
	3920
	3921	yd->initial_status = -1;
	3922	yd->current_status = -1;
	3923
	3924	yd->client_id = ++last_id;
	3925
	3926	add_to_list(yd);
	3927
	3928	va_start(ap, password);
	3929	yd->server_settings = _yahoo_assign_server_settings(ap);
	3930	va_end(ap);
	3931
	3932	return yd->client_id;
	3933	}
	3934
	3935	int yahoo_init(const char username, const char password)
	3936	{
	3937	return yahoo_init_with_attributes(username, password, NULL);
	3938	}
	3939
	3940	struct connect_callback_data {
	3941	struct yahoo_data *yd;
	3942	int tag;
	3943	int i;
	3944	};
	3945
	3946	static void yahoo_connected(int fd, int error, void *data)
	3947	{
	3948	struct connect_callback_data *ccd = data;
	3949	struct yahoo_data *yd = ccd->yd;
	3950	struct yahoo_packet *pkt;
	3951	struct yahoo_input_data *yid;
	3952	struct yahoo_server_settings *yss = yd->server_settings;
	3953
	3954	if(error) {
	3955	if(fallback_ports[ccd->i]) {
	3956	int tag;
	3957	yss->pager_port = fallback_ports[ccd->i++];
	3958	tag = YAHOO_CALLBACK(ext_yahoo_connect_async)(yd->client_id, yss->pager_host,
	3959	yss->pager_port, yahoo_connected, ccd);
	3960
	3961	if(tag > 0)
	3962	ccd->tag=tag;
	3963	} else {
	3964	FREE(ccd);
	3965	YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, YAHOO_LOGIN_SOCK, NULL);
	3966	}
	3967	return;
	3968	}
	3969
	3970	FREE(ccd);
	3971
	3972	/* fd < 0 && error == 0 means connect was cancelled */
	3973	if(fd < 0)
	3974	return;
	3975
	3976	pkt = yahoo_packet_new(YAHOO_SERVICE_AUTH, YAHOO_STATUS_AVAILABLE, yd->session_id);
	3977	NOTICE(("Sending initial packet"));
	3978
	3979	yahoo_packet_hash(pkt, 1, yd->user);
	3980
	3981	yid = y_new0(struct yahoo_input_data, 1);
	3982	yid->yd = yd;
	3983	yid->fd = fd;
	3984	inputs = y_list_prepend(inputs, yid);
	3985
	3986	yahoo_send_packet(yid, pkt, 0);
	3987
	3988	yahoo_packet_free(pkt);
	3989
	3990	yid->read_tag=YAHOO_CALLBACK(ext_yahoo_add_handler)(yid->yd->client_id, yid->fd, YAHOO_INPUT_READ, yid);
	3991	}
	3992
	3993	void yahoo_login(int id, int initial)
	3994	{
	3995	struct yahoo_data *yd = find_conn_by_id(id);
	3996	struct connect_callback_data *ccd;
	3997	struct yahoo_server_settings *yss;
	3998	int tag;
	3999
	4000	if(!yd)
	4001	return;
	4002
	4003	yss = yd->server_settings;
	4004
	4005	yd->initial_status = initial;
	4006
	4007	ccd = y_new0(struct connect_callback_data, 1);
	4008	ccd->yd = yd;
	4009	tag = YAHOO_CALLBACK(ext_yahoo_connect_async)(yd->client_id, yss->pager_host, yss->pager_port,
	4010	yahoo_connected, ccd);
	4011
	4012	/*
	4013	* if tag <= 0, then callback has already been called
	4014	* so ccd will have been freed
	4015	*/
	4016	if(tag > 0)
	4017	ccd->tag = tag;
	4018	else if(tag < 0)
	4019	YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, YAHOO_LOGIN_SOCK, NULL);
	4020	}
	4021
	4022
	4023	int yahoo_get_fd(int id)
	4024	{
	4025	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4026	if(!yid)
	4027	return 0;
	4028	else
	4029	return yid->fd;
	4030	}
	4031
[cfc8d58]	4032	void yahoo_send_im(int id, const char from, const char who, const char *what, int utf8, int picture)
[b7d3cc34]	4033	{
	4034	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4035	struct yahoo_packet *pkt = NULL;
	4036	struct yahoo_data *yd;
[cfc8d58]	4037	char pic_str[10];
[b7d3cc34]	4038
	4039	if(!yid)
	4040	return;
	4041
	4042	yd = yid->yd;
	4043
	4044	pkt = yahoo_packet_new(YAHOO_SERVICE_MESSAGE, YAHOO_STATUS_OFFLINE, yd->session_id);
	4045
[cfc8d58]	4046	snprintf(pic_str, sizeof(pic_str), "%d", picture);
	4047
[b7d3cc34]	4048	if(from && strcmp(from, yd->user))
	4049	yahoo_packet_hash(pkt, 0, yd->user);
	4050	yahoo_packet_hash(pkt, 1, from?from:yd->user);
	4051	yahoo_packet_hash(pkt, 5, who);
	4052	yahoo_packet_hash(pkt, 14, what);
	4053
	4054	if(utf8)
	4055	yahoo_packet_hash(pkt, 97, "1");
	4056
	4057	yahoo_packet_hash(pkt, 63, ";0"); /* imvironment name; or ;0 */
	4058	yahoo_packet_hash(pkt, 64, "0");
[cfc8d58]	4059	yahoo_packet_hash(pkt, 206, pic_str);
[b7d3cc34]	4060
	4061
	4062	yahoo_send_packet(yid, pkt, 0);
	4063
	4064	yahoo_packet_free(pkt);
	4065	}
	4066
	4067	void yahoo_send_typing(int id, const char from, const char who, int typ)
	4068	{
	4069	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4070	struct yahoo_data *yd;
	4071	struct yahoo_packet *pkt = NULL;
	4072	if(!yid)
	4073	return;
	4074
	4075	yd = yid->yd;
	4076	pkt = yahoo_packet_new(YAHOO_SERVICE_NOTIFY, YAHOO_STATUS_NOTIFY, yd->session_id);
	4077
	4078	yahoo_packet_hash(pkt, 5, who);
[ba16895]	4079	yahoo_packet_hash(pkt, 1, from?from:yd->user);
[b7d3cc34]	4080	yahoo_packet_hash(pkt, 14, " ");
	4081	yahoo_packet_hash(pkt, 13, typ ? "1" : "0");
	4082	yahoo_packet_hash(pkt, 49, "TYPING");
	4083
	4084	yahoo_send_packet(yid, pkt, 0);
	4085
	4086	yahoo_packet_free(pkt);
	4087	}
	4088
	4089	void yahoo_set_away(int id, enum yahoo_status state, const char *msg, int away)
	4090	{
	4091	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4092	struct yahoo_data *yd;
	4093	struct yahoo_packet *pkt = NULL;
[7ea8697]	4094	int old_status;
[b7d3cc34]	4095	char s[4];
	4096
	4097	if(!yid)
	4098	return;
	4099
	4100	yd = yid->yd;
[7ea8697]	4101	old_status = yd->current_status;
[4049061]	4102	yd->current_status = state;
[b7d3cc34]	4103
[7ea8697]	4104	/* Thank you libpurple :) */
	4105	if (yd->current_status == YAHOO_STATUS_INVISIBLE) {
	4106	pkt = yahoo_packet_new(YAHOO_SERVICE_Y6_VISIBILITY, YAHOO_STATUS_AVAILABLE, 0);
	4107	yahoo_packet_hash(pkt, 13, "2");
	4108	yahoo_send_packet(yid, pkt, 0);
	4109	yahoo_packet_free(pkt);
	4110
	4111	return;
	4112	}
	4113
	4114	pkt = yahoo_packet_new(YAHOO_SERVICE_Y6_STATUS_UPDATE, yd->current_status, yd->session_id);
	4115	snprintf(s, sizeof(s), "%d", yd->current_status);
	4116	yahoo_packet_hash(pkt, 10, s);
[be915f5]	4117	yahoo_packet_hash(pkt, 19, msg && state == YAHOO_STATUS_CUSTOM ? msg : "");
[7ea8697]	4118	yahoo_packet_hash(pkt, 47, (away == 2)? "2": (away) ?"1":"0");
[b7d3cc34]	4119	yahoo_send_packet(yid, pkt, 0);
	4120	yahoo_packet_free(pkt);
[7ea8697]	4121
	4122	if(old_status == YAHOO_STATUS_INVISIBLE) {
	4123	pkt = yahoo_packet_new(YAHOO_SERVICE_Y6_VISIBILITY, YAHOO_STATUS_AVAILABLE, 0);
	4124	yahoo_packet_hash(pkt, 13, "1");
	4125	yahoo_send_packet(yid, pkt, 0);
	4126	yahoo_packet_free(pkt);
	4127	}
[b7d3cc34]	4128	}
	4129
	4130	void yahoo_logoff(int id)
	4131	{
	4132	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4133	struct yahoo_data *yd;
	4134	struct yahoo_packet *pkt = NULL;
	4135
	4136	if(!yid)
	4137	return;
	4138	yd = yid->yd;
	4139
	4140	LOG(("yahoo_logoff: current status: %d", yd->current_status));
	4141
[99c8f13]	4142	if(yd->current_status != -1 && 0) {
	4143	/* Meh. Don't send this. The event handlers are not going to
	4144	get to do this so it'll just leak memory. And the TCP
	4145	connection reset will hopefully be clear enough. */
[b7d3cc34]	4146	pkt = yahoo_packet_new(YAHOO_SERVICE_LOGOFF, YAHOO_STATUS_AVAILABLE, yd->session_id);
	4147	yd->current_status = -1;
	4148
	4149	if (pkt) {
	4150	yahoo_send_packet(yid, pkt, 0);
	4151	yahoo_packet_free(pkt);
	4152	}
	4153	}
	4154
[52df5df]	4155	do {
[b7d3cc34]	4156	yahoo_input_close(yid);
[52df5df]	4157	} while((yid = find_input_by_id(id)));
[b7d3cc34]	4158	}
	4159
	4160	void yahoo_get_list(int id)
	4161	{
	4162	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4163	struct yahoo_data *yd;
	4164	struct yahoo_packet *pkt = NULL;
	4165
	4166	if(!yid)
	4167	return;
	4168	yd = yid->yd;
	4169
	4170	pkt = yahoo_packet_new(YAHOO_SERVICE_LIST, YAHOO_STATUS_AVAILABLE, yd->session_id);
	4171	yahoo_packet_hash(pkt, 1, yd->user);
	4172	if (pkt) {
	4173	yahoo_send_packet(yid, pkt, 0);
	4174	yahoo_packet_free(pkt);
	4175	}
	4176	}
	4177
	4178	static void _yahoo_http_connected(int id, int fd, int error, void *data)
	4179	{
	4180	struct yahoo_input_data *yid = data;
	4181	if(fd <= 0) {
	4182	inputs = y_list_remove(inputs, yid);
	4183	FREE(yid);
	4184	return;
	4185	}
	4186
	4187	yid->fd = fd;
	4188	yid->read_tag=YAHOO_CALLBACK(ext_yahoo_add_handler)(yid->yd->client_id, fd, YAHOO_INPUT_READ, yid);
	4189	}
	4190
	4191	void yahoo_get_yab(int id)
	4192	{
	4193	struct yahoo_data *yd = find_conn_by_id(id);
	4194	struct yahoo_input_data *yid;
	4195	char url[1024];
	4196	char buff[1024];
	4197
	4198	if(!yd)
	4199	return;
	4200
	4201	yid = y_new0(struct yahoo_input_data, 1);
	4202	yid->yd = yd;
	4203	yid->type = YAHOO_CONNECTION_YAB;
	4204
	4205	snprintf(url, 1024, "http://insider.msg.yahoo.com/ycontent/?ab2=0");
	4206
	4207	snprintf(buff, sizeof(buff), "Y=%s; T=%s",
	4208	yd->cookie_y, yd->cookie_t);
	4209
	4210	inputs = y_list_prepend(inputs, yid);
	4211
	4212	yahoo_http_get(yid->yd->client_id, url, buff,
	4213	_yahoo_http_connected, yid);
	4214	}
	4215
	4216	void yahoo_set_yab(int id, struct yab * yab)
	4217	{
	4218	struct yahoo_data *yd = find_conn_by_id(id);
	4219	struct yahoo_input_data *yid;
	4220	char url[1024];
	4221	char buff[1024];
	4222	char *temp;
	4223	int size = sizeof(url)-1;
	4224
	4225	if(!yd)
	4226	return;
	4227
	4228	yid = y_new0(struct yahoo_input_data, 1);
	4229	yid->type = YAHOO_CONNECTION_YAB;
	4230	yid->yd = yd;
	4231
	4232	strncpy(url, "http://insider.msg.yahoo.com/ycontent/?addab2=0", size);
	4233
	4234	if(yab->dbid) {
	4235	/* change existing yab */
	4236	char tmp[32];
	4237	strncat(url, "&ee=1&ow=1&id=", size - strlen(url));
	4238	snprintf(tmp, sizeof(tmp), "%d", yab->dbid);
	4239	strncat(url, tmp, size - strlen(url));
	4240	}
	4241
	4242	if(yab->fname) {
	4243	strncat(url, "&fn=", size - strlen(url));
	4244	temp = yahoo_urlencode(yab->fname);
	4245	strncat(url, temp, size - strlen(url));
	4246	free(temp);
	4247	}
	4248	if(yab->lname) {
	4249	strncat(url, "&ln=", size - strlen(url));
	4250	temp = yahoo_urlencode(yab->lname);
	4251	strncat(url, temp, size - strlen(url));
	4252	free(temp);
	4253	}
	4254	strncat(url, "&yid=", size - strlen(url));
	4255	temp = yahoo_urlencode(yab->id);
	4256	strncat(url, temp, size - strlen(url));
	4257	free(temp);
	4258	if(yab->nname) {
	4259	strncat(url, "&nn=", size - strlen(url));
	4260	temp = yahoo_urlencode(yab->nname);
	4261	strncat(url, temp, size - strlen(url));
	4262	free(temp);
	4263	}
	4264	if(yab->email) {
	4265	strncat(url, "&e=", size - strlen(url));
	4266	temp = yahoo_urlencode(yab->email);
	4267	strncat(url, temp, size - strlen(url));
	4268	free(temp);
	4269	}
	4270	if(yab->hphone) {
	4271	strncat(url, "&hp=", size - strlen(url));
	4272	temp = yahoo_urlencode(yab->hphone);
	4273	strncat(url, temp, size - strlen(url));
	4274	free(temp);
	4275	}
	4276	if(yab->wphone) {
	4277	strncat(url, "&wp=", size - strlen(url));
	4278	temp = yahoo_urlencode(yab->wphone);
	4279	strncat(url, temp, size - strlen(url));
	4280	free(temp);
	4281	}
	4282	if(yab->mphone) {
	4283	strncat(url, "&mp=", size - strlen(url));
	4284	temp = yahoo_urlencode(yab->mphone);
	4285	strncat(url, temp, size - strlen(url));
	4286	free(temp);
	4287	}
	4288	strncat(url, "&pp=0", size - strlen(url));
	4289
	4290	snprintf(buff, sizeof(buff), "Y=%s; T=%s",
	4291	yd->cookie_y, yd->cookie_t);
	4292
	4293	inputs = y_list_prepend(inputs, yid);
	4294
	4295	yahoo_http_get(yid->yd->client_id, url, buff,
	4296	_yahoo_http_connected, yid);
	4297	}
	4298
	4299	void yahoo_set_identity_status(int id, const char * identity, int active)
	4300	{
	4301	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4302	struct yahoo_data *yd;
	4303	struct yahoo_packet *pkt = NULL;
	4304
	4305	if(!yid)
	4306	return;
	4307	yd = yid->yd;
	4308
	4309	pkt = yahoo_packet_new(active?YAHOO_SERVICE_IDACT:YAHOO_SERVICE_IDDEACT,
	4310	YAHOO_STATUS_AVAILABLE, yd->session_id);
	4311	yahoo_packet_hash(pkt, 3, identity);
	4312	if (pkt) {
	4313	yahoo_send_packet(yid, pkt, 0);
	4314	yahoo_packet_free(pkt);
	4315	}
	4316	}
	4317
	4318	void yahoo_refresh(int id)
	4319	{
	4320	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4321	struct yahoo_data *yd;
	4322	struct yahoo_packet *pkt = NULL;
	4323
	4324	if(!yid)
	4325	return;
	4326	yd = yid->yd;
	4327
	4328	pkt = yahoo_packet_new(YAHOO_SERVICE_USERSTAT, YAHOO_STATUS_AVAILABLE, yd->session_id);
	4329	if (pkt) {
	4330	yahoo_send_packet(yid, pkt, 0);
	4331	yahoo_packet_free(pkt);
	4332	}
	4333	}
	4334
	4335	void yahoo_keepalive(int id)
	4336	{
	4337	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4338	struct yahoo_data *yd;
	4339	struct yahoo_packet *pkt=NULL;
	4340	if(!yid)
	4341	return;
	4342	yd = yid->yd;
	4343
	4344	pkt = yahoo_packet_new(YAHOO_SERVICE_PING, YAHOO_STATUS_AVAILABLE, yd->session_id);
	4345	yahoo_send_packet(yid, pkt, 0);
	4346	yahoo_packet_free(pkt);
	4347	}
	4348
	4349	void yahoo_chat_keepalive (int id)
	4350	{
	4351	struct yahoo_input_data *yid = find_input_by_id_and_type (id, YAHOO_CONNECTION_PAGER);
	4352	struct yahoo_data *yd;
	4353	struct yahoo_packet *pkt = NULL;
	4354
	4355	if (!yid)
	4356	return;
	4357
	4358	yd = yid->yd;
	4359
	4360	pkt = yahoo_packet_new (YAHOO_SERVICE_CHATPING, YAHOO_STATUS_AVAILABLE, yd->session_id);
	4361	yahoo_send_packet (yid, pkt, 0);
	4362	yahoo_packet_free (pkt);
	4363	}
	4364
[cfc8d58]	4365	void yahoo_add_buddy(int id, const char who, const char group, const char *msg)
[b7d3cc34]	4366	{
	4367	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4368	struct yahoo_data *yd;
	4369	struct yahoo_packet *pkt;
	4370
	4371	if(!yid)
	4372	return;
	4373	yd = yid->yd;
	4374
	4375	if (!yd->logged_in)
	4376	return;
	4377
[ba16895]	4378	pkt = yahoo_packet_new(YAHOO_SERVICE_ADDBUDDY, YPACKET_STATUS_DEFAULT, yd->session_id);
	4379
[cfc8d58]	4380	if (msg != NULL) /* add message/request "it's me add me" */
	4381	yahoo_packet_hash(pkt, 14, msg);
[ba16895]	4382	else
	4383	yahoo_packet_hash(pkt,14,"");
	4384
	4385	yahoo_packet_hash(pkt, 65, group);
	4386	yahoo_packet_hash(pkt, 97, "1");
	4387	yahoo_packet_hash(pkt, 1, yd->user);
	4388	yahoo_packet_hash(pkt, 302, "319");
	4389	yahoo_packet_hash(pkt, 300, "319");
	4390	yahoo_packet_hash(pkt, 7, who);
	4391	yahoo_packet_hash(pkt, 334, "0");
	4392	yahoo_packet_hash(pkt, 301, "319");
	4393	yahoo_packet_hash(pkt, 303, "319");
	4394
	4395
[b7d3cc34]	4396	yahoo_send_packet(yid, pkt, 0);
	4397	yahoo_packet_free(pkt);
	4398	}
	4399
	4400	void yahoo_remove_buddy(int id, const char who, const char group)
	4401	{
	4402	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4403	struct yahoo_data *yd;
	4404	struct yahoo_packet *pkt = NULL;
	4405
	4406	if(!yid)
	4407	return;
	4408	yd = yid->yd;
	4409
	4410	pkt = yahoo_packet_new(YAHOO_SERVICE_REMBUDDY, YAHOO_STATUS_AVAILABLE, yd->session_id);
	4411
	4412	yahoo_packet_hash(pkt, 1, yd->user);
	4413	yahoo_packet_hash(pkt, 7, who);
	4414	yahoo_packet_hash(pkt, 65, group);
	4415	yahoo_send_packet(yid, pkt, 0);
	4416	yahoo_packet_free(pkt);
	4417	}
	4418
[ba16895]	4419	void yahoo_accept_buddy_ymsg13(int id,const char* me,const char* who){
	4420	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4421	struct yahoo_data *yd;
	4422
	4423	if(!yid)
	4424	return;
	4425	yd = yid->yd;
	4426
	4427	struct yahoo_packet* pkt=NULL;
	4428	pkt= yahoo_packet_new(YAHOO_SERVICE_CONTACT_YMSG13,YAHOO_STATUS_AVAILABLE,0);
	4429
	4430	yahoo_packet_hash(pkt,1,me ?: yd->user);
	4431	yahoo_packet_hash(pkt,5,who);
	4432	yahoo_packet_hash(pkt,13,"1");
	4433	yahoo_packet_hash(pkt,334,"0");
	4434	yahoo_send_packet(yid, pkt, 0);
	4435	yahoo_packet_free(pkt);
	4436	}
	4437
	4438	void yahoo_reject_buddy_ymsg13(int id,const char* me,const char* who,const char* msg){
	4439	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4440	struct yahoo_data *yd;
	4441
	4442	if(!yid)
	4443	return;
	4444	yd = yid->yd;
	4445
	4446	struct yahoo_packet* pkt=NULL;
	4447	pkt= yahoo_packet_new(YAHOO_SERVICE_CONTACT_YMSG13,YAHOO_STATUS_AVAILABLE,0);
	4448
	4449	yahoo_packet_hash(pkt,1,me ?: yd->user);
	4450	yahoo_packet_hash(pkt,5,who);
	4451	// yahoo_packet_hash(pkt,241,YAHOO_PROTO_VER);
	4452	yahoo_packet_hash(pkt,13,"2");
	4453	yahoo_packet_hash(pkt,334,"0");
	4454	yahoo_packet_hash(pkt,97,"1");
	4455	yahoo_packet_hash(pkt,14,msg?:"");
	4456
	4457	yahoo_send_packet(yid, pkt, 0);
	4458	yahoo_packet_free(pkt);
	4459
	4460	}
	4461
[b7d3cc34]	4462	void yahoo_reject_buddy(int id, const char who, const char msg)
	4463	{
	4464	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4465	struct yahoo_data *yd;
	4466	struct yahoo_packet *pkt;
	4467
	4468	if(!yid)
	4469	return;
	4470	yd = yid->yd;
	4471
	4472	if (!yd->logged_in)
	4473	return;
	4474
	4475	pkt = yahoo_packet_new(YAHOO_SERVICE_REJECTCONTACT, YAHOO_STATUS_AVAILABLE, yd->session_id);
	4476	yahoo_packet_hash(pkt, 1, yd->user);
	4477	yahoo_packet_hash(pkt, 7, who);
	4478	yahoo_packet_hash(pkt, 14, msg);
	4479	yahoo_send_packet(yid, pkt, 0);
	4480	yahoo_packet_free(pkt);
	4481	}
	4482
	4483	void yahoo_ignore_buddy(int id, const char *who, int unignore)
	4484	{
	4485	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4486	struct yahoo_data *yd;
	4487	struct yahoo_packet *pkt;
	4488
	4489	if(!yid)
	4490	return;
	4491	yd = yid->yd;
	4492
	4493	if (!yd->logged_in)
	4494	return;
	4495
	4496	pkt = yahoo_packet_new(YAHOO_SERVICE_IGNORECONTACT, YAHOO_STATUS_AVAILABLE, yd->session_id);
	4497	yahoo_packet_hash(pkt, 1, yd->user);
	4498	yahoo_packet_hash(pkt, 7, who);
	4499	yahoo_packet_hash(pkt, 13, unignore?"2":"1");
	4500	yahoo_send_packet(yid, pkt, 0);
	4501	yahoo_packet_free(pkt);
	4502	}
	4503
[cfc8d58]	4504	void yahoo_stealth_buddy(int id, const char *who, int unstealth)
	4505	{
	4506	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4507	struct yahoo_data *yd;
	4508	struct yahoo_packet *pkt;
	4509
	4510	if(!yid)
	4511	return;
	4512	yd = yid->yd;
	4513
	4514	if (!yd->logged_in)
	4515	return;
	4516
[ba16895]	4517	pkt = yahoo_packet_new(YAHOO_SERVICE_STEALTH, YAHOO_STATUS_AVAILABLE, yd->session_id);
[cfc8d58]	4518	yahoo_packet_hash(pkt, 1, yd->user);
	4519	yahoo_packet_hash(pkt, 7, who);
	4520	yahoo_packet_hash(pkt, 31, unstealth?"2":"1");
	4521	yahoo_packet_hash(pkt, 13, "2");
	4522	yahoo_send_packet(yid, pkt, 0);
	4523	yahoo_packet_free(pkt);
	4524	}
	4525
[b7d3cc34]	4526	void yahoo_change_buddy_group(int id, const char who, const char old_group, const char *new_group)
	4527	{
	4528	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4529	struct yahoo_data *yd;
	4530	struct yahoo_packet *pkt = NULL;
	4531
	4532	if(!yid)
	4533	return;
	4534	yd = yid->yd;
	4535
	4536	pkt = yahoo_packet_new(YAHOO_SERVICE_ADDBUDDY, YAHOO_STATUS_AVAILABLE, yd->session_id);
	4537	yahoo_packet_hash(pkt, 1, yd->user);
	4538	yahoo_packet_hash(pkt, 7, who);
	4539	yahoo_packet_hash(pkt, 65, new_group);
	4540	yahoo_packet_hash(pkt, 14, " ");
	4541
	4542	yahoo_send_packet(yid, pkt, 0);
	4543	yahoo_packet_free(pkt);
	4544
	4545	pkt = yahoo_packet_new(YAHOO_SERVICE_REMBUDDY, YAHOO_STATUS_AVAILABLE, yd->session_id);
	4546	yahoo_packet_hash(pkt, 1, yd->user);
	4547	yahoo_packet_hash(pkt, 7, who);
	4548	yahoo_packet_hash(pkt, 65, old_group);
	4549	yahoo_send_packet(yid, pkt, 0);
	4550	yahoo_packet_free(pkt);
	4551	}
	4552
	4553	void yahoo_group_rename(int id, const char old_group, const char new_group)
	4554	{
	4555	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4556	struct yahoo_data *yd;
	4557	struct yahoo_packet *pkt = NULL;
	4558
	4559	if(!yid)
	4560	return;
	4561	yd = yid->yd;
	4562
	4563	pkt = yahoo_packet_new(YAHOO_SERVICE_GROUPRENAME, YAHOO_STATUS_AVAILABLE, yd->session_id);
	4564	yahoo_packet_hash(pkt, 1, yd->user);
	4565	yahoo_packet_hash(pkt, 65, old_group);
	4566	yahoo_packet_hash(pkt, 67, new_group);
	4567
	4568	yahoo_send_packet(yid, pkt, 0);
	4569	yahoo_packet_free(pkt);
	4570	}
	4571
	4572	void yahoo_conference_addinvite(int id, const char * from, const char who, const char room, const YList * members, const char *msg)
	4573	{
	4574	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4575	struct yahoo_data *yd;
	4576	struct yahoo_packet *pkt;
	4577
	4578	if(!yid)
	4579	return;
	4580	yd = yid->yd;
	4581
	4582	pkt = yahoo_packet_new(YAHOO_SERVICE_CONFADDINVITE, YAHOO_STATUS_AVAILABLE, yd->session_id);
	4583
	4584	yahoo_packet_hash(pkt, 1, (from?from:yd->user));
	4585	yahoo_packet_hash(pkt, 51, who);
	4586	yahoo_packet_hash(pkt, 57, room);
	4587	yahoo_packet_hash(pkt, 58, msg);
	4588	yahoo_packet_hash(pkt, 13, "0");
	4589	for(; members; members = members->next) {
	4590	yahoo_packet_hash(pkt, 52, (char *)members->data);
	4591	yahoo_packet_hash(pkt, 53, (char *)members->data);
	4592	}
	4593	/* 52, 53 -> other members? */
	4594
	4595	yahoo_send_packet(yid, pkt, 0);
	4596
	4597	yahoo_packet_free(pkt);
	4598	}
	4599
	4600	void yahoo_conference_invite(int id, const char * from, YList who, const char room, const char *msg)
	4601	{
	4602	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4603	struct yahoo_data *yd;
	4604	struct yahoo_packet *pkt;
	4605
	4606	if(!yid)
	4607	return;
	4608	yd = yid->yd;
	4609
	4610	pkt = yahoo_packet_new(YAHOO_SERVICE_CONFINVITE, YAHOO_STATUS_AVAILABLE, yd->session_id);
	4611
	4612	yahoo_packet_hash(pkt, 1, (from?from:yd->user));
	4613	yahoo_packet_hash(pkt, 50, yd->user);
	4614	for(; who; who = who->next) {
	4615	yahoo_packet_hash(pkt, 52, (char *)who->data);
	4616	}
	4617	yahoo_packet_hash(pkt, 57, room);
	4618	yahoo_packet_hash(pkt, 58, msg);
	4619	yahoo_packet_hash(pkt, 13, "0");
	4620
	4621	yahoo_send_packet(yid, pkt, 0);
	4622
	4623	yahoo_packet_free(pkt);
	4624	}
	4625
	4626	void yahoo_conference_logon(int id, const char from, YList who, const char *room)
	4627	{
	4628	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4629	struct yahoo_data *yd;
	4630	struct yahoo_packet *pkt;
	4631
	4632	if(!yid)
	4633	return;
	4634	yd = yid->yd;
	4635
	4636	pkt = yahoo_packet_new(YAHOO_SERVICE_CONFLOGON, YAHOO_STATUS_AVAILABLE, yd->session_id);
	4637
	4638	yahoo_packet_hash(pkt, 1, (from?from:yd->user));
	4639	for(; who; who = who->next) {
	4640	yahoo_packet_hash(pkt, 3, (char *)who->data);
	4641	}
	4642	yahoo_packet_hash(pkt, 57, room);
	4643
	4644	yahoo_send_packet(yid, pkt, 0);
	4645
	4646	yahoo_packet_free(pkt);
	4647	}
	4648
	4649	void yahoo_conference_decline(int id, const char * from, YList who, const char room, const char *msg)
	4650	{
	4651	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4652	struct yahoo_data *yd;
	4653	struct yahoo_packet *pkt;
	4654
	4655	if(!yid)
	4656	return;
	4657	yd = yid->yd;
	4658
	4659	pkt = yahoo_packet_new(YAHOO_SERVICE_CONFDECLINE, YAHOO_STATUS_AVAILABLE, yd->session_id);
	4660
	4661	yahoo_packet_hash(pkt, 1, (from?from:yd->user));
	4662	for(; who; who = who->next) {
	4663	yahoo_packet_hash(pkt, 3, (char *)who->data);
	4664	}
	4665	yahoo_packet_hash(pkt, 57, room);
	4666	yahoo_packet_hash(pkt, 14, msg);
	4667
	4668	yahoo_send_packet(yid, pkt, 0);
	4669
	4670	yahoo_packet_free(pkt);
	4671	}
	4672
	4673	void yahoo_conference_logoff(int id, const char * from, YList who, const char room)
	4674	{
	4675	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4676	struct yahoo_data *yd;
	4677	struct yahoo_packet *pkt;
	4678
	4679	if(!yid)
	4680	return;
	4681	yd = yid->yd;
	4682
	4683	pkt = yahoo_packet_new(YAHOO_SERVICE_CONFLOGOFF, YAHOO_STATUS_AVAILABLE, yd->session_id);
	4684
	4685	yahoo_packet_hash(pkt, 1, (from?from:yd->user));
	4686	for(; who; who = who->next) {
	4687	yahoo_packet_hash(pkt, 3, (char *)who->data);
	4688	}
	4689	yahoo_packet_hash(pkt, 57, room);
	4690
	4691	yahoo_send_packet(yid, pkt, 0);
	4692
	4693	yahoo_packet_free(pkt);
	4694	}
	4695
	4696	void yahoo_conference_message(int id, const char * from, YList who, const char room, const char *msg, int utf8)
	4697	{
	4698	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4699	struct yahoo_data *yd;
	4700	struct yahoo_packet *pkt;
	4701
	4702	if(!yid)
	4703	return;
	4704	yd = yid->yd;
	4705
	4706	pkt = yahoo_packet_new(YAHOO_SERVICE_CONFMSG, YAHOO_STATUS_AVAILABLE, yd->session_id);
	4707
	4708	yahoo_packet_hash(pkt, 1, (from?from:yd->user));
	4709	for(; who; who = who->next) {
	4710	yahoo_packet_hash(pkt, 53, (char *)who->data);
	4711	}
	4712	yahoo_packet_hash(pkt, 57, room);
	4713	yahoo_packet_hash(pkt, 14, msg);
	4714
	4715	if(utf8)
	4716	yahoo_packet_hash(pkt, 97, "1");
	4717
	4718	yahoo_send_packet(yid, pkt, 0);
	4719
	4720	yahoo_packet_free(pkt);
	4721	}
	4722
	4723	void yahoo_get_chatrooms(int id, int chatroomid)
	4724	{
	4725	struct yahoo_data *yd = find_conn_by_id(id);
	4726	struct yahoo_input_data *yid;
	4727	char url[1024];
	4728	char buff[1024];
	4729
	4730	if(!yd)
	4731	return;
	4732
	4733	yid = y_new0(struct yahoo_input_data, 1);
	4734	yid->yd = yd;
	4735	yid->type = YAHOO_CONNECTION_CHATCAT;
	4736
	4737	if (chatroomid == 0) {
	4738	snprintf(url, 1024, "http://insider.msg.yahoo.com/ycontent/?chatcat=0");
	4739	} else {
	4740	snprintf(url, 1024, "http://insider.msg.yahoo.com/ycontent/?chatroom_%d=0",chatroomid);
	4741	}
	4742
	4743	snprintf(buff, sizeof(buff), "Y=%s; T=%s", yd->cookie_y, yd->cookie_t);
	4744
	4745	inputs = y_list_prepend(inputs, yid);
	4746
	4747	yahoo_http_get(yid->yd->client_id, url, buff, _yahoo_http_connected, yid);
	4748	}
	4749
	4750	void yahoo_chat_logon(int id, const char from, const char room, const char *roomid)
	4751	{
	4752	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4753	struct yahoo_data *yd;
	4754	struct yahoo_packet *pkt;
	4755
	4756	if(!yid)
	4757	return;
	4758
	4759	yd = yid->yd;
	4760
	4761	pkt = yahoo_packet_new(YAHOO_SERVICE_CHATONLINE, YAHOO_STATUS_AVAILABLE, yd->session_id);
	4762
	4763	yahoo_packet_hash(pkt, 1, (from?from:yd->user));
	4764	yahoo_packet_hash(pkt, 109, yd->user);
	4765	yahoo_packet_hash(pkt, 6, "abcde");
	4766
	4767	yahoo_send_packet(yid, pkt, 0);
	4768
	4769	yahoo_packet_free(pkt);
	4770
	4771	pkt = yahoo_packet_new(YAHOO_SERVICE_CHATJOIN, YAHOO_STATUS_AVAILABLE, yd->session_id);
	4772
	4773	yahoo_packet_hash(pkt, 1, (from?from:yd->user));
	4774	yahoo_packet_hash(pkt, 104, room);
	4775	yahoo_packet_hash(pkt, 129, roomid);
	4776	yahoo_packet_hash(pkt, 62, "2"); /* ??? */
	4777
	4778	yahoo_send_packet(yid, pkt, 0);
	4779
	4780	yahoo_packet_free(pkt);
	4781	}
	4782
	4783
	4784	void yahoo_chat_message(int id, const char from, const char room, const char *msg, const int msgtype, const int utf8)
	4785	{
	4786	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4787	struct yahoo_data *yd;
	4788	struct yahoo_packet *pkt;
	4789	char buf[2];
	4790
	4791	if(!yid)
	4792	return;
	4793
	4794	yd = yid->yd;
	4795
	4796	pkt = yahoo_packet_new(YAHOO_SERVICE_COMMENT, YAHOO_STATUS_AVAILABLE, yd->session_id);
	4797
	4798	yahoo_packet_hash(pkt, 1, (from?from:yd->user));
	4799	yahoo_packet_hash(pkt, 104, room);
	4800	yahoo_packet_hash(pkt, 117, msg);
	4801
	4802	snprintf(buf, sizeof(buf), "%d", msgtype);
	4803	yahoo_packet_hash(pkt, 124, buf);
	4804
	4805	if(utf8)
	4806	yahoo_packet_hash(pkt, 97, "1");
	4807
	4808	yahoo_send_packet(yid, pkt, 0);
	4809
	4810	yahoo_packet_free(pkt);
	4811	}
	4812
	4813
	4814	void yahoo_chat_logoff(int id, const char *from)
	4815	{
	4816	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4817	struct yahoo_data *yd;
	4818	struct yahoo_packet *pkt;
	4819
	4820	if(!yid)
	4821	return;
	4822
	4823	yd = yid->yd;
	4824
	4825	pkt = yahoo_packet_new(YAHOO_SERVICE_CHATLOGOUT, YAHOO_STATUS_AVAILABLE, yd->session_id);
	4826
	4827	yahoo_packet_hash(pkt, 1, (from?from:yd->user));
	4828
	4829	yahoo_send_packet(yid, pkt, 0);
	4830
	4831	yahoo_packet_free(pkt);
	4832	}
	4833
[cfc8d58]	4834	void yahoo_buddyicon_request(int id, const char *who)
	4835	{
	4836	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4837	struct yahoo_data *yd;
	4838	struct yahoo_packet *pkt;
	4839
	4840	if( !yid )
	4841	return;
	4842
	4843	yd = yid->yd;
	4844
	4845	pkt = yahoo_packet_new(YAHOO_SERVICE_PICTURE, YAHOO_STATUS_AVAILABLE, 0);
	4846	yahoo_packet_hash(pkt, 4, yd->user);
	4847	yahoo_packet_hash(pkt, 5, who);
	4848	yahoo_packet_hash(pkt, 13, "1");
	4849	yahoo_send_packet(yid, pkt, 0);
	4850
	4851	yahoo_packet_free(pkt);
	4852	}
	4853
	4854	void yahoo_send_picture_info(int id, const char who, const char url, int checksum)
	4855	{
	4856	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4857	struct yahoo_data *yd;
	4858	struct yahoo_packet *pkt;
	4859	char checksum_str[10];
	4860
	4861	if( !yid )
	4862	return;
	4863
	4864	yd = yid->yd;
	4865
	4866	snprintf(checksum_str, sizeof(checksum_str), "%d", checksum);
	4867
	4868	pkt = yahoo_packet_new(YAHOO_SERVICE_PICTURE, YAHOO_STATUS_AVAILABLE, 0);
	4869	yahoo_packet_hash(pkt, 1, yd->user);
	4870	yahoo_packet_hash(pkt, 4, yd->user);
	4871	yahoo_packet_hash(pkt, 5, who);
	4872	yahoo_packet_hash(pkt, 13, "2");
	4873	yahoo_packet_hash(pkt, 20, url);
	4874	yahoo_packet_hash(pkt, 192, checksum_str);
	4875	yahoo_send_packet(yid, pkt, 0);
	4876
	4877	yahoo_packet_free(pkt);
	4878	}
	4879
	4880	void yahoo_send_picture_update(int id, const char *who, int type)
	4881	{
	4882	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4883	struct yahoo_data *yd;
	4884	struct yahoo_packet *pkt;
	4885	char type_str[10];
	4886
	4887	if( !yid )
	4888	return;
	4889
	4890	yd = yid->yd;
	4891
	4892	snprintf(type_str, sizeof(type_str), "%d", type);
	4893
	4894	pkt = yahoo_packet_new(YAHOO_SERVICE_PICTURE_UPDATE, YAHOO_STATUS_AVAILABLE, 0);
	4895	yahoo_packet_hash(pkt, 1, yd->user);
	4896	yahoo_packet_hash(pkt, 5, who);
	4897	yahoo_packet_hash(pkt, 206, type_str);
	4898	yahoo_send_packet(yid, pkt, 0);
	4899
	4900	yahoo_packet_free(pkt);
	4901	}
	4902
	4903	void yahoo_send_picture_checksum(int id, const char *who, int checksum)
	4904	{
	4905	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4906	struct yahoo_data *yd;
	4907	struct yahoo_packet *pkt;
	4908	char checksum_str[10];
	4909
	4910	if( !yid )
	4911	return;
	4912
	4913	yd = yid->yd;
	4914
	4915	snprintf(checksum_str, sizeof(checksum_str), "%d", checksum);
	4916
	4917	pkt = yahoo_packet_new(YAHOO_SERVICE_PICTURE_CHECKSUM, YAHOO_STATUS_AVAILABLE, 0);
	4918	yahoo_packet_hash(pkt, 1, yd->user);
	4919	if( who != 0 )
	4920	yahoo_packet_hash(pkt, 5, who);
	4921	yahoo_packet_hash(pkt, 192, checksum_str);
	4922	yahoo_packet_hash(pkt, 212, "1");
	4923	yahoo_send_packet(yid, pkt, 0);
	4924
	4925	yahoo_packet_free(pkt);
	4926	}
	4927
[b7d3cc34]	4928	void yahoo_webcam_close_feed(int id, const char *who)
	4929	{
	4930	struct yahoo_input_data *yid = find_input_by_id_and_webcam_user(id, who);
	4931
	4932	if(yid)
	4933	yahoo_input_close(yid);
	4934	}
	4935
	4936	void yahoo_webcam_get_feed(int id, const char *who)
	4937	{
	4938	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	4939	struct yahoo_data *yd;
	4940	struct yahoo_packet *pkt;
	4941
	4942	if(!yid)
	4943	return;
	4944
	4945	/*
	4946	* add the user to the queue. this is a dirty hack, since
	4947	* the yahoo server doesn't tell us who's key it's returning,
	4948	* we have to just hope that it sends back keys in the same
	4949	* order that we request them.
	4950	* The queue is popped in yahoo_process_webcam_key
	4951	*/
	4952	webcam_queue = y_list_append(webcam_queue, who?strdup(who):NULL);
	4953
	4954	yd = yid->yd;
	4955
	4956	pkt = yahoo_packet_new(YAHOO_SERVICE_WEBCAM, YAHOO_STATUS_AVAILABLE, yd->session_id);
	4957
	4958	yahoo_packet_hash(pkt, 1, yd->user);
	4959	if (who != NULL)
	4960	yahoo_packet_hash(pkt, 5, who);
	4961	yahoo_send_packet(yid, pkt, 0);
	4962
	4963	yahoo_packet_free(pkt);
	4964	}
	4965
	4966	void yahoo_webcam_send_image(int id, unsigned char *image, unsigned int length, unsigned int timestamp)
	4967	{
	4968	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_WEBCAM);
	4969	unsigned char *packet;
	4970	unsigned char header_len = 13;
	4971	unsigned int pos = 0;
	4972
	4973	if (!yid)
	4974	return;
	4975
	4976	packet = y_new0(unsigned char, header_len);
	4977
	4978	packet[pos++] = header_len;
	4979	packet[pos++] = 0;
	4980	packet[pos++] = 5; /* version byte?? */
	4981	packet[pos++] = 0;
	4982	pos += yahoo_put32(packet + pos, length);
	4983	packet[pos++] = 2; /* packet type, image */
	4984	pos += yahoo_put32(packet + pos, timestamp);
	4985	yahoo_add_to_send_queue(yid, packet, header_len);
	4986	FREE(packet);
	4987
	4988	if (length)
	4989	yahoo_add_to_send_queue(yid, image, length);
	4990	}
	4991
	4992	void yahoo_webcam_accept_viewer(int id, const char* who, int accept)
	4993	{
	4994	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_WEBCAM);
	4995	char *packet = NULL;
	4996	char *data = NULL;
	4997	unsigned char header_len = 13;
	4998	unsigned int pos = 0;
	4999	unsigned int len = 0;
	5000
	5001	if (!yid)
	5002	return;
	5003
	5004	data = strdup("u=");
	5005	data = y_string_append(data, (char*)who);
	5006	data = y_string_append(data, "\r\n");
	5007	len = strlen(data);
	5008
	5009	packet = y_new0(char, header_len + len);
	5010	packet[pos++] = header_len;
	5011	packet[pos++] = 0;
	5012	packet[pos++] = 5; /* version byte?? */
	5013	packet[pos++] = 0;
	5014	pos += yahoo_put32(packet + pos, len);
	5015	packet[pos++] = 0; /* packet type */
	5016	pos += yahoo_put32(packet + pos, accept);
	5017	memcpy(packet + pos, data, len);
	5018	FREE(data);
	5019	yahoo_add_to_send_queue(yid, packet, header_len + len);
	5020	FREE(packet);
	5021	}
	5022
	5023	void yahoo_webcam_invite(int id, const char *who)
	5024	{
	5025	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	5026	struct yahoo_packet *pkt;
	5027
	5028	if(!yid)
	5029	return;
	5030
	5031	pkt = yahoo_packet_new(YAHOO_SERVICE_NOTIFY, YAHOO_STATUS_NOTIFY, yid->yd->session_id);
	5032
	5033	yahoo_packet_hash(pkt, 49, "WEBCAMINVITE");
	5034	yahoo_packet_hash(pkt, 14, " ");
	5035	yahoo_packet_hash(pkt, 13, "0");
	5036	yahoo_packet_hash(pkt, 1, yid->yd->user);
	5037	yahoo_packet_hash(pkt, 5, who);
	5038	yahoo_send_packet(yid, pkt, 0);
	5039
	5040	yahoo_packet_free(pkt);
	5041	}
	5042
	5043	static void yahoo_search_internal(int id, int t, const char *text, int g, int ar, int photo, int yahoo_only, int startpos, int total)
	5044	{
	5045	struct yahoo_data *yd = find_conn_by_id(id);
	5046	struct yahoo_input_data *yid;
	5047	char url[1024];
	5048	char buff[1024];
	5049	char ctext, p;
	5050
	5051	if(!yd)
	5052	return;
	5053
	5054	yid = y_new0(struct yahoo_input_data, 1);
	5055	yid->yd = yd;
	5056	yid->type = YAHOO_CONNECTION_SEARCH;
	5057
	5058	/*
	5059	age range
	5060	.ar=1 - 13-18, 2 - 18-25, 3 - 25-35, 4 - 35-50, 5 - 50-70, 6 - 70+
	5061	*/
	5062
	5063	snprintf(buff, sizeof(buff), "&.sq=%%20&.tt=%d&.ss=%d", total, startpos);
	5064
	5065	ctext = strdup(text);
	5066	while((p = strchr(ctext, ' ')))
	5067	*p = '+';
	5068
	5069	snprintf(url, 1024, "http://members.yahoo.com/interests?.oc=m&.kw=%s&.sb=%d&.g=%d&.ar=0%s%s%s",
	5070	ctext, t, g, photo ? "&.p=y" : "", yahoo_only ? "&.pg=y" : "",
	5071	startpos ? buff : "");
	5072
	5073	FREE(ctext);
	5074
	5075	snprintf(buff, sizeof(buff), "Y=%s; T=%s", yd->cookie_y, yd->cookie_t);
	5076
	5077	inputs = y_list_prepend(inputs, yid);
	5078	yahoo_http_get(yid->yd->client_id, url, buff, _yahoo_http_connected, yid);
	5079	}
	5080
	5081	void yahoo_search(int id, enum yahoo_search_type t, const char *text, enum yahoo_search_gender g, enum yahoo_search_agerange ar,
	5082	int photo, int yahoo_only)
	5083	{
	5084	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	5085	struct yahoo_search_state *yss;
	5086
	5087	if(!yid)
	5088	return;
	5089
	5090	if(!yid->ys)
	5091	yid->ys = y_new0(struct yahoo_search_state, 1);
	5092
	5093	yss = yid->ys;
	5094
	5095	FREE(yss->lsearch_text);
	5096	yss->lsearch_type = t;
	5097	yss->lsearch_text = strdup(text);
	5098	yss->lsearch_gender = g;
	5099	yss->lsearch_agerange = ar;
	5100	yss->lsearch_photo = photo;
	5101	yss->lsearch_yahoo_only = yahoo_only;
	5102
	5103	yahoo_search_internal(id, t, text, g, ar, photo, yahoo_only, 0, 0);
	5104	}
	5105
	5106	void yahoo_search_again(int id, int start)
	5107	{
	5108	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
	5109	struct yahoo_search_state *yss;
	5110
	5111	if(!yid \|\| !yid->ys)
	5112	return;
	5113
	5114	yss = yid->ys;
	5115
	5116	if(start == -1)
	5117	start = yss->lsearch_nstart + yss->lsearch_nfound;
	5118
	5119	yahoo_search_internal(id, yss->lsearch_type, yss->lsearch_text,
	5120	yss->lsearch_gender, yss->lsearch_agerange,
	5121	yss->lsearch_photo, yss->lsearch_yahoo_only,
	5122	start, yss->lsearch_ntotal);
	5123	}
	5124
	5125	struct send_file_data {
	5126	struct yahoo_packet *pkt;
	5127	yahoo_get_fd_callback callback;
	5128	void *user_data;
	5129	};
	5130
[cfc8d58]	5131	static void _yahoo_send_picture_connected(int id, int fd, int error, void *data)
	5132	{
	5133	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_FT);
	5134	struct send_file_data *sfd = data;
	5135	struct yahoo_packet *pkt = sfd->pkt;
	5136	unsigned char buff[1024];
	5137
	5138	if(fd <= 0) {
	5139	sfd->callback(id, fd, error, sfd->user_data);
	5140	FREE(sfd);
	5141	yahoo_packet_free(pkt);
	5142	inputs = y_list_remove(inputs, yid);
	5143	FREE(yid);
	5144	return;
	5145	}
	5146
	5147	yid->fd = fd;
	5148	yahoo_send_packet(yid, pkt, 8);
	5149	yahoo_packet_free(pkt);
	5150
	5151	snprintf((char *)buff, sizeof(buff), "29");
	5152	buff[2] = 0xc0;
	5153	buff[3] = 0x80;
	5154
	5155	write(yid->fd, buff, 4);
	5156
	5157	/* YAHOO_CALLBACK(ext_yahoo_add_handler)(nyd->fd, YAHOO_INPUT_READ); */
	5158
	5159	sfd->callback(id, fd, error, sfd->user_data);
	5160	FREE(sfd);
	5161	inputs = y_list_remove(inputs, yid);
	5162	/*
	5163	while(yahoo_tcp_readline(buff, sizeof(buff), nyd->fd) > 0) {
	5164	if(!strcmp(buff, ""))
	5165	break;
	5166	}
	5167
	5168	*/
	5169	yahoo_input_close(yid);
	5170	}
	5171
	5172	void yahoo_send_picture(int id, const char *name, unsigned long size,
	5173	yahoo_get_fd_callback callback, void *data)
	5174	{
	5175	struct yahoo_data *yd = find_conn_by_id(id);
	5176	struct yahoo_input_data *yid;
	5177	struct yahoo_server_settings *yss;
	5178	struct yahoo_packet *pkt = NULL;
	5179	char size_str[10];
	5180	char expire_str[10];
	5181	long content_length=0;
	5182	unsigned char buff[1024];
	5183	char url[255];
	5184	struct send_file_data *sfd;
	5185
	5186	if(!yd)
	5187	return;
	5188
	5189	yss = yd->server_settings;
	5190
	5191	yid = y_new0(struct yahoo_input_data, 1);
	5192	yid->yd = yd;
	5193	yid->type = YAHOO_CONNECTION_FT;
	5194
	5195	pkt = yahoo_packet_new(YAHOO_SERVICE_PICTURE_UPLOAD, YAHOO_STATUS_AVAILABLE, yd->session_id);
	5196
	5197	snprintf(size_str, sizeof(size_str), "%ld", size);
	5198	snprintf(expire_str, sizeof(expire_str), "%ld", (long)604800);
	5199
	5200	yahoo_packet_hash(pkt, 0, yd->user);
	5201	yahoo_packet_hash(pkt, 1, yd->user);
	5202	yahoo_packet_hash(pkt, 14, "");
	5203	yahoo_packet_hash(pkt, 27, name);
	5204	yahoo_packet_hash(pkt, 28, size_str);
	5205	yahoo_packet_hash(pkt, 38, expire_str);
	5206
	5207
	5208	content_length = YAHOO_PACKET_HDRLEN + yahoo_packet_length(pkt);
	5209
	5210	snprintf(url, sizeof(url), "http://%s:%d/notifyft",
	5211	yss->filetransfer_host, yss->filetransfer_port);
	5212	snprintf((char *)buff, sizeof(buff), "Y=%s; T=%s",
	5213	yd->cookie_y, yd->cookie_t);
	5214	inputs = y_list_prepend(inputs, yid);
	5215
	5216	sfd = y_new0(struct send_file_data, 1);
	5217	sfd->pkt = pkt;
	5218	sfd->callback = callback;
	5219	sfd->user_data = data;
	5220	yahoo_http_post(yid->yd->client_id, url, (char *)buff, content_length+4+size,
	5221	_yahoo_send_picture_connected, sfd);
	5222	}
	5223
[b7d3cc34]	5224	static void _yahoo_send_file_connected(int id, int fd, int error, void *data)
	5225	{
	5226	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_FT);
	5227	struct send_file_data *sfd = data;
	5228	struct yahoo_packet *pkt = sfd->pkt;
	5229	unsigned char buff[1024];
	5230
	5231	if(fd <= 0) {
	5232	sfd->callback(id, fd, error, sfd->user_data);
	5233	FREE(sfd);
	5234	yahoo_packet_free(pkt);
	5235	inputs = y_list_remove(inputs, yid);
	5236	FREE(yid);
	5237	return;
	5238	}
	5239
	5240	yid->fd = fd;
	5241	yahoo_send_packet(yid, pkt, 8);
	5242	yahoo_packet_free(pkt);
	5243
	5244	snprintf((char *)buff, sizeof(buff), "29");
	5245	buff[2] = 0xc0;
	5246	buff[3] = 0x80;
	5247
	5248	write(yid->fd, buff, 4);
	5249
	5250	/* YAHOO_CALLBACK(ext_yahoo_add_handler)(nyd->fd, YAHOO_INPUT_READ); */
	5251
	5252	sfd->callback(id, fd, error, sfd->user_data);
	5253	FREE(sfd);
	5254	inputs = y_list_remove(inputs, yid);
	5255	/*
	5256	while(yahoo_tcp_readline(buff, sizeof(buff), nyd->fd) > 0) {
	5257	if(!strcmp(buff, ""))
	5258	break;
	5259	}
	5260
	5261	*/
	5262	yahoo_input_close(yid);
	5263	}
	5264
	5265	void yahoo_send_file(int id, const char who, const char msg,
	5266	const char *name, unsigned long size,
	5267	yahoo_get_fd_callback callback, void *data)
	5268	{
	5269	struct yahoo_data *yd = find_conn_by_id(id);
	5270	struct yahoo_input_data *yid;
	5271	struct yahoo_server_settings *yss;
	5272	struct yahoo_packet *pkt = NULL;
	5273	char size_str[10];
	5274	long content_length=0;
	5275	unsigned char buff[1024];
	5276	char url[255];
	5277	struct send_file_data *sfd;
	5278
	5279	if(!yd)
	5280	return;
	5281
	5282	yss = yd->server_settings;
	5283
	5284	yid = y_new0(struct yahoo_input_data, 1);
	5285	yid->yd = yd;
	5286	yid->type = YAHOO_CONNECTION_FT;
	5287
	5288	pkt = yahoo_packet_new(YAHOO_SERVICE_FILETRANSFER, YAHOO_STATUS_AVAILABLE, yd->session_id);
	5289
	5290	snprintf(size_str, sizeof(size_str), "%ld", size);
	5291
	5292	yahoo_packet_hash(pkt, 0, yd->user);
	5293	yahoo_packet_hash(pkt, 5, who);
	5294	yahoo_packet_hash(pkt, 14, msg);
	5295	yahoo_packet_hash(pkt, 27, name);
	5296	yahoo_packet_hash(pkt, 28, size_str);
	5297
	5298	content_length = YAHOO_PACKET_HDRLEN + yahoo_packet_length(pkt);
	5299
	5300	snprintf(url, sizeof(url), "http://%s:%d/notifyft",
	5301	yss->filetransfer_host, yss->filetransfer_port);
	5302	snprintf((char *)buff, sizeof(buff), "Y=%s; T=%s",
	5303	yd->cookie_y, yd->cookie_t);
	5304	inputs = y_list_prepend(inputs, yid);
	5305
	5306	sfd = y_new0(struct send_file_data, 1);
	5307	sfd->pkt = pkt;
	5308	sfd->callback = callback;
	5309	sfd->user_data = data;
	5310	yahoo_http_post(yid->yd->client_id, url, (char *)buff, content_length+4+size,
	5311	_yahoo_send_file_connected, sfd);
	5312	}
	5313
	5314
	5315	enum yahoo_status yahoo_current_status(int id)
	5316	{
	5317	struct yahoo_data *yd = find_conn_by_id(id);
	5318	if(!yd)
	5319	return YAHOO_STATUS_OFFLINE;
	5320	return yd->current_status;
	5321	}
	5322
	5323	const YList * yahoo_get_buddylist(int id)
	5324	{
	5325	struct yahoo_data *yd = find_conn_by_id(id);
	5326	if(!yd)
	5327	return NULL;
	5328	return yd->buddies;
	5329	}
	5330
	5331	const YList * yahoo_get_ignorelist(int id)
	5332	{
	5333	struct yahoo_data *yd = find_conn_by_id(id);
	5334	if(!yd)
	5335	return NULL;
	5336	return yd->ignore;
	5337	}
	5338
	5339	const YList * yahoo_get_identities(int id)
	5340	{
	5341	struct yahoo_data *yd = find_conn_by_id(id);
	5342	if(!yd)
	5343	return NULL;
	5344	return yd->identities;
	5345	}
	5346
	5347	const char * yahoo_get_cookie(int id, const char *which)
	5348	{
	5349	struct yahoo_data *yd = find_conn_by_id(id);
	5350	if(!yd)
	5351	return NULL;
	5352	if(!strncasecmp(which, "y", 1))
	5353	return yd->cookie_y;
	5354	if(!strncasecmp(which, "t", 1))
	5355	return yd->cookie_t;
	5356	if(!strncasecmp(which, "c", 1))
	5357	return yd->cookie_c;
	5358	if(!strncasecmp(which, "login", 5))
	5359	return yd->login_cookie;
	5360	return NULL;
	5361	}
	5362
	5363	void yahoo_get_url_handle(int id, const char *url,
	5364	yahoo_get_url_handle_callback callback, void *data)
	5365	{
	5366	struct yahoo_data *yd = find_conn_by_id(id);
	5367	if(!yd)
	5368	return;
	5369
	5370	yahoo_get_url_fd(id, url, yd, callback, data);
	5371	}
	5372
	5373	const char * yahoo_get_profile_url( void )
	5374	{
	5375	return profile_url;
	5376	}
	5377

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

Download in other formats: