#include "utils.h"

#include "glib.h"

// win32/libc_interface.h defines its own socket(), read() and so on.

// We don't want to use it here.

#define _LIBC_INTERFACE_H_ 1

#include "purple.h"

#include <algorithm>

#include <iostream>

#include "transport/networkplugin.h"

#include "transport/logging.h"

#include "transport/config.h"

#include "transport/logging.h"

#include "geventloop.h"

// #include "valgrind/memcheck.h"

#include "malloc.h"

#endif

#include <algorithm>

#include "errno.h"

#include <boost/make_shared.hpp>

#ifdef WITH_LIBEVENT

#include <event.h>

#endif

#ifdef WIN32

#include "win32/win32dep.h"

#define close closesocket

#define ssize_t SSIZE_T

#include <process.h>

#define getpid _getpid

#endif

#include "purple_defs.h"

DEFINE_LOGGER(logger_libpurple, "libpurple");

DEFINE_LOGGER(logger, "backend");

int main_socket;

static int writeInput;

bool firstPing = true;

using namespace Transport;

template <class T> T fromString(const std::string &str) {

	T i;

	std::istringstream os(str);

	os >> i;

	return i;

}

template <class T> std::string stringOf(T object) {

	std::ostringstream os;

	os << object;

	return (os.str());

}

static std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) {

    std::stringstream ss(s);

    std::string item;

    while(std::getline(ss, item, delim)) {

        elems.push_back(item);

    }

			// Default avatar

			setDefaultAvatar(account, legacyName);

			purple_account_set_password_wrapped(account, password.c_str());

			purple_account_set_bool_wrapped(account, "custom_smileys", FALSE);

			purple_account_set_bool_wrapped(account, "direct_connect", FALSE);

			setDefaultAccountOptions(account);

			// Enable account + privacy lists

			purple_account_set_enabled_wrapped(account, "spectrum", TRUE);

#if PURPLE_MAJOR_VERSION >= 2 && PURPLE_MINOR_VERSION >= 7

			if (CONFIG_BOOL(config, "service.enable_privacy_lists")) {

				purple_account_set_privacy_type_wrapped(account, PURPLE_PRIVACY_DENY_USERS);

			}

#endif

			// Set the status

			const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive_wrapped(account, PURPLE_STATUS_AVAILABLE);

			if (status_type != NULL) {

				purple_account_set_status_wrapped(account, purple_status_type_get_id_wrapped(status_type), TRUE, NULL);

			}

		}

		void handleLogoutRequest(const std::string &user, const std::string &legacyName) {

			PurpleAccount *account = m_sessions[user];

			if (account) {

				if (account->ui_data) {

					NodeCache *cache = (NodeCache *) account->ui_data;

					purple_timeout_remove_wrapped(cache->timer);

					delete cache;

					account->ui_data = NULL;

				}

				if (purple_account_get_int_wrapped(account, "version", 0) != 0) {

					std::string data = stringOf(purple_account_get_int_wrapped(account, "version", 0));

					g_file_set_contents ("gfire.cfg", data.c_str(), data.size(), NULL);

				}

// 				VALGRIND_DO_LEAK_CHECK;

				m_sessions.erase(user);

				purple_account_disconnect_wrapped(account);

				purple_account_set_enabled_wrapped(account, "spectrum", FALSE);

				m_accounts.erase(account);

				purple_accounts_delete_wrapped(account);

#ifndef WIN32

				malloc_trim(0);

#endif

#endif

// 				VALGRIND_DO_LEAK_CHECK;

			}

		}

		void handleStatusChangeRequest(const std::string &user, int status, const std::string &statusMessage) {

			PurpleAccount *account = m_sessions[user];

			if (account) {

				int st;

				switch(status) {

					case pbnetwork::STATUS_AWAY: {

						st = PURPLE_STATUS_AWAY;

						if (!purple_account_get_status_type_with_primitive_wrapped(account, PURPLE_STATUS_AWAY))

							st = PURPLE_STATUS_EXTENDED_AWAY;

						else

							st = PURPLE_STATUS_AWAY;

						break;

					}

					case pbnetwork::STATUS_DND: {

						st = PURPLE_STATUS_UNAVAILABLE;

						break;

					}

					case pbnetwork::STATUS_XA: {

						if (!purple_account_get_status_type_with_primitive_wrapped(account, PURPLE_STATUS_EXTENDED_AWAY))

							st = PURPLE_STATUS_AWAY;

						else

							st = PURPLE_STATUS_EXTENDED_AWAY;

						break;

					}

					case pbnetwork::STATUS_NONE: {

						st = PURPLE_STATUS_OFFLINE;

						break;

					}

					case pbnetwork::STATUS_INVISIBLE:

						st = PURPLE_STATUS_INVISIBLE;

						break;

					default:

						st = PURPLE_STATUS_AVAILABLE;

						break;

				}

				gchar *_markup = purple_markup_escape_text_wrapped(statusMessage.c_str(), -1);

				std::string markup(_markup);

				g_free(_markup);

				// we are already connected so we have to change status

				const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive_wrapped(account, (PurpleStatusPrimitive) st);

		std::string message(new_domain ? new_domain : "g_log");

		message.push_back(' ');

		message.append(new_msg);

		LOG4CXX_ERROR(logger, message);

		g_free(new_msg);

	}

	g_free(new_domain);

}

static void

debug_init(void)

{

#define REGISTER_G_LOG_HANDLER(name) \

	g_log_set_handler((name), \

		(GLogLevelFlags)(G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL \

										  | G_LOG_FLAG_RECURSION), \

					  spectrum_glib_log_handler, NULL)

	REGISTER_G_LOG_HANDLER(NULL);

	REGISTER_G_LOG_HANDLER("GLib");

	REGISTER_G_LOG_HANDLER("GModule");

	REGISTER_G_LOG_HANDLER("GLib-GObject");

	REGISTER_G_LOG_HANDLER("GThread");

	REGISTER_G_LOG_HANDLER("GConf");

#undef REGISTER_G_LOD_HANDLER

}

static PurpleCoreUiOps coreUiOps =

{

	NULL,

	debug_init,

	transport_core_ui_init,

	NULL,

	spectrum_ui_get_info,

	NULL,

	NULL,

	NULL

};

static void signed_on(PurpleConnection *gc, gpointer unused) {

	PurpleAccount *account = purple_connection_get_account_wrapped(gc);

	np->handleConnected(np->m_accounts[account]);

#ifndef WIN32

	// force returning of memory chunks allocated by libxml2 to kernel

	malloc_trim(0);

#endif

#endif

	// For prpl-gg

	execute_purple_plugin_action(gc, "Download buddylist from Server");

}

static void printDebug(PurpleDebugLevel level, const char *category, const char *arg_s) {

	std::string c("");

	std::string args(arg_s);

	args.erase(args.size() - 1);

	if (category) {

		c.append(category);

	}

	c.push_back(':');

	LOG4CXX_INFO(logger_libpurple, c << args);

}

/*

 * Ops....

 */

static PurpleDebugUiOps debugUiOps =

{

	printDebug,

	NULL,

	NULL,

	NULL,

	NULL,

	NULL

};

static void buddyTyping(PurpleAccount *account, const char *who, gpointer null) {

	std::string w = purple_normalize_wrapped(account, who);

	size_t pos = w.find("/");

	if (pos != std::string::npos)

		w.erase((int) pos, w.length() - (int) pos);

	np->handleBuddyTyping(np->m_accounts[account], w);

}

static void buddyTyped(PurpleAccount *account, const char *who, gpointer null) {

	std::string w = purple_normalize_wrapped(account, who);

	size_t pos = w.find("/");

	if (pos != std::string::npos)

		purple_signal_connect_wrapped(purple_xfers_get_handle_wrapped(), "file-recv-complete", &xfer_handle, PURPLE_CALLBACK(XferReceiveComplete), NULL);

		purple_signal_connect_wrapped(purple_xfers_get_handle_wrapped(), "file-send-complete", &xfer_handle, PURPLE_CALLBACK(XferSendComplete), NULL);

// 

// 		purple_commands_init();

	}

	return ret;

}

static void transportDataReceived(gpointer data, gint source, PurpleInputCondition cond) {

	if (cond & PURPLE_INPUT_READ) {

		char buffer[65535];

		char *ptr = buffer;

#ifdef WIN32

		ssize_t n = recv(source, ptr, sizeof(buffer), 0);

#else

		ssize_t n = read(source, ptr, sizeof(buffer));

#endif

		if (n <= 0) {

			if (errno == EAGAIN) {

				return;

			}

			LOG4CXX_INFO(logger, "Diconnecting from spectrum2 server");

			exit(errno);

		}

		std::string d = std::string(buffer, n);

		if (firstPing) {

			firstPing = false;

			NetworkPlugin::PluginConfig cfg;

			cfg.setSupportMUC(true);

			np->sendConfig(cfg);

		}

		np->handleDataRead(d);

	}

	else {

		if (writeInput != 0) {

			purple_input_remove_wrapped(writeInput);

			writeInput = 0;

		}

		np->readyForData();

	}

}

int main(int argc, char **argv) {

#ifndef WIN32

		mallopt(M_CHECK_ACTION, 2);

		mallopt(M_PERTURB, 0xb);

#endif

		signal(SIGPIPE, SIG_IGN);

		if (signal(SIGCHLD, spectrum_sigchld_handler) == SIG_ERR) {

			std::cout << "SIGCHLD handler can't be set\n";

			return -1;

		}

#endif

	std::string error;

	Config *cfg = Config::createFromArgs(argc, argv, error, host, port);

	if (cfg == NULL) {

		std::cerr << error;

		return 1;

	}

	config = boost::shared_ptr<Config>(cfg);

	Logging::initBackendLogging(config.get());

	initPurple();

	main_socket = create_socket(host.c_str(), port);

	purple_input_add_wrapped(main_socket, PURPLE_INPUT_READ, &transportDataReceived, NULL);

	purple_timeout_add_seconds_wrapped(30, pingTimeout, NULL);

	np = new SpectrumNetworkPlugin();

	bool libev = CONFIG_STRING_DEFAULTED(config, "service.eventloop", "") == "libev";

	GMainLoop *m_loop;

#ifdef WITH_LIBEVENT

	if (!libev) {

		m_loop = g_main_loop_new(NULL, FALSE);

	}

	else {

		event_init();

	}

#endif

	m_loop = g_main_loop_new(NULL, FALSE);

	if (m_loop) {

		g_main_loop_run(m_loop);

	}

#ifdef WITH_LIBEVENT

	else {

		event_loop(0);

	}

/* 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);

 * 		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

/*

 * libyahoo2: yahoo_util.c

 *

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

 *

 * 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 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 "yahoo_util.h"

char *y_string_append(char *string, char *append)

{

	int size = strlen(string) + strlen(append) + 1;

	char *new_string = y_renew(char, string, size);

	if (new_string == NULL) {

		new_string = y_new(char, size);

		strcpy(new_string, string);

		FREE(string);

	}

	strcat(new_string, append);

	return new_string;

}

char *y_str_to_utf8(const char *in)

{

	unsigned int n, i = 0;

	char *result = NULL;

	if (in == NULL || *in == '\0')

		return strdup("");

	result = y_new(char, strlen(in) * 2 + 1);

	/* convert a string to UTF-8 Format */

	for (n = 0; n < strlen(in); n++) {

		unsigned char c = (unsigned char)in[n];

		if (c < 128) {

			result[i++] = (char)c;

 *

 */

#ifndef __YAHOO_UTIL_H__

#define __YAHOO_UTIL_H__

#if HAVE_CONFIG_H

# include <config.h>

#endif

#if HAVE_GLIB

# include <glib.h>

# define FREE(x)	if(x) {g_free(x); x=NULL;}

# define y_new		g_new

# define y_new0		g_new0

# define y_renew	g_renew

# define y_memdup	g_memdup

# define y_strsplit	g_strsplit

# define y_strfreev	g_strfreev

# ifndef strdup

#  define strdup	g_strdup

# endif

# ifndef strncasecmp

#  define strncasecmp	g_strncasecmp

#  define strcasecmp	g_strcasecmp

# endif

# define snprintf	g_snprintf

# define vsnprintf	g_vsnprintf

#else

# include <stdlib.h>

# include <stdarg.h>

# define FREE(x)		if(x) {free(x); x=NULL;}

# define y_new(type, n)		(type *)malloc(sizeof(type) * (n))

# define y_new0(type, n)	(type *)calloc((n), sizeof(type))

# define y_renew(type, mem, n)	(type *)realloc(mem, n)

void *y_memdup(const void *addr, int n);

char **y_strsplit(char *str, char *sep, int nelem);

void y_strfreev(char **vector);

int strncasecmp(const char *s1, const char *s2, size_t n);

int strcasecmp(const char *s1, const char *s2);

char *strdup(const char *s);

int snprintf(char *str, size_t size, const char *format, ...);

int vsnprintf(char *str, size_t size, const char *format, va_list ap);

#endif

#endif

#ifndef TRUE

#define TRUE 1

#endif

#ifndef FALSE

#define FALSE 0

#endif

#ifndef MIN

#define MIN(x,y) ((x)<(y)?(x):(y))

#endif

#ifndef MAX

#define MAX(x,y) ((x)>(y)?(x):(y))

#endif

/* 

 * The following three functions return newly allocated memory.

 * You must free it yourself

 */

char *y_string_append(char *str, char *append);

char *y_str_to_utf8(const char *in);

char *y_utf8_to_str(const char *in);

#endif