Context Navigation

source: protocols/yahoo/libyahoo2.c @ 0c41177

1.2.3-2

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

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

Download in other formats: