Context Navigation

source: protocols/yahoo/libyahoo2.c @ 5e202b0

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

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

Download in other formats: