Context Navigation

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

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

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

Download in other formats: