#	We have our own copy now...

# 	if(YAHOO2_FOUND)

# 		include_directories(${YAHOO2_INCLUDE_DIR})

# 	else()

# 		message("Libyahoo2 plugin  : no (install libyahoo2-devel)")

# 	endif()

# 	if(YAHOO2_FOUND)

# 	endif()

FILE(GLOB_RECURSE SRC *.c *.cpp)

ADD_DEFINITIONS(-DHAVE_STDINT_H=1)

include_directories(${CMAKE_CURRENT_SOURCE_DIR}/yahoo)

target_link_libraries(spectrum2_libyahoo2_backend transport pthread ${Boost_LIBRARIES} ${SWIFTEN_LIBRARY} ${LOG4CXX_LIBRARIES})

/* One way encryption based on MD5 sum.

   Copyright (C) 1996, 1997, 1999, 2000 Free Software Foundation, Inc.

   This file is part of the GNU C Library.

   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.

   The GNU C Library is free software; you can redistribute it and/or

   modify it under the terms of the GNU Lesser General Public

   License as published by the Free Software Foundation; either

   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public

   License along with the GNU C Library; if not, write to the Free

   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA

   02111-1307 USA.  */

/* warmenhoven took this file and made it work with the md5.[ch] we

 * already had. isn't that lovely. people should just use linux or

 * freebsd, crypt works properly on those systems. i hate solaris */

#if HAVE_CONFIG_H

#  include <config.h>

#endif

#if HAVE_STRING_H

#  include <string.h>

#elif HAVE_STRINGS_H

#  include <strings.h>

#endif

#include <stdlib.h>

#include "yahoo_util.h"

#include "md5.h"

/* Define our magic string to mark salt for MD5 "encryption"

   replacement.  This is meant to be the same as for other MD5 based

   encryption implementations.  */

static const char md5_salt_prefix[] = "$1$";

/* Table with characters for base64 transformation.  */

static const char b64t[64] =

	"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";

char *yahoo_crypt(char *key, char *salt)

{

	char *buffer = NULL;

	int buflen = 0;

	int needed = 3 + strlen(salt) + 1 + 26 + 1;

	md5_byte_t alt_result[16];

	md5_state_t ctx;

	md5_state_t alt_ctx;

	size_t salt_len;

	size_t key_len;

	size_t cnt;

	char *cp;

	if (buflen < needed) {

		buflen = needed;

		if ((buffer = realloc(buffer, buflen)) == NULL)

			return NULL;

	}

	/* Find beginning of salt string.  The prefix should normally always

	   be present.  Just in case it is not.  */

	if (strncmp(md5_salt_prefix, salt, sizeof(md5_salt_prefix) - 1) == 0)

		/* Skip salt prefix.  */

		salt += sizeof(md5_salt_prefix) - 1;

	salt_len = MIN(strcspn(salt, "$"), 8);

	key_len = strlen(key);

	/* Prepare for the real work.  */

	md5_init(&ctx);

	/* Add the key string.  */

	md5_append(&ctx, (md5_byte_t *)key, key_len);

	/* Because the SALT argument need not always have the salt prefix we

	   add it separately.  */

	md5_append(&ctx, (md5_byte_t *)md5_salt_prefix,

		sizeof(md5_salt_prefix) - 1);

	/* The last part is the salt string.  This must be at most 8

	   characters and it ends at the first `$' character (for

	   compatibility which existing solutions).  */

	md5_append(&ctx, (md5_byte_t *)salt, salt_len);

	/* Compute alternate MD5 sum with input KEY, SALT, and KEY.  The

	   final result will be added to the first context.  */

	md5_init(&alt_ctx);

	/* Add key.  */

	md5_append(&alt_ctx, (md5_byte_t *)key, key_len);

	/* Add salt.  */

	md5_append(&alt_ctx, (md5_byte_t *)salt, salt_len);

	/* Add key again.  */

	md5_append(&alt_ctx, (md5_byte_t *)key, key_len);

	/* Now get result of this (16 bytes) and add it to the other

	   context.  */

	md5_finish(&alt_ctx, alt_result);

	/* Add for any character in the key one byte of the alternate sum.  */

	for (cnt = key_len; cnt > 16; cnt -= 16)

		md5_append(&ctx, alt_result, 16);

	md5_append(&ctx, alt_result, cnt);

	/* For the following code we need a NUL byte.  */

	alt_result[0] = '\0';

	/* The original implementation now does something weird: for every 1

	   bit in the key the first 0 is added to the buffer, for every 0

	   bit the first character of the key.  This does not seem to be

	   what was intended but we have to follow this to be compatible.  */

	for (cnt = key_len; cnt > 0; cnt >>= 1)

		md5_append(&ctx,

			(cnt & 1) != 0 ? alt_result : (md5_byte_t *)key, 1);

	/* Create intermediate result.  */

	md5_finish(&ctx, alt_result);

	/* Now comes another weirdness.  In fear of password crackers here

	   comes a quite long loop which just processes the output of the

	   previous round again.  We cannot ignore this here.  */

	for (cnt = 0; cnt < 1000; ++cnt) {

		/* New context.  */

		md5_init(&ctx);

		/* Add key or last result.  */

		if ((cnt & 1) != 0)

			md5_append(&ctx, (md5_byte_t *)key, key_len);

		else

			md5_append(&ctx, alt_result, 16);

		/* Add salt for numbers not divisible by 3.  */

		if (cnt % 3 != 0)

			md5_append(&ctx, (md5_byte_t *)salt, salt_len);

		/* Add key for numbers not divisible by 7.  */

		if (cnt % 7 != 0)

			md5_append(&ctx, (md5_byte_t *)key, key_len);

		/* Add key or last result.  */

		if ((cnt & 1) != 0)

			md5_append(&ctx, alt_result, 16);

		else

			md5_append(&ctx, (md5_byte_t *)key, key_len);

		/* Create intermediate result.  */

		md5_finish(&ctx, alt_result);

	}

	/* Now we can construct the result string.  It consists of three

	   parts.  */

	strncpy(buffer, md5_salt_prefix, MAX(0, buflen));

	cp = buffer + strlen(buffer);

	buflen -= sizeof(md5_salt_prefix);

	strncpy(cp, salt, MIN((size_t) buflen, salt_len));

	cp = cp + strlen(cp);

	buflen -= MIN((size_t) buflen, salt_len);

	if (buflen > 0) {

		*cp++ = '$';

		--buflen;

	}

#define b64_from_24bit(B2, B1, B0, N) \

	do { \

		unsigned int w = ((B2) << 16) | ((B1) << 8) | (B0); \

		int n = (N); \

		while (n-- > 0 && buflen > 0) { \

			*cp++ = b64t[w & 0x3f]; \

			--buflen; \

			w >>= 6; \

		}\

	} while (0)

	b64_from_24bit(alt_result[0], alt_result[6], alt_result[12], 4);

	b64_from_24bit(alt_result[1], alt_result[7], alt_result[13], 4);

	b64_from_24bit(alt_result[2], alt_result[8], alt_result[14], 4);

	b64_from_24bit(alt_result[3], alt_result[9], alt_result[15], 4);

	b64_from_24bit(alt_result[4], alt_result[10], alt_result[5], 4);

	b64_from_24bit(0, 0, alt_result[11], 2);

	if (buflen <= 0) {

		FREE(buffer);

	} else

		*cp = '\0';	/* Terminate the string.  */

	/* Clear the buffer for the intermediate result so that people

	   attaching to processes or reading core dumps cannot get any

	   information.  We do it in this way to clear correct_words[]

	   inside the MD5 implementation as well.  */

	md5_init(&ctx);

	md5_finish(&ctx, alt_result);

	memset(&ctx, '\0', sizeof(ctx));

	memset(&alt_ctx, '\0', sizeof(alt_ctx));

	return buffer;

}

/*

 * libyahoo2: libyahoo2.c

 *

 * Some code copyright (C) 2002-2004, Philip S Tellis <philip.tellis AT gmx.net>

 * YMSG16 code copyright (C) 2009, 

 * 		Siddhesh Poyarekar <siddhesh dot poyarekar at gmail dot com>

 *

 * Yahoo Search copyright (C) 2003, Konstantin Klyagin <konst AT konst.org.ua>

 *

 * Much of this code was taken and adapted from the yahoo module for

 * gaim released under the GNU GPL.  This code is also released under the 

 * GNU GPL.

 *

 * This code is derivitive of Gaim <http://gaim.sourceforge.net>

 * copyright (C) 1998-1999, Mark Spencer <markster@marko.net>

 *	       1998-1999, Adam Fritzler <afritz@marko.net>

 *	       1998-2002, Rob Flynn <rob@marko.net>

 *	       2000-2002, Eric Warmenhoven <eric@warmenhoven.org>

 *	       2001-2002, Brian Macke <macke@strangelove.net>

 *		    2001, Anand Biligiri S <abiligiri@users.sf.net>

 *		    2001, Valdis Kletnieks

 *		    2002, Sean Egan <bj91704@binghamton.edu>

 *		    2002, Toby Gray <toby.gray@ntlworld.com>

 *

 * This library also uses code from other libraries, namely:

 *     Portions from libfaim copyright 1998, 1999 Adam Fritzler

 *     <afritz@auk.cx>

 *     Portions of Sylpheed copyright 2000-2002 Hiroyuki Yamamoto

 *     <hiro-y@kcn.ne.jp>

 *

 * YMSG16 authentication code based mostly on write-up at:

 * 	http://www.carbonize.co.uk/ymsg16.html

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 */

#if HAVE_CONFIG_H

# include <config.h>

#endif

#if HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <errno.h>

#include <stdio.h>

#include <stdarg.h>

#if STDC_HEADERS

# include <string.h>

#else

# if !HAVE_STRCHR

#  define strchr index

#  define strrchr rindex

# endif

char *strchr(), *strrchr();

# if !HAVE_MEMCPY

#  define memcpy(d, s, n) bcopy ((s), (d), (n))

#  define memmove(d, s, n) bcopy ((s), (d), (n))

# endif

#endif

#include <sys/types.h>

#include <stdlib.h>

#include <ctype.h>

#include "sha1.h"

#include "md5.h"

#include "yahoo2.h"

#include "yahoo_httplib.h"

#include "yahoo_util.h"

#include "yahoo_fn.h"

#include "yahoo2_callbacks.h"

#include "yahoo_debug.h"

#ifdef __MINGW32__

#define snprintf _snprintf

#define vsnprintf _vsnprintf

#endif

struct yahoo_callbacks *yc = NULL;

void yahoo_register_callbacks(struct yahoo_callbacks *tyc)

{

	yc = tyc;

}

#define YAHOO_CALLBACK(x)	yc->x

static int yahoo_send_data(void *fd, void *data, int len);

static void _yahoo_http_connected(int id, void *fd, int error, void *data);

static void yahoo_connected(void *fd, int error, void *data);

int yahoo_log_message(char *fmt, ...)

{

	char out[1024];

	va_list ap;

	va_start(ap, fmt);

	vsnprintf(out, sizeof(out), fmt, ap);

	va_end(ap);

	return YAHOO_CALLBACK(ext_yahoo_log) ("%s", out);

}

int yahoo_connect(char *host, int port)

{

	return YAHOO_CALLBACK(ext_yahoo_connect) (host, port);

}

static enum yahoo_log_level log_level = YAHOO_LOG_NONE;

enum yahoo_log_level yahoo_get_log_level()

{

	return log_level;

}

int yahoo_set_log_level(enum yahoo_log_level level)

{

	enum yahoo_log_level l = log_level;

	log_level = level;

	return l;

}

/* default values for servers */

static char *default_pager_hosts[] = {	"scs.msg.yahoo.com",

					"scsa.msg.yahoo.com",

					"scsb.msg.yahoo.com",

					"scsc.msg.yahoo.com",

					NULL};

static int pager_port = 5050;

static int fallback_ports[] = { 23, 25, 80, 20, 119, 8001, 8002, 5050, 0 };

static char filetransfer_host[] = "filetransfer.msg.yahoo.com";

static int filetransfer_port = 80;

static char webcam_host[] = "webcam.yahoo.com";

static int webcam_port = 5100;

static char webcam_description[] = "";

static char local_host[] = "";

static int conn_type = Y_WCM_DSL;

static char profile_url[] = "http://profiles.yahoo.com/";

struct connect_callback_data {

	struct yahoo_data *yd;

	int tag;

	int i;

	int server_i;

};

struct yahoo_pair {

	int key;

	char *value;

};

struct yahoo_packet {

	unsigned short int service;

	unsigned int status;

	unsigned int id;

	YList *hash;

};

struct yahoo_search_state {

	int lsearch_type;

	char *lsearch_text;

	int lsearch_gender;

	int lsearch_agerange;

	int lsearch_photo;

	int lsearch_yahoo_only;

	int lsearch_nstart;

	int lsearch_nfound;

	int lsearch_ntotal;

};

struct data_queue {

	unsigned char *queue;

	int len;

};

struct yahoo_input_data {

	struct yahoo_data *yd;

	struct yahoo_webcam *wcm;

	struct yahoo_webcam_data *wcd;

	struct yahoo_search_state *ys;

	void *fd;

	enum yahoo_connection_type type;

	unsigned char *rxqueue;

	int rxlen;

	int read_tag;

	YList *txqueues;

	int write_tag;

};

struct yahoo_server_settings {

	char *pager_host;

	int pager_port;

	char *filetransfer_host;

	int filetransfer_port;

	char *webcam_host;

	int webcam_port;

	char *webcam_description;

	char *local_host;

	int conn_type;

	char **pager_host_list;

};

static void yahoo_process_ft_connection(struct yahoo_input_data *yid, int over);

static void yahoo_process_filetransfer(struct yahoo_input_data *yid,

	struct yahoo_packet *pkt);

static void yahoo_process_filetransferinfo(struct yahoo_input_data *yid,

	struct yahoo_packet *pkt);

static void yahoo_process_filetransferaccept(struct yahoo_input_data *yid,

	struct yahoo_packet *pkt);

static void *_yahoo_default_server_settings()

{

	struct yahoo_server_settings *yss =

		y_new0(struct yahoo_server_settings, 1);

	/* Give preference to the default host list

	 * Make sure that only one of the two is set at any time 

	 */

	yss->pager_host = NULL;

	yss->pager_host_list = default_pager_hosts;

	yss->pager_port = pager_port;

	yss->filetransfer_host = strdup(filetransfer_host);

	yss->filetransfer_port = filetransfer_port;

	yss->webcam_host = strdup(webcam_host);

	yss->webcam_port = webcam_port;

	yss->webcam_description = strdup(webcam_description);

	yss->local_host = strdup(local_host);

	yss->conn_type = conn_type;

	return yss;

}

static void *_yahoo_assign_server_settings(va_list ap)

{

	struct yahoo_server_settings *yss = _yahoo_default_server_settings();

	char *key;

	char *svalue;

	int nvalue;

	char **pvalue;

	while (1) {

		key = va_arg(ap, char *);

		if (key == NULL)

			break;

		if (!strcmp(key, "pager_host")) {

			svalue = va_arg(ap, char *);

			free(yss->pager_host);

			yss->pager_host = strdup(svalue);

			yss->pager_host_list = NULL;

		} else if (!strcmp(key, "pager_host_list")) {

			pvalue = va_arg(ap, char **);

			yss->pager_host_list = pvalue;

			free(yss->pager_host);

			yss->pager_host = NULL;

		} else if (!strcmp(key, "pager_port")) {

			nvalue = va_arg(ap, int);

			yss->pager_port = nvalue;

		} else if (!strcmp(key, "filetransfer_host")) {

			svalue = va_arg(ap, char *);

			free(yss->filetransfer_host);

			yss->filetransfer_host = strdup(svalue);

		} else if (!strcmp(key, "filetransfer_port")) {

			nvalue = va_arg(ap, int);

			yss->filetransfer_port = nvalue;

		} else if (!strcmp(key, "webcam_host")) {

			svalue = va_arg(ap, char *);

			free(yss->webcam_host);

			yss->webcam_host = strdup(svalue);

		} else if (!strcmp(key, "webcam_port")) {

			nvalue = va_arg(ap, int);

			yss->webcam_port = nvalue;

		} else if (!strcmp(key, "webcam_description")) {

			svalue = va_arg(ap, char *);

			free(yss->webcam_description);

			yss->webcam_description = strdup(svalue);

		} else if (!strcmp(key, "local_host")) {

			svalue = va_arg(ap, char *);

			free(yss->local_host);

			yss->local_host = strdup(svalue);

		} else if (!strcmp(key, "conn_type")) {

			nvalue = va_arg(ap, int);

			yss->conn_type = nvalue;

		} else {

			WARNING(("Unknown key passed to yahoo_init, "

					"perhaps you didn't terminate the list "

					"with NULL"));

		}

	}

	return yss;

}

static void yahoo_free_server_settings(struct yahoo_server_settings *yss)

{

	if (!yss)

		return;

	free(yss->pager_host);

	free(yss->filetransfer_host);

	free(yss->webcam_host);

	free(yss->webcam_description);

	free(yss->local_host);

	free(yss);

}

static YList *conns = NULL;

static YList *inputs = NULL;

static int last_id = 0;

static void add_to_list(struct yahoo_data *yd)

{

	conns = y_list_prepend(conns, yd);

}

static struct yahoo_data *find_conn_by_id(int id)

{

	YList *l;

	for (l = conns; l; l = y_list_next(l)) {

		struct yahoo_data *yd = l->data;

		if (yd->client_id == id)

			return yd;

	}

	return NULL;

}

static void del_from_list(struct yahoo_data *yd)

{

	conns = y_list_remove(conns, yd);

}

/* call repeatedly to get the next one */

/*

static struct yahoo_input_data * find_input_by_id(int id)

{

	YList *l;

	for(l = inputs; l; l = y_list_next(l)) {

		struct yahoo_input_data *yid = l->data;

		if(yid->yd->client_id == id)

			return yid;

	}

	return NULL;

}

*/

static struct yahoo_input_data *find_input_by_id_and_webcam_user(int id,

	const char *who)

{

	YList *l;

	LOG(("find_input_by_id_and_webcam_user"));

	for (l = inputs; l; l = y_list_next(l)) {

		struct yahoo_input_data *yid = l->data;

		if (yid->type == YAHOO_CONNECTION_WEBCAM

			&& yid->yd->client_id == id && yid->wcm && ((who

					&& yid->wcm->user

					&& !strcmp(who, yid->wcm->user))

				|| !(yid->wcm->user && !who)))

			return yid;

	}

	return NULL;

}

static struct yahoo_input_data *find_input_by_id_and_type(int id,

	enum yahoo_connection_type type)

{

	YList *l;

	LOG(("find_input_by_id_and_type"));

	for (l = inputs; l; l = y_list_next(l)) {

		struct yahoo_input_data *yid = l->data;

		if (yid->type == type && yid->yd->client_id == id)

			return yid;

	}

	return NULL;

}

static struct yahoo_input_data *find_input_by_id_and_fd(int id, void *fd)

{

	YList *l;

	LOG(("find_input_by_id_and_fd"));

	for (l = inputs; l; l = y_list_next(l)) {

		struct yahoo_input_data *yid = l->data;

		if (yid->fd == fd && yid->yd->client_id == id)

			return yid;

	}

	return NULL;

}

static int count_inputs_with_id(int id)

{

	int c = 0;

	YList *l;

	LOG(("counting %d", id));

	for (l = inputs; l; l = y_list_next(l)) {

		struct yahoo_input_data *yid = l->data;

		if (yid->yd->client_id == id)

			c++;

	}

	LOG(("%d", c));

	return c;

}

extern char *yahoo_crypt(char *, char *);

/* Free a buddy list */

static void yahoo_free_buddies(YList *list)

{

	YList *l;

	for (l = list; l; l = l->next) {

		struct yahoo_buddy *bud = l->data;

		if (!bud)

			continue;

		FREE(bud->group);

		FREE(bud->id);

		FREE(bud->real_name);

		if (bud->yab_entry) {

			FREE(bud->yab_entry->fname);

			FREE(bud->yab_entry->lname);

			FREE(bud->yab_entry->nname);

			FREE(bud->yab_entry->id);

			FREE(bud->yab_entry->email);

			FREE(bud->yab_entry->hphone);

			FREE(bud->yab_entry->wphone);

			FREE(bud->yab_entry->mphone);

			FREE(bud->yab_entry);

		}

		FREE(bud);

		l->data = bud = NULL;

	}

	y_list_free(list);

}

/* Free an identities list */

static void yahoo_free_identities(YList *list)

{

	while (list) {

		YList *n = list;

		FREE(list->data);

		list = y_list_remove_link(list, list);

		y_list_free_1(n);

	}

}

/* Free webcam data */

static void yahoo_free_webcam(struct yahoo_webcam *wcm)

{

	if (wcm) {

		FREE(wcm->user);

		FREE(wcm->server);

		FREE(wcm->key);

		FREE(wcm->description);

		FREE(wcm->my_ip);

	}

	FREE(wcm);

}

static void yahoo_free_data(struct yahoo_data *yd)

{

	FREE(yd->user);

	FREE(yd->password);

	FREE(yd->cookie_y);

	FREE(yd->cookie_t);

	FREE(yd->cookie_b);

	FREE(yd->cookie_c);

	FREE(yd->login_cookie);

	FREE(yd->login_id);

	yahoo_free_buddies(yd->buddies);

	yahoo_free_buddies(yd->ignore);

	yahoo_free_identities(yd->identities);

	yahoo_free_server_settings(yd->server_settings);

	FREE(yd);

}

#define YAHOO_PACKET_HDRLEN (4 + 2 + 2 + 2 + 2 + 4 + 4)

static struct yahoo_packet *yahoo_packet_new(enum yahoo_service service,

	enum ypacket_status status, int id)

{