Context Navigation

source: protocols/yahoo/libyahoo2.c @ e4d6271

Last change on this file since e4d6271 was c3c2e14, checked in by Wilmer van der Gaast <wilmer@…>, at 2005-11-30T12:12:25Z
Got rid of the config.h includes in IM-code. Now that HAVE_CONFIG_H is defined, they started to cause problems.
Property mode set to `100644`
File size: 109.5 KB

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

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

Download in other formats: