Context Navigation

source: protocols/yahoo/libyahoo2.c @ 17f9522

Last change on this file since 17f9522 was ccba980, checked in by Wilmer van der Gaast <wilmer@…>, at 2009-12-17T00:42:25Z
A few fixes for bugs that caused coredumps on testing.bitlbee.org (or caught my attention in new compiler warnings).
Property mode set to `100644`
File size: 130.2 KB

Line
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
76	#include "sha1.h"
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
90	#include "base64.h"
91	#include "http_client.h"
92
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
106	static int yahoo_send_data(int fd, void *data, int len);
107
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,
172	YAHOO_SERVICE_SKINNAME = 0x15,
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,
196	YAHOO_SERVICE_AUTHBUDDY = 0x6d,
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) */
202	YAHOO_SERVICE_Y7_PING = 0x8A, /* 0 - id and that's it?? */
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,
208	YAHOO_SERVICE_CHATADDINVITE = 0x9d,
209	YAHOO_SERVICE_CHATLOGOUT = 0xa0,
210	YAHOO_SERVICE_CHATPING,
211	YAHOO_SERVICE_COMMENT = 0xa8,
212	YAHOO_SERVICE_STEALTH = 0xb9,
213	YAHOO_SERVICE_PICTURE_CHECKSUM = 0xbd,
214	YAHOO_SERVICE_PICTURE = 0xbe,
215	YAHOO_SERVICE_PICTURE_UPDATE = 0xc1,
216	YAHOO_SERVICE_PICTURE_UPLOAD = 0xc2,
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,
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) */
720	static void to_y64(unsigned char out, const unsigned char in, int inlen)
721	{
722	base64_encode_real(in, inlen, out, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._-");
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;
752	pos += yahoo_put16(data + pos, YAHOO_PROTO_VER);
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
763	if( yid->type == YAHOO_CONNECTION_FT )
764	yahoo_send_data(yid->fd, data, len);
765	else
766	yahoo_add_to_send_queue(yid, data, len);
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);
812
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;
952	char *to = NULL;
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;
961	if (pair->key == 5)
962	to = pair->value;
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")))
980	YAHOO_CALLBACK(ext_yahoo_typing_notify)(yd->client_id, to, from, stat);
981	else if (!strncasecmp(msg, "GAME", strlen("GAME")))
982	YAHOO_CALLBACK(ext_yahoo_game_notify)(yd->client_id, to, from, stat);
983	else if (!strncasecmp(msg, "WEBCAMINVITE", strlen("WEBCAMINVITE")))
984	{
985	if (!strcmp(ind, " ")) {
986	YAHOO_CALLBACK(ext_yahoo_webcam_invite)(yd->client_id, to, from);
987	} else {
988	accept = atoi(ind);
989	/* accept the invitation (-1 = deny 1 = accept) */
990	if (accept < 0)
991	accept = 0;
992	YAHOO_CALLBACK(ext_yahoo_webcam_invite_reply)(yd->client_id, to, from, accept);
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)
1051	YAHOO_CALLBACK(ext_yahoo_got_file)(yd->client_id, to, from, url, expires, msg, filename, filesize);
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)
1125	YAHOO_CALLBACK(ext_yahoo_got_conf_invite)(yd->client_id, id, host, room, msg, members);
1126	else if(msg)
1127	YAHOO_CALLBACK(ext_yahoo_error)(yd->client_id, msg, 0, E_CONFNOTAVAIL);
1128	break;
1129	case YAHOO_SERVICE_CONFADDINVITE:
1130	if(pkt->status == 2)
1131	;
1132	else
1133	YAHOO_CALLBACK(ext_yahoo_got_conf_invite)(yd->client_id, id, host, room, msg, members);
1134	break;
1135	case YAHOO_SERVICE_CONFDECLINE:
1136	if(who)
1137	YAHOO_CALLBACK(ext_yahoo_conf_userdecline)(yd->client_id, id, who, room, msg);
1138	break;
1139	case YAHOO_SERVICE_CONFLOGON:
1140	if(who)
1141	YAHOO_CALLBACK(ext_yahoo_conf_userjoin)(yd->client_id, id, who, room);
1142	break;
1143	case YAHOO_SERVICE_CONFLOGOFF:
1144	if(who)
1145	YAHOO_CALLBACK(ext_yahoo_conf_userleave)(yd->client_id, id, who, room);
1146	break;
1147	case YAHOO_SERVICE_CONFMSG:
1148	if(who)
1149	YAHOO_CALLBACK(ext_yahoo_conf_message)(yd->client_id, id, who, room, msg, utf8);
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;
1157	char *id = NULL;
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
1174	if (pair->key == 1) {
1175	/* My identity */
1176	id = pair->value;
1177	}
1178
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 */
1253	YAHOO_CALLBACK(ext_yahoo_chat_yahoologout)(yid->yd->client_id, id);
1254	return ;
1255	}
1256	if (pkt->service == YAHOO_SERVICE_COMMENT && chaterr) {
1257	YAHOO_CALLBACK(ext_yahoo_chat_yahooerror)(yid->yd->client_id, id);
1258	return;
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) {
1271	YAHOO_CALLBACK(ext_yahoo_chat_join)(yid->yd->client_id, id, room, topic, members, yid->fd);
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;
1280	YAHOO_CALLBACK(ext_yahoo_chat_userjoin)(yid->yd->client_id, id, room, currentmember);
1281	y_list_free_1(members);
1282	members=n;
1283	}
1284	}
1285	break;
1286	case YAHOO_SERVICE_CHATEXIT:
1287	if(who) {
1288	YAHOO_CALLBACK(ext_yahoo_chat_userleave)(yid->yd->client_id, id, room, who);
1289	}
1290	break;
1291	case YAHOO_SERVICE_COMMENT:
1292	if(who) {
1293	YAHOO_CALLBACK(ext_yahoo_chat_message)(yid->yd->client_id, id, who, room, msg, msgtype, utf8);
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) {
1352	YAHOO_CALLBACK(ext_yahoo_got_im)(yd->client_id, message->to, message->from, message->msg, message->tm, pkt->status, message->utf8);
1353	} else if (pkt->status == 0xffffffff) {
1354	YAHOO_CALLBACK(ext_yahoo_error)(yd->client_id, message->msg, 0, E_SYSTEM);
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;
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;
1391
1392	if (pkt->service == YAHOO_SERVICE_LOGOFF && pkt->status == -1) {
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 */
1416	u = y_new0(struct user, 1);
1417	u->name = pair->value;
1418	users = y_list_prepend(users, u);
1419	break;
1420	case 10: /* state */
1421	((struct user*)users->data)->state = strtol(pair->value, NULL, 10);
1422	break;
1423	case 19: /* custom status message */
1424	((struct user*)users->data)->msg = pair->value;
1425	break;
1426	case 47: /* is it an away message or not */
1427	((struct user*)users->data)->away = atoi(pair->value);
1428	break;
1429	case 137: /* seconds idle */
1430	((struct user*)users->data)->idle = atoi(pair->value);
1431	break;
1432	case 11: /* this is the buddy's session id */
1433	((struct user*)users->data)->buddy_session = atoi(pair->value);
1434	break;
1435	case 17: /* in chat? */
1436	((struct user*)users->data)->f17 = atoi(pair->value);
1437	break;
1438	case 13: /* bitmask, bit 0 = pager, bit 1 = chat, bit 2 = game */
1439	((struct user*)users->data)->flags = atoi(pair->value);
1440	break;
1441	case 60: /* SMS -> 1 MOBILE USER */
1442	/* sometimes going offline makes this 2, but invisible never sends it */
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;
1472	case 16: /* Custom error message */
1473	YAHOO_CALLBACK(ext_yahoo_error)(yd->client_id, pair->value, 0, E_CUSTOM);
1474	break;
1475	default:
1476	WARNING(("unknown status key %d:%s", pair->key, pair->value));
1477	break;
1478	}
1479	}
1480
1481	while (users) {
1482	YList *t = users;
1483	struct user *u = users->data;
1484
1485	if (u->name != NULL) {
1486	if (pkt->service == YAHOO_SERVICE_LOGOFF) { /* \|\| u->flags == 0) { Not in YMSG16 */
1487	YAHOO_CALLBACK(ext_yahoo_status_changed)(yd->client_id, u->name, YAHOO_STATUS_OFFLINE, NULL, 1, 0, 0);
1488	} else {
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
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	}
1503	}
1504
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:
1526	g_free(cur_group);
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);
1532	if (cur_group) {
1533	newbud->group = strdup(cur_group);
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	}
1545	}
1546
1547	yd->buddies = y_list_append(yd->buddies, newbud);
1548
1549	break;
1550	}
1551	}
1552
1553	g_free(cur_group);
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
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
1639	if(yd->cookie_y && yd->cookie_t)
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
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
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
1907	sha1_state_t ctx1;
1908	sha1_state_t ctx2;
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
1964	while (*magic_ptr != 0) {
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
2143	sha1_init(&ctx1);
2144	sha1_init(&ctx2);
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
2151	sha1_append(&ctx1, pass_hash_xor1, 64);
2152	if (j >= 3 )
2153	ctx1.Length_Low = 0x1ff;
2154	sha1_append(&ctx1, magic_key_char, 4);
2155	sha1_finish(&ctx1, digest1);
2156
2157	/* The second context gets the password hash XORed
2158	* with 0x5c plus the SHA-1 digest
2159	* of the first context. */
2160
2161	sha1_append(&ctx2, pass_hash_xor2, 64);
2162	sha1_append(&ctx2, digest1, 20);
2163	sha1_finish(&ctx2, digest2);
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
2234	sha1_init(&ctx1);
2235	sha1_init(&ctx2);
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
2242	sha1_append(&ctx1, crypt_hash_xor1, 64);
2243	if (j >= 3 )
2244	ctx1.Length_Low = 0x1ff;
2245	sha1_append(&ctx1, magic_key_char, 4);
2246	sha1_finish(&ctx1, digest1);
2247
2248	/* The second context gets the password hash XORed
2249	* with 0x5c plus the SHA-1 digest
2250	* of the first context. */
2251
2252	sha1_append(&ctx2, crypt_hash_xor2, 64);
2253	sha1_append(&ctx2, digest1, 20);
2254	sha1_finish(&ctx2, digest2);
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
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
2363	static void yahoo_process_auth_0x10(struct yahoo_input_data yid, const char seed, const char *sn)
2364	{
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	}
2372
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	}
2398
2399	static void yahoo_https_auth_token_finish(struct http_request *req)
2400	{
2401	struct yahoo_https_auth_data *had = req->data;
2402	struct yahoo_input_data *yid;
2403	struct yahoo_data *yd;
2404	int st;
2405
2406	if (y_list_find(inputs, had->yid) == NULL)
2407	return;
2408
2409	yid = had->yid;
2410	yd = yid->yd;
2411
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	}
2434
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);
2444
2445	g_free(url);
2446	}
2447
2448	static void yahoo_https_auth_finish(struct http_request *req)
2449	{
2450	struct yahoo_https_auth_data *had = req->data;
2451	struct yahoo_input_data *yid;
2452	struct yahoo_data *yd;
2453	struct yahoo_packet *pack;
2454	char *crumb = NULL;
2455	int st;
2456
2457	if (y_list_find(inputs, had->yid) == NULL)
2458	return;
2459
2460	yid = had->yid;
2461	yd = yid->yd;
2462
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:
2508	g_free(crumb);
2509	g_free(had->token);
2510	g_free(had->chal);
2511	g_free(had);
2512	}
2513
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;
2542	case 2:
2543	yahoo_process_auth_0x10(yid, seed, sn);
2544	break;
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;
2623	int idle = 0;
2624	int mobile = 0;
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);
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
2651	}
2652
2653	if (id)
2654	YAHOO_CALLBACK(ext_yahoo_contact_added)(yd->client_id, id, who, msg);
2655	else if (name)
2656	YAHOO_CALLBACK(ext_yahoo_status_changed)(yd->client_id, name, state, msg, away, idle, mobile);
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
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);
2699
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	}
2704
2705	/* YAHOO_CALLBACK(ext_yahoo_status_changed)(yd->client_id, who, status, NULL, (status==YAHOO_STATUS_AVAILABLE?0:1)); */
2706	}
2707
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
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)
2811	YAHOO_CALLBACK(ext_yahoo_error)(yd->client_id, who, 0, status);
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
2835	NOTICE(("got voice chat invite from %s in %s to identity %s", who, room, me));
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
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
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;
2939	// yahoo_dump_unhandled(pkt);
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));
2961	yahoo_dump_unhandled(pkt);
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:
2973	case YAHOO_SERVICE_Y6_STATUS_UPDATE:
2974	case YAHOO_SERVICE_YMSG15_STATUS:
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;
2988	case YAHOO_SERVICE_REJECTCONTACT:
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;
3029	case YAHOO_SERVICE_CONTACT_YMSG13:
3030	yahoo_process_contact_ymsg13(yid,pkt);
3031	break;
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;
3044	case YAHOO_SERVICE_PING:
3045	yahoo_process_ping(yid, pkt);
3046	break;
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;
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;
3073	case YAHOO_SERVICE_YMSG15_BUDDY_LIST: /* Buddy List */
3074	yahoo_process_buddy_list(yid, pkt);
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));
3482	if(!yid \|\| !yid->txqueues \|\| !find_conn_by_id(id))
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:
3667	if(strcmp(cp, "5") != 0)
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,
3858	yahoo_process_search_connection,
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
3876	if(len == -1 && (errno == EAGAIN\|\|errno == EINTR)) /* we'll try again later */
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) {
3884	YAHOO_CALLBACK(ext_yahoo_error)(yid->yd->client_id, "Connection closed by server", 1, E_CONNECTION);
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
4032	void yahoo_send_im(int id, const char from, const char who, const char *what, int utf8, int picture)
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;
4037	char pic_str[10];
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
4046	snprintf(pic_str, sizeof(pic_str), "%d", picture);
4047
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");
4059	yahoo_packet_hash(pkt, 206, pic_str);
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);
4079	yahoo_packet_hash(pkt, 1, from?from:yd->user);
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;
4094	int old_status;
4095	char s[4];
4096
4097	if(!yid)
4098	return;
4099
4100	yd = yid->yd;
4101
4102	old_status = yd->current_status;
4103
4104	if (msg && strncmp(msg,"Invisible",9)) {
4105	yd->current_status = YAHOO_STATUS_CUSTOM;
4106	} else {
4107	yd->current_status = state;
4108	}
4109
4110	/* Thank you libpurple :) */
4111	if (yd->current_status == YAHOO_STATUS_INVISIBLE) {
4112	pkt = yahoo_packet_new(YAHOO_SERVICE_Y6_VISIBILITY, YAHOO_STATUS_AVAILABLE, 0);
4113	yahoo_packet_hash(pkt, 13, "2");
4114	yahoo_send_packet(yid, pkt, 0);
4115	yahoo_packet_free(pkt);
4116
4117	return;
4118	}
4119
4120	pkt = yahoo_packet_new(YAHOO_SERVICE_Y6_STATUS_UPDATE, yd->current_status, yd->session_id);
4121	snprintf(s, sizeof(s), "%d", yd->current_status);
4122	yahoo_packet_hash(pkt, 10, s);
4123
4124	if (yd->current_status == YAHOO_STATUS_CUSTOM) {
4125	yahoo_packet_hash(pkt, 19, msg);
4126	} else {
4127	yahoo_packet_hash(pkt, 19, "");
4128	}
4129
4130	yahoo_packet_hash(pkt, 47, (away == 2)? "2": (away) ?"1":"0");
4131
4132	yahoo_send_packet(yid, pkt, 0);
4133	yahoo_packet_free(pkt);
4134
4135	if(old_status == YAHOO_STATUS_INVISIBLE) {
4136	pkt = yahoo_packet_new(YAHOO_SERVICE_Y6_VISIBILITY, YAHOO_STATUS_AVAILABLE, 0);
4137	yahoo_packet_hash(pkt, 13, "1");
4138	yahoo_send_packet(yid, pkt, 0);
4139	yahoo_packet_free(pkt);
4140	}
4141	}
4142
4143	void yahoo_logoff(int id)
4144	{
4145	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4146	struct yahoo_data *yd;
4147	struct yahoo_packet *pkt = NULL;
4148
4149	if(!yid)
4150	return;
4151	yd = yid->yd;
4152
4153	LOG(("yahoo_logoff: current status: %d", yd->current_status));
4154
4155	if(yd->current_status != -1 && 0) {
4156	/* Meh. Don't send this. The event handlers are not going to
4157	get to do this so it'll just leak memory. And the TCP
4158	connection reset will hopefully be clear enough. */
4159	pkt = yahoo_packet_new(YAHOO_SERVICE_LOGOFF, YAHOO_STATUS_AVAILABLE, yd->session_id);
4160	yd->current_status = -1;
4161
4162	if (pkt) {
4163	yahoo_send_packet(yid, pkt, 0);
4164	yahoo_packet_free(pkt);
4165	}
4166	}
4167
4168	do {
4169	yahoo_input_close(yid);
4170	} while((yid = find_input_by_id(id)));
4171	}
4172
4173	void yahoo_get_list(int id)
4174	{
4175	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4176	struct yahoo_data *yd;
4177	struct yahoo_packet *pkt = NULL;
4178
4179	if(!yid)
4180	return;
4181	yd = yid->yd;
4182
4183	pkt = yahoo_packet_new(YAHOO_SERVICE_LIST, YAHOO_STATUS_AVAILABLE, yd->session_id);
4184	yahoo_packet_hash(pkt, 1, yd->user);
4185	if (pkt) {
4186	yahoo_send_packet(yid, pkt, 0);
4187	yahoo_packet_free(pkt);
4188	}
4189	}
4190
4191	static void _yahoo_http_connected(int id, int fd, int error, void *data)
4192	{
4193	struct yahoo_input_data *yid = data;
4194	if(fd <= 0) {
4195	inputs = y_list_remove(inputs, yid);
4196	FREE(yid);
4197	return;
4198	}
4199
4200	yid->fd = fd;
4201	yid->read_tag=YAHOO_CALLBACK(ext_yahoo_add_handler)(yid->yd->client_id, fd, YAHOO_INPUT_READ, yid);
4202	}
4203
4204	void yahoo_get_yab(int id)
4205	{
4206	struct yahoo_data *yd = find_conn_by_id(id);
4207	struct yahoo_input_data *yid;
4208	char url[1024];
4209	char buff[1024];
4210
4211	if(!yd)
4212	return;
4213
4214	yid = y_new0(struct yahoo_input_data, 1);
4215	yid->yd = yd;
4216	yid->type = YAHOO_CONNECTION_YAB;
4217
4218	snprintf(url, 1024, "http://insider.msg.yahoo.com/ycontent/?ab2=0");
4219
4220	snprintf(buff, sizeof(buff), "Y=%s; T=%s",
4221	yd->cookie_y, yd->cookie_t);
4222
4223	inputs = y_list_prepend(inputs, yid);
4224
4225	yahoo_http_get(yid->yd->client_id, url, buff,
4226	_yahoo_http_connected, yid);
4227	}
4228
4229	void yahoo_set_yab(int id, struct yab * yab)
4230	{
4231	struct yahoo_data *yd = find_conn_by_id(id);
4232	struct yahoo_input_data *yid;
4233	char url[1024];
4234	char buff[1024];
4235	char *temp;
4236	int size = sizeof(url)-1;
4237
4238	if(!yd)
4239	return;
4240
4241	yid = y_new0(struct yahoo_input_data, 1);
4242	yid->type = YAHOO_CONNECTION_YAB;
4243	yid->yd = yd;
4244
4245	strncpy(url, "http://insider.msg.yahoo.com/ycontent/?addab2=0", size);
4246
4247	if(yab->dbid) {
4248	/* change existing yab */
4249	char tmp[32];
4250	strncat(url, "&ee=1&ow=1&id=", size - strlen(url));
4251	snprintf(tmp, sizeof(tmp), "%d", yab->dbid);
4252	strncat(url, tmp, size - strlen(url));
4253	}
4254
4255	if(yab->fname) {
4256	strncat(url, "&fn=", size - strlen(url));
4257	temp = yahoo_urlencode(yab->fname);
4258	strncat(url, temp, size - strlen(url));
4259	free(temp);
4260	}
4261	if(yab->lname) {
4262	strncat(url, "&ln=", size - strlen(url));
4263	temp = yahoo_urlencode(yab->lname);
4264	strncat(url, temp, size - strlen(url));
4265	free(temp);
4266	}
4267	strncat(url, "&yid=", size - strlen(url));
4268	temp = yahoo_urlencode(yab->id);
4269	strncat(url, temp, size - strlen(url));
4270	free(temp);
4271	if(yab->nname) {
4272	strncat(url, "&nn=", size - strlen(url));
4273	temp = yahoo_urlencode(yab->nname);
4274	strncat(url, temp, size - strlen(url));
4275	free(temp);
4276	}
4277	if(yab->email) {
4278	strncat(url, "&e=", size - strlen(url));
4279	temp = yahoo_urlencode(yab->email);
4280	strncat(url, temp, size - strlen(url));
4281	free(temp);
4282	}
4283	if(yab->hphone) {
4284	strncat(url, "&hp=", size - strlen(url));
4285	temp = yahoo_urlencode(yab->hphone);
4286	strncat(url, temp, size - strlen(url));
4287	free(temp);
4288	}
4289	if(yab->wphone) {
4290	strncat(url, "&wp=", size - strlen(url));
4291	temp = yahoo_urlencode(yab->wphone);
4292	strncat(url, temp, size - strlen(url));
4293	free(temp);
4294	}
4295	if(yab->mphone) {
4296	strncat(url, "&mp=", size - strlen(url));
4297	temp = yahoo_urlencode(yab->mphone);
4298	strncat(url, temp, size - strlen(url));
4299	free(temp);
4300	}
4301	strncat(url, "&pp=0", size - strlen(url));
4302
4303	snprintf(buff, sizeof(buff), "Y=%s; T=%s",
4304	yd->cookie_y, yd->cookie_t);
4305
4306	inputs = y_list_prepend(inputs, yid);
4307
4308	yahoo_http_get(yid->yd->client_id, url, buff,
4309	_yahoo_http_connected, yid);
4310	}
4311
4312	void yahoo_set_identity_status(int id, const char * identity, int active)
4313	{
4314	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4315	struct yahoo_data *yd;
4316	struct yahoo_packet *pkt = NULL;
4317
4318	if(!yid)
4319	return;
4320	yd = yid->yd;
4321
4322	pkt = yahoo_packet_new(active?YAHOO_SERVICE_IDACT:YAHOO_SERVICE_IDDEACT,
4323	YAHOO_STATUS_AVAILABLE, yd->session_id);
4324	yahoo_packet_hash(pkt, 3, identity);
4325	if (pkt) {
4326	yahoo_send_packet(yid, pkt, 0);
4327	yahoo_packet_free(pkt);
4328	}
4329	}
4330
4331	void yahoo_refresh(int id)
4332	{
4333	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4334	struct yahoo_data *yd;
4335	struct yahoo_packet *pkt = NULL;
4336
4337	if(!yid)
4338	return;
4339	yd = yid->yd;
4340
4341	pkt = yahoo_packet_new(YAHOO_SERVICE_USERSTAT, YAHOO_STATUS_AVAILABLE, yd->session_id);
4342	if (pkt) {
4343	yahoo_send_packet(yid, pkt, 0);
4344	yahoo_packet_free(pkt);
4345	}
4346	}
4347
4348	void yahoo_keepalive(int id)
4349	{
4350	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4351	struct yahoo_data *yd;
4352	struct yahoo_packet *pkt=NULL;
4353	if(!yid)
4354	return;
4355	yd = yid->yd;
4356
4357	pkt = yahoo_packet_new(YAHOO_SERVICE_PING, YAHOO_STATUS_AVAILABLE, yd->session_id);
4358	yahoo_send_packet(yid, pkt, 0);
4359	yahoo_packet_free(pkt);
4360	}
4361
4362	void yahoo_chat_keepalive (int id)
4363	{
4364	struct yahoo_input_data *yid = find_input_by_id_and_type (id, YAHOO_CONNECTION_PAGER);
4365	struct yahoo_data *yd;
4366	struct yahoo_packet *pkt = NULL;
4367
4368	if (!yid)
4369	return;
4370
4371	yd = yid->yd;
4372
4373	pkt = yahoo_packet_new (YAHOO_SERVICE_CHATPING, YAHOO_STATUS_AVAILABLE, yd->session_id);
4374	yahoo_send_packet (yid, pkt, 0);
4375	yahoo_packet_free (pkt);
4376	}
4377
4378	void yahoo_add_buddy(int id, const char who, const char group, const char *msg)
4379	{
4380	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4381	struct yahoo_data *yd;
4382	struct yahoo_packet *pkt;
4383
4384	if(!yid)
4385	return;
4386	yd = yid->yd;
4387
4388	if (!yd->logged_in)
4389	return;
4390
4391	pkt = yahoo_packet_new(YAHOO_SERVICE_ADDBUDDY, YPACKET_STATUS_DEFAULT, yd->session_id);
4392
4393	if (msg != NULL) /* add message/request "it's me add me" */
4394	yahoo_packet_hash(pkt, 14, msg);
4395	else
4396	yahoo_packet_hash(pkt,14,"");
4397
4398	yahoo_packet_hash(pkt, 65, group);
4399	yahoo_packet_hash(pkt, 97, "1");
4400	yahoo_packet_hash(pkt, 1, yd->user);
4401	yahoo_packet_hash(pkt, 302, "319");
4402	yahoo_packet_hash(pkt, 300, "319");
4403	yahoo_packet_hash(pkt, 7, who);
4404	yahoo_packet_hash(pkt, 334, "0");
4405	yahoo_packet_hash(pkt, 301, "319");
4406	yahoo_packet_hash(pkt, 303, "319");
4407
4408
4409	yahoo_send_packet(yid, pkt, 0);
4410	yahoo_packet_free(pkt);
4411	}
4412
4413	void yahoo_remove_buddy(int id, const char who, const char group)
4414	{
4415	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4416	struct yahoo_data *yd;
4417	struct yahoo_packet *pkt = NULL;
4418
4419	if(!yid)
4420	return;
4421	yd = yid->yd;
4422
4423	pkt = yahoo_packet_new(YAHOO_SERVICE_REMBUDDY, YAHOO_STATUS_AVAILABLE, yd->session_id);
4424
4425	yahoo_packet_hash(pkt, 1, yd->user);
4426	yahoo_packet_hash(pkt, 7, who);
4427	yahoo_packet_hash(pkt, 65, group);
4428	yahoo_send_packet(yid, pkt, 0);
4429	yahoo_packet_free(pkt);
4430	}
4431
4432	void yahoo_accept_buddy_ymsg13(int id,const char* me,const char* who){
4433	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4434	struct yahoo_data *yd;
4435
4436	if(!yid)
4437	return;
4438	yd = yid->yd;
4439
4440	struct yahoo_packet* pkt=NULL;
4441	pkt= yahoo_packet_new(YAHOO_SERVICE_CONTACT_YMSG13,YAHOO_STATUS_AVAILABLE,0);
4442
4443	yahoo_packet_hash(pkt,1,me ?: yd->user);
4444	yahoo_packet_hash(pkt,5,who);
4445	yahoo_packet_hash(pkt,13,"1");
4446	yahoo_packet_hash(pkt,334,"0");
4447	yahoo_send_packet(yid, pkt, 0);
4448	yahoo_packet_free(pkt);
4449	}
4450
4451	void yahoo_reject_buddy_ymsg13(int id,const char* me,const char* who,const char* msg){
4452	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4453	struct yahoo_data *yd;
4454
4455	if(!yid)
4456	return;
4457	yd = yid->yd;
4458
4459	struct yahoo_packet* pkt=NULL;
4460	pkt= yahoo_packet_new(YAHOO_SERVICE_CONTACT_YMSG13,YAHOO_STATUS_AVAILABLE,0);
4461
4462	yahoo_packet_hash(pkt,1,me ?: yd->user);
4463	yahoo_packet_hash(pkt,5,who);
4464	// yahoo_packet_hash(pkt,241,YAHOO_PROTO_VER);
4465	yahoo_packet_hash(pkt,13,"2");
4466	yahoo_packet_hash(pkt,334,"0");
4467	yahoo_packet_hash(pkt,97,"1");
4468	yahoo_packet_hash(pkt,14,msg?:"");
4469
4470	yahoo_send_packet(yid, pkt, 0);
4471	yahoo_packet_free(pkt);
4472
4473	}
4474
4475	void yahoo_reject_buddy(int id, const char who, const char msg)
4476	{
4477	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4478	struct yahoo_data *yd;
4479	struct yahoo_packet *pkt;
4480
4481	if(!yid)
4482	return;
4483	yd = yid->yd;
4484
4485	if (!yd->logged_in)
4486	return;
4487
4488	pkt = yahoo_packet_new(YAHOO_SERVICE_REJECTCONTACT, YAHOO_STATUS_AVAILABLE, yd->session_id);
4489	yahoo_packet_hash(pkt, 1, yd->user);
4490	yahoo_packet_hash(pkt, 7, who);
4491	yahoo_packet_hash(pkt, 14, msg);
4492	yahoo_send_packet(yid, pkt, 0);
4493	yahoo_packet_free(pkt);
4494	}
4495
4496	void yahoo_ignore_buddy(int id, const char *who, int unignore)
4497	{
4498	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4499	struct yahoo_data *yd;
4500	struct yahoo_packet *pkt;
4501
4502	if(!yid)
4503	return;
4504	yd = yid->yd;
4505
4506	if (!yd->logged_in)
4507	return;
4508
4509	pkt = yahoo_packet_new(YAHOO_SERVICE_IGNORECONTACT, YAHOO_STATUS_AVAILABLE, yd->session_id);
4510	yahoo_packet_hash(pkt, 1, yd->user);
4511	yahoo_packet_hash(pkt, 7, who);
4512	yahoo_packet_hash(pkt, 13, unignore?"2":"1");
4513	yahoo_send_packet(yid, pkt, 0);
4514	yahoo_packet_free(pkt);
4515	}
4516
4517	void yahoo_stealth_buddy(int id, const char *who, int unstealth)
4518	{
4519	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4520	struct yahoo_data *yd;
4521	struct yahoo_packet *pkt;
4522
4523	if(!yid)
4524	return;
4525	yd = yid->yd;
4526
4527	if (!yd->logged_in)
4528	return;
4529
4530	pkt = yahoo_packet_new(YAHOO_SERVICE_STEALTH, YAHOO_STATUS_AVAILABLE, yd->session_id);
4531	yahoo_packet_hash(pkt, 1, yd->user);
4532	yahoo_packet_hash(pkt, 7, who);
4533	yahoo_packet_hash(pkt, 31, unstealth?"2":"1");
4534	yahoo_packet_hash(pkt, 13, "2");
4535	yahoo_send_packet(yid, pkt, 0);
4536	yahoo_packet_free(pkt);
4537	}
4538
4539	void yahoo_change_buddy_group(int id, const char who, const char old_group, const char *new_group)
4540	{
4541	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4542	struct yahoo_data *yd;
4543	struct yahoo_packet *pkt = NULL;
4544
4545	if(!yid)
4546	return;
4547	yd = yid->yd;
4548
4549	pkt = yahoo_packet_new(YAHOO_SERVICE_ADDBUDDY, YAHOO_STATUS_AVAILABLE, yd->session_id);
4550	yahoo_packet_hash(pkt, 1, yd->user);
4551	yahoo_packet_hash(pkt, 7, who);
4552	yahoo_packet_hash(pkt, 65, new_group);
4553	yahoo_packet_hash(pkt, 14, " ");
4554
4555	yahoo_send_packet(yid, pkt, 0);
4556	yahoo_packet_free(pkt);
4557
4558	pkt = yahoo_packet_new(YAHOO_SERVICE_REMBUDDY, YAHOO_STATUS_AVAILABLE, yd->session_id);
4559	yahoo_packet_hash(pkt, 1, yd->user);
4560	yahoo_packet_hash(pkt, 7, who);
4561	yahoo_packet_hash(pkt, 65, old_group);
4562	yahoo_send_packet(yid, pkt, 0);
4563	yahoo_packet_free(pkt);
4564	}
4565
4566	void yahoo_group_rename(int id, const char old_group, const char new_group)
4567	{
4568	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4569	struct yahoo_data *yd;
4570	struct yahoo_packet *pkt = NULL;
4571
4572	if(!yid)
4573	return;
4574	yd = yid->yd;
4575
4576	pkt = yahoo_packet_new(YAHOO_SERVICE_GROUPRENAME, YAHOO_STATUS_AVAILABLE, yd->session_id);
4577	yahoo_packet_hash(pkt, 1, yd->user);
4578	yahoo_packet_hash(pkt, 65, old_group);
4579	yahoo_packet_hash(pkt, 67, new_group);
4580
4581	yahoo_send_packet(yid, pkt, 0);
4582	yahoo_packet_free(pkt);
4583	}
4584
4585	void yahoo_conference_addinvite(int id, const char * from, const char who, const char room, const YList * members, const char *msg)
4586	{
4587	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4588	struct yahoo_data *yd;
4589	struct yahoo_packet *pkt;
4590
4591	if(!yid)
4592	return;
4593	yd = yid->yd;
4594
4595	pkt = yahoo_packet_new(YAHOO_SERVICE_CONFADDINVITE, YAHOO_STATUS_AVAILABLE, yd->session_id);
4596
4597	yahoo_packet_hash(pkt, 1, (from?from:yd->user));
4598	yahoo_packet_hash(pkt, 51, who);
4599	yahoo_packet_hash(pkt, 57, room);
4600	yahoo_packet_hash(pkt, 58, msg);
4601	yahoo_packet_hash(pkt, 13, "0");
4602	for(; members; members = members->next) {
4603	yahoo_packet_hash(pkt, 52, (char *)members->data);
4604	yahoo_packet_hash(pkt, 53, (char *)members->data);
4605	}
4606	/* 52, 53 -> other members? */
4607
4608	yahoo_send_packet(yid, pkt, 0);
4609
4610	yahoo_packet_free(pkt);
4611	}
4612
4613	void yahoo_conference_invite(int id, const char * from, YList who, const char room, const char *msg)
4614	{
4615	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4616	struct yahoo_data *yd;
4617	struct yahoo_packet *pkt;
4618
4619	if(!yid)
4620	return;
4621	yd = yid->yd;
4622
4623	pkt = yahoo_packet_new(YAHOO_SERVICE_CONFINVITE, YAHOO_STATUS_AVAILABLE, yd->session_id);
4624
4625	yahoo_packet_hash(pkt, 1, (from?from:yd->user));
4626	yahoo_packet_hash(pkt, 50, yd->user);
4627	for(; who; who = who->next) {
4628	yahoo_packet_hash(pkt, 52, (char *)who->data);
4629	}
4630	yahoo_packet_hash(pkt, 57, room);
4631	yahoo_packet_hash(pkt, 58, msg);
4632	yahoo_packet_hash(pkt, 13, "0");
4633
4634	yahoo_send_packet(yid, pkt, 0);
4635
4636	yahoo_packet_free(pkt);
4637	}
4638
4639	void yahoo_conference_logon(int id, const char from, YList who, const char *room)
4640	{
4641	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4642	struct yahoo_data *yd;
4643	struct yahoo_packet *pkt;
4644
4645	if(!yid)
4646	return;
4647	yd = yid->yd;
4648
4649	pkt = yahoo_packet_new(YAHOO_SERVICE_CONFLOGON, YAHOO_STATUS_AVAILABLE, yd->session_id);
4650
4651	yahoo_packet_hash(pkt, 1, (from?from:yd->user));
4652	for(; who; who = who->next) {
4653	yahoo_packet_hash(pkt, 3, (char *)who->data);
4654	}
4655	yahoo_packet_hash(pkt, 57, room);
4656
4657	yahoo_send_packet(yid, pkt, 0);
4658
4659	yahoo_packet_free(pkt);
4660	}
4661
4662	void yahoo_conference_decline(int id, const char * from, YList who, const char room, const char *msg)
4663	{
4664	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4665	struct yahoo_data *yd;
4666	struct yahoo_packet *pkt;
4667
4668	if(!yid)
4669	return;
4670	yd = yid->yd;
4671
4672	pkt = yahoo_packet_new(YAHOO_SERVICE_CONFDECLINE, YAHOO_STATUS_AVAILABLE, yd->session_id);
4673
4674	yahoo_packet_hash(pkt, 1, (from?from:yd->user));
4675	for(; who; who = who->next) {
4676	yahoo_packet_hash(pkt, 3, (char *)who->data);
4677	}
4678	yahoo_packet_hash(pkt, 57, room);
4679	yahoo_packet_hash(pkt, 14, msg);
4680
4681	yahoo_send_packet(yid, pkt, 0);
4682
4683	yahoo_packet_free(pkt);
4684	}
4685
4686	void yahoo_conference_logoff(int id, const char * from, YList who, const char room)
4687	{
4688	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4689	struct yahoo_data *yd;
4690	struct yahoo_packet *pkt;
4691
4692	if(!yid)
4693	return;
4694	yd = yid->yd;
4695
4696	pkt = yahoo_packet_new(YAHOO_SERVICE_CONFLOGOFF, YAHOO_STATUS_AVAILABLE, yd->session_id);
4697
4698	yahoo_packet_hash(pkt, 1, (from?from:yd->user));
4699	for(; who; who = who->next) {
4700	yahoo_packet_hash(pkt, 3, (char *)who->data);
4701	}
4702	yahoo_packet_hash(pkt, 57, room);
4703
4704	yahoo_send_packet(yid, pkt, 0);
4705
4706	yahoo_packet_free(pkt);
4707	}
4708
4709	void yahoo_conference_message(int id, const char * from, YList who, const char room, const char *msg, int utf8)
4710	{
4711	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4712	struct yahoo_data *yd;
4713	struct yahoo_packet *pkt;
4714
4715	if(!yid)
4716	return;
4717	yd = yid->yd;
4718
4719	pkt = yahoo_packet_new(YAHOO_SERVICE_CONFMSG, YAHOO_STATUS_AVAILABLE, yd->session_id);
4720
4721	yahoo_packet_hash(pkt, 1, (from?from:yd->user));
4722	for(; who; who = who->next) {
4723	yahoo_packet_hash(pkt, 53, (char *)who->data);
4724	}
4725	yahoo_packet_hash(pkt, 57, room);
4726	yahoo_packet_hash(pkt, 14, msg);
4727
4728	if(utf8)
4729	yahoo_packet_hash(pkt, 97, "1");
4730
4731	yahoo_send_packet(yid, pkt, 0);
4732
4733	yahoo_packet_free(pkt);
4734	}
4735
4736	void yahoo_get_chatrooms(int id, int chatroomid)
4737	{
4738	struct yahoo_data *yd = find_conn_by_id(id);
4739	struct yahoo_input_data *yid;
4740	char url[1024];
4741	char buff[1024];
4742
4743	if(!yd)
4744	return;
4745
4746	yid = y_new0(struct yahoo_input_data, 1);
4747	yid->yd = yd;
4748	yid->type = YAHOO_CONNECTION_CHATCAT;
4749
4750	if (chatroomid == 0) {
4751	snprintf(url, 1024, "http://insider.msg.yahoo.com/ycontent/?chatcat=0");
4752	} else {
4753	snprintf(url, 1024, "http://insider.msg.yahoo.com/ycontent/?chatroom_%d=0",chatroomid);
4754	}
4755
4756	snprintf(buff, sizeof(buff), "Y=%s; T=%s", yd->cookie_y, yd->cookie_t);
4757
4758	inputs = y_list_prepend(inputs, yid);
4759
4760	yahoo_http_get(yid->yd->client_id, url, buff, _yahoo_http_connected, yid);
4761	}
4762
4763	void yahoo_chat_logon(int id, const char from, const char room, const char *roomid)
4764	{
4765	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4766	struct yahoo_data *yd;
4767	struct yahoo_packet *pkt;
4768
4769	if(!yid)
4770	return;
4771
4772	yd = yid->yd;
4773
4774	pkt = yahoo_packet_new(YAHOO_SERVICE_CHATONLINE, YAHOO_STATUS_AVAILABLE, yd->session_id);
4775
4776	yahoo_packet_hash(pkt, 1, (from?from:yd->user));
4777	yahoo_packet_hash(pkt, 109, yd->user);
4778	yahoo_packet_hash(pkt, 6, "abcde");
4779
4780	yahoo_send_packet(yid, pkt, 0);
4781
4782	yahoo_packet_free(pkt);
4783
4784	pkt = yahoo_packet_new(YAHOO_SERVICE_CHATJOIN, YAHOO_STATUS_AVAILABLE, yd->session_id);
4785
4786	yahoo_packet_hash(pkt, 1, (from?from:yd->user));
4787	yahoo_packet_hash(pkt, 104, room);
4788	yahoo_packet_hash(pkt, 129, roomid);
4789	yahoo_packet_hash(pkt, 62, "2"); /* ??? */
4790
4791	yahoo_send_packet(yid, pkt, 0);
4792
4793	yahoo_packet_free(pkt);
4794	}
4795
4796
4797	void yahoo_chat_message(int id, const char from, const char room, const char *msg, const int msgtype, const int utf8)
4798	{
4799	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4800	struct yahoo_data *yd;
4801	struct yahoo_packet *pkt;
4802	char buf[2];
4803
4804	if(!yid)
4805	return;
4806
4807	yd = yid->yd;
4808
4809	pkt = yahoo_packet_new(YAHOO_SERVICE_COMMENT, YAHOO_STATUS_AVAILABLE, yd->session_id);
4810
4811	yahoo_packet_hash(pkt, 1, (from?from:yd->user));
4812	yahoo_packet_hash(pkt, 104, room);
4813	yahoo_packet_hash(pkt, 117, msg);
4814
4815	snprintf(buf, sizeof(buf), "%d", msgtype);
4816	yahoo_packet_hash(pkt, 124, buf);
4817
4818	if(utf8)
4819	yahoo_packet_hash(pkt, 97, "1");
4820
4821	yahoo_send_packet(yid, pkt, 0);
4822
4823	yahoo_packet_free(pkt);
4824	}
4825
4826
4827	void yahoo_chat_logoff(int id, const char *from)
4828	{
4829	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4830	struct yahoo_data *yd;
4831	struct yahoo_packet *pkt;
4832
4833	if(!yid)
4834	return;
4835
4836	yd = yid->yd;
4837
4838	pkt = yahoo_packet_new(YAHOO_SERVICE_CHATLOGOUT, YAHOO_STATUS_AVAILABLE, yd->session_id);
4839
4840	yahoo_packet_hash(pkt, 1, (from?from:yd->user));
4841
4842	yahoo_send_packet(yid, pkt, 0);
4843
4844	yahoo_packet_free(pkt);
4845	}
4846
4847	void yahoo_buddyicon_request(int id, const char *who)
4848	{
4849	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4850	struct yahoo_data *yd;
4851	struct yahoo_packet *pkt;
4852
4853	if( !yid )
4854	return;
4855
4856	yd = yid->yd;
4857
4858	pkt = yahoo_packet_new(YAHOO_SERVICE_PICTURE, YAHOO_STATUS_AVAILABLE, 0);
4859	yahoo_packet_hash(pkt, 4, yd->user);
4860	yahoo_packet_hash(pkt, 5, who);
4861	yahoo_packet_hash(pkt, 13, "1");
4862	yahoo_send_packet(yid, pkt, 0);
4863
4864	yahoo_packet_free(pkt);
4865	}
4866
4867	void yahoo_send_picture_info(int id, const char who, const char url, int checksum)
4868	{
4869	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4870	struct yahoo_data *yd;
4871	struct yahoo_packet *pkt;
4872	char checksum_str[10];
4873
4874	if( !yid )
4875	return;
4876
4877	yd = yid->yd;
4878
4879	snprintf(checksum_str, sizeof(checksum_str), "%d", checksum);
4880
4881	pkt = yahoo_packet_new(YAHOO_SERVICE_PICTURE, YAHOO_STATUS_AVAILABLE, 0);
4882	yahoo_packet_hash(pkt, 1, yd->user);
4883	yahoo_packet_hash(pkt, 4, yd->user);
4884	yahoo_packet_hash(pkt, 5, who);
4885	yahoo_packet_hash(pkt, 13, "2");
4886	yahoo_packet_hash(pkt, 20, url);
4887	yahoo_packet_hash(pkt, 192, checksum_str);
4888	yahoo_send_packet(yid, pkt, 0);
4889
4890	yahoo_packet_free(pkt);
4891	}
4892
4893	void yahoo_send_picture_update(int id, const char *who, int type)
4894	{
4895	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4896	struct yahoo_data *yd;
4897	struct yahoo_packet *pkt;
4898	char type_str[10];
4899
4900	if( !yid )
4901	return;
4902
4903	yd = yid->yd;
4904
4905	snprintf(type_str, sizeof(type_str), "%d", type);
4906
4907	pkt = yahoo_packet_new(YAHOO_SERVICE_PICTURE_UPDATE, YAHOO_STATUS_AVAILABLE, 0);
4908	yahoo_packet_hash(pkt, 1, yd->user);
4909	yahoo_packet_hash(pkt, 5, who);
4910	yahoo_packet_hash(pkt, 206, type_str);
4911	yahoo_send_packet(yid, pkt, 0);
4912
4913	yahoo_packet_free(pkt);
4914	}
4915
4916	void yahoo_send_picture_checksum(int id, const char *who, int checksum)
4917	{
4918	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4919	struct yahoo_data *yd;
4920	struct yahoo_packet *pkt;
4921	char checksum_str[10];
4922
4923	if( !yid )
4924	return;
4925
4926	yd = yid->yd;
4927
4928	snprintf(checksum_str, sizeof(checksum_str), "%d", checksum);
4929
4930	pkt = yahoo_packet_new(YAHOO_SERVICE_PICTURE_CHECKSUM, YAHOO_STATUS_AVAILABLE, 0);
4931	yahoo_packet_hash(pkt, 1, yd->user);
4932	if( who != 0 )
4933	yahoo_packet_hash(pkt, 5, who);
4934	yahoo_packet_hash(pkt, 192, checksum_str);
4935	yahoo_packet_hash(pkt, 212, "1");
4936	yahoo_send_packet(yid, pkt, 0);
4937
4938	yahoo_packet_free(pkt);
4939	}
4940
4941	void yahoo_webcam_close_feed(int id, const char *who)
4942	{
4943	struct yahoo_input_data *yid = find_input_by_id_and_webcam_user(id, who);
4944
4945	if(yid)
4946	yahoo_input_close(yid);
4947	}
4948
4949	void yahoo_webcam_get_feed(int id, const char *who)
4950	{
4951	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
4952	struct yahoo_data *yd;
4953	struct yahoo_packet *pkt;
4954
4955	if(!yid)
4956	return;
4957
4958	/*
4959	* add the user to the queue. this is a dirty hack, since
4960	* the yahoo server doesn't tell us who's key it's returning,
4961	* we have to just hope that it sends back keys in the same
4962	* order that we request them.
4963	* The queue is popped in yahoo_process_webcam_key
4964	*/
4965	webcam_queue = y_list_append(webcam_queue, who?strdup(who):NULL);
4966
4967	yd = yid->yd;
4968
4969	pkt = yahoo_packet_new(YAHOO_SERVICE_WEBCAM, YAHOO_STATUS_AVAILABLE, yd->session_id);
4970
4971	yahoo_packet_hash(pkt, 1, yd->user);
4972	if (who != NULL)
4973	yahoo_packet_hash(pkt, 5, who);
4974	yahoo_send_packet(yid, pkt, 0);
4975
4976	yahoo_packet_free(pkt);
4977	}
4978
4979	void yahoo_webcam_send_image(int id, unsigned char *image, unsigned int length, unsigned int timestamp)
4980	{
4981	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_WEBCAM);
4982	unsigned char *packet;
4983	unsigned char header_len = 13;
4984	unsigned int pos = 0;
4985
4986	if (!yid)
4987	return;
4988
4989	packet = y_new0(unsigned char, header_len);
4990
4991	packet[pos++] = header_len;
4992	packet[pos++] = 0;
4993	packet[pos++] = 5; /* version byte?? */
4994	packet[pos++] = 0;
4995	pos += yahoo_put32(packet + pos, length);
4996	packet[pos++] = 2; /* packet type, image */
4997	pos += yahoo_put32(packet + pos, timestamp);
4998	yahoo_add_to_send_queue(yid, packet, header_len);
4999	FREE(packet);
5000
5001	if (length)
5002	yahoo_add_to_send_queue(yid, image, length);
5003	}
5004
5005	void yahoo_webcam_accept_viewer(int id, const char* who, int accept)
5006	{
5007	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_WEBCAM);
5008	char *packet = NULL;
5009	char *data = NULL;
5010	unsigned char header_len = 13;
5011	unsigned int pos = 0;
5012	unsigned int len = 0;
5013
5014	if (!yid)
5015	return;
5016
5017	data = strdup("u=");
5018	data = y_string_append(data, (char*)who);
5019	data = y_string_append(data, "\r\n");
5020	len = strlen(data);
5021
5022	packet = y_new0(char, header_len + len);
5023	packet[pos++] = header_len;
5024	packet[pos++] = 0;
5025	packet[pos++] = 5; /* version byte?? */
5026	packet[pos++] = 0;
5027	pos += yahoo_put32(packet + pos, len);
5028	packet[pos++] = 0; /* packet type */
5029	pos += yahoo_put32(packet + pos, accept);
5030	memcpy(packet + pos, data, len);
5031	FREE(data);
5032	yahoo_add_to_send_queue(yid, packet, header_len + len);
5033	FREE(packet);
5034	}
5035
5036	void yahoo_webcam_invite(int id, const char *who)
5037	{
5038	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
5039	struct yahoo_packet *pkt;
5040
5041	if(!yid)
5042	return;
5043
5044	pkt = yahoo_packet_new(YAHOO_SERVICE_NOTIFY, YAHOO_STATUS_NOTIFY, yid->yd->session_id);
5045
5046	yahoo_packet_hash(pkt, 49, "WEBCAMINVITE");
5047	yahoo_packet_hash(pkt, 14, " ");
5048	yahoo_packet_hash(pkt, 13, "0");
5049	yahoo_packet_hash(pkt, 1, yid->yd->user);
5050	yahoo_packet_hash(pkt, 5, who);
5051	yahoo_send_packet(yid, pkt, 0);
5052
5053	yahoo_packet_free(pkt);
5054	}
5055
5056	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)
5057	{
5058	struct yahoo_data *yd = find_conn_by_id(id);
5059	struct yahoo_input_data *yid;
5060	char url[1024];
5061	char buff[1024];
5062	char ctext, p;
5063
5064	if(!yd)
5065	return;
5066
5067	yid = y_new0(struct yahoo_input_data, 1);
5068	yid->yd = yd;
5069	yid->type = YAHOO_CONNECTION_SEARCH;
5070
5071	/*
5072	age range
5073	.ar=1 - 13-18, 2 - 18-25, 3 - 25-35, 4 - 35-50, 5 - 50-70, 6 - 70+
5074	*/
5075
5076	snprintf(buff, sizeof(buff), "&.sq=%%20&.tt=%d&.ss=%d", total, startpos);
5077
5078	ctext = strdup(text);
5079	while((p = strchr(ctext, ' ')))
5080	*p = '+';
5081
5082	snprintf(url, 1024, "http://members.yahoo.com/interests?.oc=m&.kw=%s&.sb=%d&.g=%d&.ar=0%s%s%s",
5083	ctext, t, g, photo ? "&.p=y" : "", yahoo_only ? "&.pg=y" : "",
5084	startpos ? buff : "");
5085
5086	FREE(ctext);
5087
5088	snprintf(buff, sizeof(buff), "Y=%s; T=%s", yd->cookie_y, yd->cookie_t);
5089
5090	inputs = y_list_prepend(inputs, yid);
5091	yahoo_http_get(yid->yd->client_id, url, buff, _yahoo_http_connected, yid);
5092	}
5093
5094	void yahoo_search(int id, enum yahoo_search_type t, const char *text, enum yahoo_search_gender g, enum yahoo_search_agerange ar,
5095	int photo, int yahoo_only)
5096	{
5097	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
5098	struct yahoo_search_state *yss;
5099
5100	if(!yid)
5101	return;
5102
5103	if(!yid->ys)
5104	yid->ys = y_new0(struct yahoo_search_state, 1);
5105
5106	yss = yid->ys;
5107
5108	FREE(yss->lsearch_text);
5109	yss->lsearch_type = t;
5110	yss->lsearch_text = strdup(text);
5111	yss->lsearch_gender = g;
5112	yss->lsearch_agerange = ar;
5113	yss->lsearch_photo = photo;
5114	yss->lsearch_yahoo_only = yahoo_only;
5115
5116	yahoo_search_internal(id, t, text, g, ar, photo, yahoo_only, 0, 0);
5117	}
5118
5119	void yahoo_search_again(int id, int start)
5120	{
5121	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
5122	struct yahoo_search_state *yss;
5123
5124	if(!yid \|\| !yid->ys)
5125	return;
5126
5127	yss = yid->ys;
5128
5129	if(start == -1)
5130	start = yss->lsearch_nstart + yss->lsearch_nfound;
5131
5132	yahoo_search_internal(id, yss->lsearch_type, yss->lsearch_text,
5133	yss->lsearch_gender, yss->lsearch_agerange,
5134	yss->lsearch_photo, yss->lsearch_yahoo_only,
5135	start, yss->lsearch_ntotal);
5136	}
5137
5138	struct send_file_data {
5139	struct yahoo_packet *pkt;
5140	yahoo_get_fd_callback callback;
5141	void *user_data;
5142	};
5143
5144	static void _yahoo_send_picture_connected(int id, int fd, int error, void *data)
5145	{
5146	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_FT);
5147	struct send_file_data *sfd = data;
5148	struct yahoo_packet *pkt = sfd->pkt;
5149	unsigned char buff[1024];
5150
5151	if(fd <= 0) {
5152	sfd->callback(id, fd, error, sfd->user_data);
5153	FREE(sfd);
5154	yahoo_packet_free(pkt);
5155	inputs = y_list_remove(inputs, yid);
5156	FREE(yid);
5157	return;
5158	}
5159
5160	yid->fd = fd;
5161	yahoo_send_packet(yid, pkt, 8);
5162	yahoo_packet_free(pkt);
5163
5164	snprintf((char *)buff, sizeof(buff), "29");
5165	buff[2] = 0xc0;
5166	buff[3] = 0x80;
5167
5168	write(yid->fd, buff, 4);
5169
5170	/* YAHOO_CALLBACK(ext_yahoo_add_handler)(nyd->fd, YAHOO_INPUT_READ); */
5171
5172	sfd->callback(id, fd, error, sfd->user_data);
5173	FREE(sfd);
5174	inputs = y_list_remove(inputs, yid);
5175	/*
5176	while(yahoo_tcp_readline(buff, sizeof(buff), nyd->fd) > 0) {
5177	if(!strcmp(buff, ""))
5178	break;
5179	}
5180
5181	*/
5182	yahoo_input_close(yid);
5183	}
5184
5185	void yahoo_send_picture(int id, const char *name, unsigned long size,
5186	yahoo_get_fd_callback callback, void *data)
5187	{
5188	struct yahoo_data *yd = find_conn_by_id(id);
5189	struct yahoo_input_data *yid;
5190	struct yahoo_server_settings *yss;
5191	struct yahoo_packet *pkt = NULL;
5192	char size_str[10];
5193	char expire_str[10];
5194	long content_length=0;
5195	unsigned char buff[1024];
5196	char url[255];
5197	struct send_file_data *sfd;
5198
5199	if(!yd)
5200	return;
5201
5202	yss = yd->server_settings;
5203
5204	yid = y_new0(struct yahoo_input_data, 1);
5205	yid->yd = yd;
5206	yid->type = YAHOO_CONNECTION_FT;
5207
5208	pkt = yahoo_packet_new(YAHOO_SERVICE_PICTURE_UPLOAD, YAHOO_STATUS_AVAILABLE, yd->session_id);
5209
5210	snprintf(size_str, sizeof(size_str), "%ld", size);
5211	snprintf(expire_str, sizeof(expire_str), "%ld", (long)604800);
5212
5213	yahoo_packet_hash(pkt, 0, yd->user);
5214	yahoo_packet_hash(pkt, 1, yd->user);
5215	yahoo_packet_hash(pkt, 14, "");
5216	yahoo_packet_hash(pkt, 27, name);
5217	yahoo_packet_hash(pkt, 28, size_str);
5218	yahoo_packet_hash(pkt, 38, expire_str);
5219
5220
5221	content_length = YAHOO_PACKET_HDRLEN + yahoo_packet_length(pkt);
5222
5223	snprintf(url, sizeof(url), "http://%s:%d/notifyft",
5224	yss->filetransfer_host, yss->filetransfer_port);
5225	snprintf((char *)buff, sizeof(buff), "Y=%s; T=%s",
5226	yd->cookie_y, yd->cookie_t);
5227	inputs = y_list_prepend(inputs, yid);
5228
5229	sfd = y_new0(struct send_file_data, 1);
5230	sfd->pkt = pkt;
5231	sfd->callback = callback;
5232	sfd->user_data = data;
5233	yahoo_http_post(yid->yd->client_id, url, (char *)buff, content_length+4+size,
5234	_yahoo_send_picture_connected, sfd);
5235	}
5236
5237	static void _yahoo_send_file_connected(int id, int fd, int error, void *data)
5238	{
5239	struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_FT);
5240	struct send_file_data *sfd = data;
5241	struct yahoo_packet *pkt = sfd->pkt;
5242	unsigned char buff[1024];
5243
5244	if(fd <= 0) {
5245	sfd->callback(id, fd, error, sfd->user_data);
5246	FREE(sfd);
5247	yahoo_packet_free(pkt);
5248	inputs = y_list_remove(inputs, yid);
5249	FREE(yid);
5250	return;
5251	}
5252
5253	yid->fd = fd;
5254	yahoo_send_packet(yid, pkt, 8);
5255	yahoo_packet_free(pkt);
5256
5257	snprintf((char *)buff, sizeof(buff), "29");
5258	buff[2] = 0xc0;
5259	buff[3] = 0x80;
5260
5261	write(yid->fd, buff, 4);
5262
5263	/* YAHOO_CALLBACK(ext_yahoo_add_handler)(nyd->fd, YAHOO_INPUT_READ); */
5264
5265	sfd->callback(id, fd, error, sfd->user_data);
5266	FREE(sfd);
5267	inputs = y_list_remove(inputs, yid);
5268	/*
5269	while(yahoo_tcp_readline(buff, sizeof(buff), nyd->fd) > 0) {
5270	if(!strcmp(buff, ""))
5271	break;
5272	}
5273
5274	*/
5275	yahoo_input_close(yid);
5276	}
5277
5278	void yahoo_send_file(int id, const char who, const char msg,
5279	const char *name, unsigned long size,
5280	yahoo_get_fd_callback callback, void *data)
5281	{
5282	struct yahoo_data *yd = find_conn_by_id(id);
5283	struct yahoo_input_data *yid;
5284	struct yahoo_server_settings *yss;
5285	struct yahoo_packet *pkt = NULL;
5286	char size_str[10];
5287	long content_length=0;
5288	unsigned char buff[1024];
5289	char url[255];
5290	struct send_file_data *sfd;
5291
5292	if(!yd)
5293	return;
5294
5295	yss = yd->server_settings;
5296
5297	yid = y_new0(struct yahoo_input_data, 1);
5298	yid->yd = yd;
5299	yid->type = YAHOO_CONNECTION_FT;
5300
5301	pkt = yahoo_packet_new(YAHOO_SERVICE_FILETRANSFER, YAHOO_STATUS_AVAILABLE, yd->session_id);
5302
5303	snprintf(size_str, sizeof(size_str), "%ld", size);
5304
5305	yahoo_packet_hash(pkt, 0, yd->user);
5306	yahoo_packet_hash(pkt, 5, who);
5307	yahoo_packet_hash(pkt, 14, msg);
5308	yahoo_packet_hash(pkt, 27, name);
5309	yahoo_packet_hash(pkt, 28, size_str);
5310
5311	content_length = YAHOO_PACKET_HDRLEN + yahoo_packet_length(pkt);
5312
5313	snprintf(url, sizeof(url), "http://%s:%d/notifyft",
5314	yss->filetransfer_host, yss->filetransfer_port);
5315	snprintf((char *)buff, sizeof(buff), "Y=%s; T=%s",
5316	yd->cookie_y, yd->cookie_t);
5317	inputs = y_list_prepend(inputs, yid);
5318
5319	sfd = y_new0(struct send_file_data, 1);
5320	sfd->pkt = pkt;
5321	sfd->callback = callback;
5322	sfd->user_data = data;
5323	yahoo_http_post(yid->yd->client_id, url, (char *)buff, content_length+4+size,
5324	_yahoo_send_file_connected, sfd);
5325	}
5326
5327
5328	enum yahoo_status yahoo_current_status(int id)
5329	{
5330	struct yahoo_data *yd = find_conn_by_id(id);
5331	if(!yd)
5332	return YAHOO_STATUS_OFFLINE;
5333	return yd->current_status;
5334	}
5335
5336	const YList * yahoo_get_buddylist(int id)
5337	{
5338	struct yahoo_data *yd = find_conn_by_id(id);
5339	if(!yd)
5340	return NULL;
5341	return yd->buddies;
5342	}
5343
5344	const YList * yahoo_get_ignorelist(int id)
5345	{
5346	struct yahoo_data *yd = find_conn_by_id(id);
5347	if(!yd)
5348	return NULL;
5349	return yd->ignore;
5350	}
5351
5352	const YList * yahoo_get_identities(int id)
5353	{
5354	struct yahoo_data *yd = find_conn_by_id(id);
5355	if(!yd)
5356	return NULL;
5357	return yd->identities;
5358	}
5359
5360	const char * yahoo_get_cookie(int id, const char *which)
5361	{
5362	struct yahoo_data *yd = find_conn_by_id(id);
5363	if(!yd)
5364	return NULL;
5365	if(!strncasecmp(which, "y", 1))
5366	return yd->cookie_y;
5367	if(!strncasecmp(which, "t", 1))
5368	return yd->cookie_t;
5369	if(!strncasecmp(which, "c", 1))
5370	return yd->cookie_c;
5371	if(!strncasecmp(which, "login", 5))
5372	return yd->login_cookie;
5373	return NULL;
5374	}
5375
5376	void yahoo_get_url_handle(int id, const char *url,
5377	yahoo_get_url_handle_callback callback, void *data)
5378	{
5379	struct yahoo_data *yd = find_conn_by_id(id);
5380	if(!yd)
5381	return;
5382
5383	yahoo_get_url_fd(id, url, yd, callback, data);
5384	}
5385
5386	const char * yahoo_get_profile_url( void )
5387	{
5388	return profile_url;
5389	}
5390

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

Download in other formats: