purple_xfers_set_ui_ops(&xferUiOps);

	purple_connections_set_ui_ops(&conn_ui_ops);

	purple_conversations_set_ui_ops(&conversation_ui_ops);

// #ifndef WIN32

// 	purple_dnsquery_set_ui_ops(getDNSUiOps());

// #endif

}

/***** Core Ui Ops *****/

static void

spectrum_glib_log_handler(const gchar *domain,

						  GLogLevelFlags flags,

						  const gchar *message,

						  gpointer user_data)

{

	const char *level;

	char *new_msg = NULL;

	char *new_domain = NULL;

	if ((flags & G_LOG_LEVEL_ERROR) == G_LOG_LEVEL_ERROR)

		level = "ERROR";

	else if ((flags & G_LOG_LEVEL_CRITICAL) == G_LOG_LEVEL_CRITICAL)

		level = "CRITICAL";

	else if ((flags & G_LOG_LEVEL_WARNING) == G_LOG_LEVEL_WARNING)

		level = "WARNING";

	else if ((flags & G_LOG_LEVEL_MESSAGE) == G_LOG_LEVEL_MESSAGE)

		level = "MESSAGE";

	else if ((flags & G_LOG_LEVEL_INFO) == G_LOG_LEVEL_INFO)

		level = "INFO";

	else if ((flags & G_LOG_LEVEL_DEBUG) == G_LOG_LEVEL_DEBUG)

		level = "DEBUG";

	else {

		LOG4CXX_ERROR(logger, "Unknown glib logging level in " << (guint)flags);

		level = "UNKNOWN"; /* This will never happen. */

	}

	if (message != NULL)

		new_msg = purple_utf8_try_convert(message);

	if (domain != NULL)

		new_domain = purple_utf8_try_convert(domain);

	if (new_msg != NULL) {

		std::string area("glib");

		area.push_back('/');

		area.append(level);

		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");

#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(gc);

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

#ifndef WIN32

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

	malloc_trim(0);

#endif

}

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(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(account, who);

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

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

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

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

}

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

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

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

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

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

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

}

static void gotAttention(PurpleAccount *account, const char *who, PurpleConversation *conv, guint type) {

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

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

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

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

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

}

static bool initPurple() {

	bool ret;

	purple_util_set_user_dir("./");

	remove("./accounts.xml");

	remove("./blist.xml");

	purple_debug_set_ui_ops(&debugUiOps);

	purple_debug_set_verbose(true);

	purple_core_set_ui_ops(&coreUiOps);

	if (KEYFILE_STRING("service", "eventloop") == "libev") {

		LOG4CXX_INFO(logger, "Will use libev based event loop");

	}

	else {

		LOG4CXX_INFO(logger, "Will use glib based event loop");

	}

	purple_eventloop_set_ui_ops(getEventLoopUiOps(KEYFILE_STRING("service", "eventloop") == "libev"));

	ret = purple_core_init("spectrum");

	if (ret) {

		static int blist_handle;

		static int conversation_handle;

		purple_set_blist(purple_blist_new());

		purple_blist_load();

		purple_prefs_load();

		/* Good default preferences */

		/* The combination of these two settings mean that libpurple will never

		 * (of its own accord) set all the user accounts idle.

		 */

		purple_prefs_set_bool("/purple/away/away_when_idle", false);

		/*

/**

 * libtransport -- C++ library for easy XMPP Transports development

 *

 * Copyright (C) 2011, Jan Kaluza <hanzz.k@gmail.com>

 *

 * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA

 */

#include "utils.h"

#include "glib.h"

#include "purple.h"

#include <algorithm>

#include <iostream>

#include "errno.h"

#ifndef WIN32 

#include "sys/wait.h"

#include "sys/signal.h"

#include <netinet/if_ether.h>

#include <netinet/ip.h>

#include <netinet/ip6.h>

#include <netinet/udp.h>

#include <netinet/tcp.h>

#include <netinet/ether.h>

#include "sys/socket.h"

#include <netdb.h>

#include <unistd.h>

#include <fcntl.h>

#else 

#include <process.h>

#define getpid _getpid 

#define ssize_t SSIZE_T

#include "win32/win32dep.h"

#endif

static GHashTable *ui_info = NULL;

GHashTable *spectrum_ui_get_info(void)

{

	if(NULL == ui_info) {

		ui_info = g_hash_table_new(g_str_hash, g_str_equal);

		g_hash_table_insert(ui_info, g_strdup("name"), g_strdup("Spectrum"));

		g_hash_table_insert(ui_info, g_strdup("version"), g_strdup("0.5"));

		g_hash_table_insert(ui_info, g_strdup("website"), g_strdup("http://spectrum.im"));

		g_hash_table_insert(ui_info, g_strdup("dev_website"), g_strdup("http://spectrum.im"));

		g_hash_table_insert(ui_info, g_strdup("client_type"), g_strdup("pc"));

		/*

		 * This is the client key for "Pidgin."  It is owned by the AIM

		 * account "markdoliner."  Please don't use this key for other

		 * applications.  You can either not specify a client key, in

		 * which case the default "libpurple" key will be used, or you

		 * can register for your own client key at

		 * http://developer.aim.com/manageKeys.jsp

		 */

		g_hash_table_insert(ui_info, g_strdup("prpl-aim-clientkey"), g_strdup("ma1cSASNCKFtrdv9"));

		g_hash_table_insert(ui_info, g_strdup("prpl-icq-clientkey"), g_strdup("ma1cSASNCKFtrdv9"));

		/*

		 * This is the distid for Pidgin, given to us by AOL.  Please

		 * don't use this for other applications.  You can just not

		 * specify a distid and libpurple will use a default.

		 */

		g_hash_table_insert(ui_info, g_strdup("prpl-aim-distid"), GINT_TO_POINTER(1550));

		g_hash_table_insert(ui_info, g_strdup("prpl-icq-distid"), GINT_TO_POINTER(1550));

	}

	return ui_info;

}

#ifndef WIN32

void spectrum_sigchld_handler(int sig)

{

	int status;

	pid_t pid;

	do {

		pid = waitpid(-1, &status, WNOHANG);

	} while (pid != 0 && pid != (pid_t)-1);

	if ((pid == (pid_t) - 1) && (errno != ECHILD)) {

		char errmsg[BUFSIZ];

		snprintf(errmsg, BUFSIZ, "Warning: waitpid() returned %d", pid);

		perror(errmsg);

	}

}

#endif

int create_socket(char *host, int portno) {

	struct sockaddr_in serv_addr;

	int main_socket = socket(AF_INET, SOCK_STREAM, 0);

	memset((char *) &serv_addr, 0, sizeof(serv_addr));

	serv_addr.sin_family = AF_INET;

	serv_addr.sin_port = htons(portno);

	hostent *hos;  // Resolve name

	if ((hos = gethostbyname(host)) == NULL) {

		// strerror() will not work for gethostbyname() and hstrerror() 

		// is supposedly obsolete

		exit(1);

	}

	serv_addr.sin_addr.s_addr = *((unsigned long *) hos->h_addr_list[0]);

	if (connect(main_socket, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {

		close(main_socket);

		main_socket = 0;

	}

	int flags = fcntl(main_socket, F_GETFL);

	flags |= O_NONBLOCK;

	fcntl(main_socket, F_SETFL, flags);

	return main_socket;

}

/**

 * libtransport -- C++ library for easy XMPP Transports development

 *

 * Copyright (C) 2011, Jan Kaluza <hanzz.k@gmail.com>

 *

 * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA

 */

#pragma once

#include "purple.h"

#ifndef WIN32

void spectrum_sigchld_handler(int sig);

#endif

int create_socket(char *host, int portno);