FTData *ftdata = (FTData *) xfer->ui_data;

	if (ftdata && ftdata->timer) {

		purple_timeout_remove_wrapped(ftdata->timer);

	}

	purple_xfer_unref_wrapped(xfer);

}

static gssize XferWrite(PurpleXfer *xfer, const guchar *buffer, gssize size) {

	FTData *ftData = (FTData *) xfer->ui_data;

	std::string data((const char *) buffer, (size_t) size);

// 	std::cout << "xferwrite\n";

	if (!ftData->paused) {

// 		std::cout << "adding xfer to waitingXfers queue\n";

		np->m_waitingXfers.push_back(xfer);

	}

	np->handleFTData(ftData->id, data);

	return size;

}

static void XferNotSent(PurpleXfer *xfer, const guchar *buffer, gsize size) {

// 	FiletransferRepeater *repeater = (FiletransferRepeater *) xfer->ui_data;

// 	repeater->handleDataNotSent(buffer, size);

}

static gssize XferRead(PurpleXfer *xfer, guchar **buffer, gssize size) {

// 	FiletransferRepeater *repeater = (FiletransferRepeater *) xfer->ui_data;

// 	int data_size = repeater->getDataToSend(buffer, size);

// 	if (data_size == 0)

// 		return 0;

// 	

// 	return data_size;

	return 0;

}

static PurpleXferUiOps xferUiOps =

{

	XferCreated,

	XferDestroyed,

	NULL,

	NULL,

	xferCanceled,

	xferCanceled,

	XferWrite,

	XferRead,

	XferNotSent,

	NULL

};

static void transport_core_ui_init(void)

{

	purple_blist_set_ui_ops_wrapped(&blistUiOps);

	purple_accounts_set_ui_ops_wrapped(&accountUiOps);

	purple_notify_set_ui_ops_wrapped(&notifyUiOps);

	purple_request_set_ui_ops_wrapped(&requestUiOps);

	purple_xfers_set_ui_ops_wrapped(&xferUiOps);

	purple_connections_set_ui_ops_wrapped(&conn_ui_ops);

	purple_conversations_set_ui_ops_wrapped(&conversation_ui_ops);

// #ifndef WIN32

// 	purple_dnsquery_set_ui_ops_wrapped(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_wrapped(message);

	if (domain != NULL)

		new_domain = purple_utf8_try_convert_wrapped(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");

	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

#if !defined(__FreeBSD__) && !defined(__APPLE__)

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

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

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

}

purple_blist_new_wrapped_fnc purple_blist_new_wrapped = NULL;

purple_blist_load_wrapped_fnc purple_blist_load_wrapped = NULL;

purple_blist_get_handle_wrapped_fnc purple_blist_get_handle_wrapped = NULL;

purple_buddy_icons_set_account_icon_wrapped_fnc purple_buddy_icons_set_account_icon_wrapped = NULL;

purple_buddy_icons_find_wrapped_fnc purple_buddy_icons_find_wrapped = NULL;

purple_buddy_icon_get_full_path_wrapped_fnc purple_buddy_icon_get_full_path_wrapped = NULL;

purple_buddy_icon_unref_wrapped_fnc purple_buddy_icon_unref_wrapped = NULL;

purple_buddy_icons_find_account_icon_wrapped_fnc purple_buddy_icons_find_account_icon_wrapped = NULL;

purple_buddy_icon_get_data_wrapped_fnc purple_buddy_icon_get_data_wrapped = NULL;

purple_certificate_add_ca_search_path_wrapped_fnc purple_certificate_add_ca_search_path_wrapped = NULL;

purple_connection_get_state_wrapped_fnc purple_connection_get_state_wrapped = NULL;

purple_connection_get_account_wrapped_fnc purple_connection_get_account_wrapped = NULL;

purple_connection_get_display_name_wrapped_fnc purple_connection_get_display_name_wrapped = NULL;

purple_connections_set_ui_ops_wrapped_fnc purple_connections_set_ui_ops_wrapped = NULL;

purple_connections_get_handle_wrapped_fnc purple_connections_get_handle_wrapped = NULL;

purple_conversation_get_im_data_wrapped_fnc purple_conversation_get_im_data_wrapped = NULL;

purple_conversation_get_chat_data_wrapped_fnc purple_conversation_get_chat_data_wrapped = NULL;

purple_find_conversation_with_account_wrapped_fnc purple_find_conversation_with_account_wrapped = NULL;

purple_conversation_new_wrapped_fnc purple_conversation_new_wrapped = NULL;

purple_conversation_get_type_wrapped_fnc purple_conversation_get_type_wrapped = NULL;

purple_conv_im_send_wrapped_fnc purple_conv_im_send_wrapped = NULL;

purple_conv_chat_send_wrapped_fnc purple_conv_chat_send_wrapped = NULL;

purple_conversation_destroy_wrapped_fnc purple_conversation_destroy_wrapped = NULL;

purple_conversation_get_account_wrapped_fnc purple_conversation_get_account_wrapped = NULL;

purple_conversation_get_name_wrapped_fnc purple_conversation_get_name_wrapped = NULL;

purple_conversations_set_ui_ops_wrapped_fnc purple_conversations_set_ui_ops_wrapped = NULL;

purple_conversations_get_handle_wrapped_fnc purple_conversations_get_handle_wrapped = NULL;

purple_core_set_ui_ops_wrapped_fnc purple_core_set_ui_ops_wrapped = NULL;

purple_core_init_wrapped_fnc purple_core_init_wrapped = NULL;

purple_debug_set_ui_ops_wrapped_fnc purple_debug_set_ui_ops_wrapped = NULL;

purple_debug_set_verbose_wrapped_fnc purple_debug_set_verbose_wrapped = NULL;

purple_dnsquery_set_ui_ops_wrapped_fnc purple_dnsquery_set_ui_ops_wrapped = NULL;

purple_timeout_remove_wrapped_fnc purple_timeout_remove_wrapped = NULL;

purple_input_add_wrapped_fnc purple_input_add_wrapped = NULL;

purple_timeout_add_wrapped_fnc purple_timeout_add_wrapped = NULL;

purple_timeout_add_seconds_wrapped_fnc purple_timeout_add_seconds_wrapped = NULL;

purple_eventloop_set_ui_ops_wrapped_fnc purple_eventloop_set_ui_ops_wrapped = NULL;

purple_input_remove_wrapped_fnc purple_input_remove_wrapped = NULL;

purple_xfer_ui_ready_wrapped_fnc purple_xfer_ui_ready_wrapped = NULL;

purple_xfer_request_accepted_wrapped_fnc purple_xfer_request_accepted_wrapped = NULL;

purple_xfer_request_denied_wrapped_fnc purple_xfer_request_denied_wrapped = NULL;

purple_xfer_get_account_wrapped_fnc purple_xfer_get_account_wrapped = NULL;

purple_xfer_get_filename_wrapped_fnc purple_xfer_get_filename_wrapped = NULL;

purple_xfer_get_size_wrapped_fnc purple_xfer_get_size_wrapped = NULL;

purple_xfer_unref_wrapped_fnc purple_xfer_unref_wrapped = NULL;

purple_xfer_ref_wrapped_fnc purple_xfer_ref_wrapped = NULL;

purple_xfers_set_ui_ops_wrapped_fnc purple_xfers_set_ui_ops_wrapped = NULL;

purple_xfers_get_handle_wrapped_fnc purple_xfers_get_handle_wrapped = NULL;

purple_imgstore_get_data_wrapped_fnc purple_imgstore_get_data_wrapped = NULL;

purple_imgstore_get_size_wrapped_fnc purple_imgstore_get_size_wrapped = NULL;

purple_imgstore_unref_wrapped_fnc purple_imgstore_unref_wrapped = NULL;

purple_notify_user_info_new_wrapped_fnc purple_notify_user_info_new_wrapped = NULL;

purple_notify_user_info_destroy_wrapped_fnc purple_notify_user_info_destroy_wrapped = NULL;

purple_notify_user_info_get_entries_wrapped_fnc purple_notify_user_info_get_entries_wrapped = NULL;

purple_notify_user_info_entry_get_label_wrapped_fnc purple_notify_user_info_entry_get_label_wrapped = NULL;

purple_notify_user_info_entry_get_value_wrapped_fnc purple_notify_user_info_entry_get_value_wrapped = NULL;

purple_notify_set_ui_ops_wrapped_fnc purple_notify_set_ui_ops_wrapped = NULL;

purple_plugins_add_search_path_wrapped_fnc purple_plugins_add_search_path_wrapped = NULL;

purple_plugin_action_free_wrapped_fnc purple_plugin_action_free_wrapped = NULL;

purple_prefs_load_wrapped_fnc purple_prefs_load_wrapped = NULL;

purple_prefs_set_bool_wrapped_fnc purple_prefs_set_bool_wrapped = NULL;

purple_prefs_set_string_wrapped_fnc purple_prefs_set_string_wrapped = NULL;

purple_privacy_deny_wrapped_fnc purple_privacy_deny_wrapped = NULL;

purple_privacy_allow_wrapped_fnc purple_privacy_allow_wrapped = NULL;

purple_privacy_check_wrapped_fnc purple_privacy_check_wrapped = NULL;

purple_proxy_info_new_wrapped_fnc purple_proxy_info_new_wrapped = NULL;

purple_proxy_info_set_type_wrapped_fnc purple_proxy_info_set_type_wrapped = NULL;

purple_proxy_info_set_host_wrapped_fnc purple_proxy_info_set_host_wrapped = NULL;

purple_proxy_info_set_port_wrapped_fnc purple_proxy_info_set_port_wrapped = NULL;

purple_proxy_info_set_username_wrapped_fnc purple_proxy_info_set_username_wrapped = NULL;

purple_proxy_info_set_password_wrapped_fnc purple_proxy_info_set_password_wrapped = NULL;

purple_find_prpl_wrapped_fnc purple_find_prpl_wrapped = NULL;

purple_prpl_send_attention_wrapped_fnc purple_prpl_send_attention_wrapped = NULL;

purple_request_set_ui_ops_wrapped_fnc purple_request_set_ui_ops_wrapped = NULL;

serv_get_info_wrapped_fnc serv_get_info_wrapped = NULL;

serv_alias_buddy_wrapped_fnc serv_alias_buddy_wrapped = NULL;

serv_send_typing_wrapped_fnc serv_send_typing_wrapped = NULL;

serv_join_chat_wrapped_fnc serv_join_chat_wrapped = NULL;

purple_signal_connect_wrapped_fnc purple_signal_connect_wrapped = NULL;

purple_status_type_get_id_wrapped_fnc purple_status_type_get_id_wrapped = NULL;

purple_presence_get_active_status_wrapped_fnc purple_presence_get_active_status_wrapped = NULL;

purple_status_type_get_primitive_wrapped_fnc purple_status_type_get_primitive_wrapped = NULL;

purple_status_get_type_wrapped_fnc purple_status_get_type_wrapped = NULL;

purple_status_get_attr_string_wrapped_fnc purple_status_get_attr_string_wrapped = NULL;

purple_markup_escape_text_wrapped_fnc purple_markup_escape_text_wrapped = NULL;

purple_markup_strip_html_wrapped_fnc purple_markup_strip_html_wrapped = NULL;

purple_strdup_withhtml_wrapped_fnc purple_strdup_withhtml_wrapped = NULL;

purple_markup_html_to_xhtml_wrapped_fnc purple_markup_html_to_xhtml_wrapped = NULL;

purple_normalize_wrapped_fnc purple_normalize_wrapped = NULL;

purple_utf8_try_convert_wrapped_fnc purple_utf8_try_convert_wrapped = NULL;

purple_util_set_user_dir_wrapped_fnc purple_util_set_user_dir_wrapped = NULL;

wpurple_g_io_channel_win32_new_socket_wrapped_fnc wpurple_g_io_channel_win32_new_socket_wrapped = NULL;

#endif

bool resolvePurpleFunctions() {

#if PURPLE_RUNTIME

	f_hPurple = LoadLibrary(L"libpurple.dll");

	purple_eventloop_set_ui_ops_wrapped = (purple_eventloop_set_ui_ops_wrapped_fnc)GetProcAddress(f_hPurple, "purple_eventloop_set_ui_ops");

	if (!purple_eventloop_set_ui_ops_wrapped)

		return false;

	purple_input_remove_wrapped = (purple_input_remove_wrapped_fnc)GetProcAddress(f_hPurple, "purple_input_remove");

	if (!purple_input_remove_wrapped)

		return false;

	purple_xfer_ui_ready_wrapped = (purple_xfer_ui_ready_wrapped_fnc)GetProcAddress(f_hPurple, "purple_xfer_ui_ready");

	if (!purple_xfer_ui_ready_wrapped)

		return false;

	purple_xfer_request_accepted_wrapped = (purple_xfer_request_accepted_wrapped_fnc)GetProcAddress(f_hPurple, "purple_xfer_request_accepted");

	if (!purple_xfer_request_accepted_wrapped)

		return false;

	purple_xfer_request_denied_wrapped = (purple_xfer_request_denied_wrapped_fnc)GetProcAddress(f_hPurple, "purple_xfer_request_denied");

	if (!purple_xfer_request_denied_wrapped)

		return false;

	purple_xfer_get_account_wrapped = (purple_xfer_get_account_wrapped_fnc)GetProcAddress(f_hPurple, "purple_xfer_get_account");

	if (!purple_xfer_get_account_wrapped)

		return false;

	purple_xfer_get_filename_wrapped = (purple_xfer_get_filename_wrapped_fnc)GetProcAddress(f_hPurple, "purple_xfer_get_filename");

	if (!purple_xfer_get_filename_wrapped)

		return false;

	purple_xfer_get_size_wrapped = (purple_xfer_get_size_wrapped_fnc)GetProcAddress(f_hPurple, "purple_xfer_get_size");

	if (!purple_xfer_get_size_wrapped)

		return false;

	purple_xfer_unref_wrapped = (purple_xfer_unref_wrapped_fnc)GetProcAddress(f_hPurple, "purple_xfer_unref");

	if (!purple_xfer_unref_wrapped)

		return false;

	purple_xfer_ref_wrapped = (purple_xfer_ref_wrapped_fnc)GetProcAddress(f_hPurple, "purple_xfer_ref");

	if (!purple_xfer_ref_wrapped)

		return false;

	purple_xfers_set_ui_ops_wrapped = (purple_xfers_set_ui_ops_wrapped_fnc)GetProcAddress(f_hPurple, "purple_xfers_set_ui_ops");

	if (!purple_xfers_set_ui_ops_wrapped)

		return false;

	purple_xfers_get_handle_wrapped = (purple_xfers_get_handle_wrapped_fnc)GetProcAddress(f_hPurple, "purple_xfers_get_handle");

	if (!purple_xfers_get_handle_wrapped)

		return false;

	purple_imgstore_get_data_wrapped = (purple_imgstore_get_data_wrapped_fnc)GetProcAddress(f_hPurple, "purple_imgstore_get_data");

	if (!purple_imgstore_get_data_wrapped)

		return false;

	purple_imgstore_get_size_wrapped = (purple_imgstore_get_size_wrapped_fnc)GetProcAddress(f_hPurple, "purple_imgstore_get_size");

	if (!purple_imgstore_get_size_wrapped)

		return false;

	purple_imgstore_unref_wrapped = (purple_imgstore_unref_wrapped_fnc)GetProcAddress(f_hPurple, "purple_imgstore_unref");

	if (!purple_imgstore_unref_wrapped)

		return false;

	purple_notify_user_info_new_wrapped = (purple_notify_user_info_new_wrapped_fnc)GetProcAddress(f_hPurple, "purple_notify_user_info_new");

	if (!purple_notify_user_info_new_wrapped)

		return false;

	purple_notify_user_info_destroy_wrapped = (purple_notify_user_info_destroy_wrapped_fnc)GetProcAddress(f_hPurple, "purple_notify_user_info_destroy");

	if (!purple_notify_user_info_destroy_wrapped)

		return false;

	purple_notify_user_info_get_entries_wrapped = (purple_notify_user_info_get_entries_wrapped_fnc)GetProcAddress(f_hPurple, "purple_notify_user_info_get_entries");

	if (!purple_notify_user_info_get_entries_wrapped)

		return false;

	purple_notify_user_info_entry_get_label_wrapped = (purple_notify_user_info_entry_get_label_wrapped_fnc)GetProcAddress(f_hPurple, "purple_notify_user_info_entry_get_label");

	if (!purple_notify_user_info_entry_get_label_wrapped)

		return false;

	purple_notify_user_info_entry_get_value_wrapped = (purple_notify_user_info_entry_get_value_wrapped_fnc)GetProcAddress(f_hPurple, "purple_notify_user_info_entry_get_value");

	if (!purple_notify_user_info_entry_get_value_wrapped)

		return false;

	purple_notify_set_ui_ops_wrapped = (purple_notify_set_ui_ops_wrapped_fnc)GetProcAddress(f_hPurple, "purple_notify_set_ui_ops");

	if (!purple_notify_set_ui_ops_wrapped)

		return false;

	purple_plugins_add_search_path_wrapped = (purple_plugins_add_search_path_wrapped_fnc)GetProcAddress(f_hPurple, "purple_plugins_add_search_path");

	if (!purple_plugins_add_search_path_wrapped)

		return false;

	purple_plugin_action_free_wrapped = (purple_plugin_action_free_wrapped_fnc)GetProcAddress(f_hPurple, "purple_plugin_action_free");

	if (!purple_plugin_action_free_wrapped)

		return false;

	purple_prefs_load_wrapped = (purple_prefs_load_wrapped_fnc)GetProcAddress(f_hPurple, "purple_prefs_load");

	if (!purple_prefs_load_wrapped)

		return false;

typedef gboolean  (_cdecl * purple_timeout_remove_wrapped_fnc)(guint handle);

extern purple_timeout_remove_wrapped_fnc purple_timeout_remove_wrapped;

typedef guint  (_cdecl * purple_input_add_wrapped_fnc)(int fd, PurpleInputCondition cond, PurpleInputFunction func, gpointer user_data);

extern purple_input_add_wrapped_fnc purple_input_add_wrapped;

typedef guint  (_cdecl * purple_timeout_add_wrapped_fnc)(guint interval, GSourceFunc function, gpointer data);

extern purple_timeout_add_wrapped_fnc purple_timeout_add_wrapped;

typedef guint  (_cdecl * purple_timeout_add_seconds_wrapped_fnc)(guint interval, GSourceFunc function, gpointer data);

extern purple_timeout_add_seconds_wrapped_fnc purple_timeout_add_seconds_wrapped;

typedef void  (_cdecl * purple_eventloop_set_ui_ops_wrapped_fnc)(PurpleEventLoopUiOps *ops);

extern purple_eventloop_set_ui_ops_wrapped_fnc purple_eventloop_set_ui_ops_wrapped;

typedef gboolean  (_cdecl * purple_input_remove_wrapped_fnc)(guint handle);

extern purple_input_remove_wrapped_fnc purple_input_remove_wrapped;

typedef void  (_cdecl * purple_xfer_ui_ready_wrapped_fnc)(PurpleXfer *xfer);

extern purple_xfer_ui_ready_wrapped_fnc purple_xfer_ui_ready_wrapped;

typedef void  (_cdecl * purple_xfer_request_accepted_wrapped_fnc)(PurpleXfer *xfer, const char *filename);

extern purple_xfer_request_accepted_wrapped_fnc purple_xfer_request_accepted_wrapped;

typedef void  (_cdecl * purple_xfer_request_denied_wrapped_fnc)(PurpleXfer *xfer);

extern purple_xfer_request_denied_wrapped_fnc purple_xfer_request_denied_wrapped;

typedef PurpleAccount * (_cdecl * purple_xfer_get_account_wrapped_fnc)(const PurpleXfer *xfer);

extern purple_xfer_get_account_wrapped_fnc purple_xfer_get_account_wrapped;

typedef const char * (_cdecl * purple_xfer_get_filename_wrapped_fnc)(const PurpleXfer *xfer);

extern purple_xfer_get_filename_wrapped_fnc purple_xfer_get_filename_wrapped;

typedef size_t  (_cdecl * purple_xfer_get_size_wrapped_fnc)(const PurpleXfer *xfer);

extern purple_xfer_get_size_wrapped_fnc purple_xfer_get_size_wrapped;

typedef void  (_cdecl * purple_xfer_unref_wrapped_fnc)(PurpleXfer *xfer);

extern purple_xfer_unref_wrapped_fnc purple_xfer_unref_wrapped;

typedef void  (_cdecl * purple_xfer_ref_wrapped_fnc)(PurpleXfer *xfer);

extern purple_xfer_ref_wrapped_fnc purple_xfer_ref_wrapped;

typedef void  (_cdecl * purple_xfers_set_ui_ops_wrapped_fnc)(PurpleXferUiOps *ops);

extern purple_xfers_set_ui_ops_wrapped_fnc purple_xfers_set_ui_ops_wrapped;

typedef void * (_cdecl * purple_xfers_get_handle_wrapped_fnc)(void);

extern purple_xfers_get_handle_wrapped_fnc purple_xfers_get_handle_wrapped;

typedef gconstpointer  (_cdecl * purple_imgstore_get_data_wrapped_fnc)(PurpleStoredImage *img);

extern purple_imgstore_get_data_wrapped_fnc purple_imgstore_get_data_wrapped;

typedef size_t  (_cdecl * purple_imgstore_get_size_wrapped_fnc)(PurpleStoredImage *img);

extern purple_imgstore_get_size_wrapped_fnc purple_imgstore_get_size_wrapped;

typedef PurpleStoredImage * (_cdecl * purple_imgstore_unref_wrapped_fnc)(PurpleStoredImage *img);

extern purple_imgstore_unref_wrapped_fnc purple_imgstore_unref_wrapped;

typedef PurpleNotifyUserInfo * (_cdecl * purple_notify_user_info_new_wrapped_fnc)(void);

extern purple_notify_user_info_new_wrapped_fnc purple_notify_user_info_new_wrapped;

typedef void  (_cdecl * purple_notify_user_info_destroy_wrapped_fnc)(PurpleNotifyUserInfo *user_info);

extern purple_notify_user_info_destroy_wrapped_fnc purple_notify_user_info_destroy_wrapped;

typedef GList * (_cdecl * purple_notify_user_info_get_entries_wrapped_fnc)(PurpleNotifyUserInfo *user_info);

extern purple_notify_user_info_get_entries_wrapped_fnc purple_notify_user_info_get_entries_wrapped;

typedef const gchar * (_cdecl * purple_notify_user_info_entry_get_label_wrapped_fnc)(PurpleNotifyUserInfoEntry *user_info_entry);

extern purple_notify_user_info_entry_get_label_wrapped_fnc purple_notify_user_info_entry_get_label_wrapped;

typedef const gchar * (_cdecl * purple_notify_user_info_entry_get_value_wrapped_fnc)(PurpleNotifyUserInfoEntry *user_info_entry);

extern purple_notify_user_info_entry_get_value_wrapped_fnc purple_notify_user_info_entry_get_value_wrapped;

typedef void  (_cdecl * purple_notify_set_ui_ops_wrapped_fnc)(PurpleNotifyUiOps *ops);

extern purple_notify_set_ui_ops_wrapped_fnc purple_notify_set_ui_ops_wrapped;

typedef void  (_cdecl * purple_plugins_add_search_path_wrapped_fnc)(const char *path);

extern purple_plugins_add_search_path_wrapped_fnc purple_plugins_add_search_path_wrapped;

typedef void  (_cdecl * purple_plugin_action_free_wrapped_fnc)(PurplePluginAction *action);

extern purple_plugin_action_free_wrapped_fnc purple_plugin_action_free_wrapped;

typedef gboolean  (_cdecl * purple_prefs_load_wrapped_fnc)(void);

extern purple_prefs_load_wrapped_fnc purple_prefs_load_wrapped;

typedef void  (_cdecl * purple_prefs_set_bool_wrapped_fnc)(const char *name, gboolean value);

extern purple_prefs_set_bool_wrapped_fnc purple_prefs_set_bool_wrapped;

typedef void  (_cdecl * purple_prefs_set_string_wrapped_fnc)(const char *name, const char *value);

extern purple_prefs_set_string_wrapped_fnc purple_prefs_set_string_wrapped;

typedef void  (_cdecl * purple_privacy_deny_wrapped_fnc)(PurpleAccount *account, const char *who, gboolean local, gboolean restore);

extern purple_privacy_deny_wrapped_fnc purple_privacy_deny_wrapped;

typedef void  (_cdecl * purple_privacy_allow_wrapped_fnc)(PurpleAccount *account, const char *who, gboolean local, gboolean restore);

extern purple_privacy_allow_wrapped_fnc purple_privacy_allow_wrapped;

#define purple_blist_get_handle_wrapped purple_blist_get_handle

#define purple_buddy_icons_set_account_icon_wrapped purple_buddy_icons_set_account_icon

#define purple_buddy_icons_find_wrapped purple_buddy_icons_find

#define purple_buddy_icon_get_full_path_wrapped purple_buddy_icon_get_full_path

#define purple_buddy_icon_unref_wrapped purple_buddy_icon_unref

#define purple_buddy_icons_find_account_icon_wrapped purple_buddy_icons_find_account_icon

#define purple_buddy_icon_get_data_wrapped purple_buddy_icon_get_data

#define purple_certificate_add_ca_search_path_wrapped purple_certificate_add_ca_search_path

#define purple_connection_get_state_wrapped purple_connection_get_state

#define purple_connection_get_account_wrapped purple_connection_get_account

#define purple_connection_get_display_name_wrapped purple_connection_get_display_name

#define purple_connections_set_ui_ops_wrapped purple_connections_set_ui_ops

#define purple_connections_get_handle_wrapped purple_connections_get_handle

#define purple_conversation_get_im_data_wrapped purple_conversation_get_im_data

#define purple_conversation_get_chat_data_wrapped purple_conversation_get_chat_data

#define purple_find_conversation_with_account_wrapped purple_find_conversation_with_account

#define purple_conversation_new_wrapped purple_conversation_new

#define purple_conversation_get_type_wrapped purple_conversation_get_type

#define purple_conversation_set_data_wrapped purple_conversation_set_data

#define purple_conversation_update_wrapped purple_conversation_update

#define purple_conv_im_send_wrapped purple_conv_im_send

#define purple_conv_chat_send_wrapped purple_conv_chat_send

#define purple_conversation_destroy_wrapped purple_conversation_destroy

#define purple_conversation_get_account_wrapped purple_conversation_get_account

#define purple_conversation_get_name_wrapped purple_conversation_get_name

#define purple_conversations_set_ui_ops_wrapped purple_conversations_set_ui_ops

#define purple_conversations_get_handle_wrapped purple_conversations_get_handle

#define purple_core_set_ui_ops_wrapped purple_core_set_ui_ops

#define purple_core_init_wrapped purple_core_init

#define purple_debug_set_ui_ops_wrapped purple_debug_set_ui_ops

#define purple_debug_set_verbose_wrapped purple_debug_set_verbose

#define purple_dnsquery_set_ui_ops_wrapped purple_dnsquery_set_ui_ops

#define purple_timeout_remove_wrapped purple_timeout_remove

#define purple_input_add_wrapped purple_input_add

#define purple_timeout_add_wrapped purple_timeout_add

#define purple_timeout_add_seconds_wrapped purple_timeout_add_seconds

#define purple_eventloop_set_ui_ops_wrapped purple_eventloop_set_ui_ops

#define purple_input_remove_wrapped purple_input_remove

#define purple_xfer_ui_ready_wrapped purple_xfer_ui_ready

#define purple_xfer_request_accepted_wrapped purple_xfer_request_accepted

#define purple_xfer_request_denied_wrapped purple_xfer_request_denied

#define purple_xfer_get_account_wrapped purple_xfer_get_account

#define purple_xfer_get_filename_wrapped purple_xfer_get_filename

#define purple_xfer_get_size_wrapped purple_xfer_get_size

#define purple_xfer_unref_wrapped purple_xfer_unref

#define purple_xfer_ref_wrapped purple_xfer_ref

#define purple_xfers_set_ui_ops_wrapped purple_xfers_set_ui_ops

#define purple_xfers_get_handle_wrapped purple_xfers_get_handle

#define purple_imgstore_get_data_wrapped purple_imgstore_get_data

#define purple_imgstore_get_size_wrapped purple_imgstore_get_size

#define purple_imgstore_unref_wrapped purple_imgstore_unref

#define purple_notify_user_info_new_wrapped purple_notify_user_info_new

#define purple_notify_user_info_destroy_wrapped purple_notify_user_info_destroy

#define purple_notify_user_info_get_entries_wrapped purple_notify_user_info_get_entries

#define purple_notify_user_info_entry_get_label_wrapped purple_notify_user_info_entry_get_label

#define purple_notify_user_info_entry_get_value_wrapped purple_notify_user_info_entry_get_value

#define purple_notify_set_ui_ops_wrapped purple_notify_set_ui_ops

#define purple_plugins_add_search_path_wrapped purple_plugins_add_search_path

#define purple_plugin_action_free_wrapped purple_plugin_action_free

#define purple_prefs_load_wrapped purple_prefs_load

#define purple_prefs_set_bool_wrapped purple_prefs_set_bool

#define purple_prefs_set_string_wrapped purple_prefs_set_string

#define purple_privacy_deny_wrapped purple_privacy_deny

#define purple_privacy_allow_wrapped purple_privacy_allow

#define purple_privacy_check_wrapped purple_privacy_check

#define purple_proxy_info_new_wrapped purple_proxy_info_new

#define purple_proxy_info_set_type_wrapped purple_proxy_info_set_type

#define purple_proxy_info_set_host_wrapped purple_proxy_info_set_host

#define purple_proxy_info_set_port_wrapped purple_proxy_info_set_port

#define purple_proxy_info_set_username_wrapped purple_proxy_info_set_username

#define purple_proxy_info_set_password_wrapped purple_proxy_info_set_password

#define purple_find_prpl_wrapped purple_find_prpl

#define purple_prpl_send_attention_wrapped purple_prpl_send_attention

#define purple_request_set_ui_ops_wrapped purple_request_set_ui_ops

#define serv_get_info_wrapped serv_get_info

#define serv_alias_buddy_wrapped serv_alias_buddy

#define serv_send_typing_wrapped serv_send_typing

#define serv_join_chat_wrapped serv_join_chat

#define purple_signal_connect_wrapped purple_signal_connect

#define purple_status_type_get_id_wrapped purple_status_type_get_id

#define purple_presence_get_active_status_wrapped purple_presence_get_active_status

#define purple_status_type_get_primitive_wrapped purple_status_type_get_primitive

#define purple_status_get_type_wrapped purple_status_get_type

#define purple_status_get_attr_string_wrapped purple_status_get_attr_string

#define purple_markup_escape_text_wrapped purple_markup_escape_text

#define purple_markup_strip_html_wrapped purple_markup_strip_html

#define purple_strdup_withhtml_wrapped purple_strdup_withhtml

#define purple_markup_html_to_xhtml_wrapped purple_markup_html_to_xhtml

#define purple_normalize_wrapped purple_normalize

#define purple_utf8_try_convert_wrapped purple_utf8_try_convert

#define purple_util_set_user_dir_wrapped purple_util_set_user_dir

#define wpurple_g_io_channel_win32_new_socket_wrapped wpurple_g_io_channel_win32_new_socket

#endif

bool resolvePurpleFunctions();

void DiscoInfoResponder::addRoom(const std::string &jid, const std::string &name) {

	std::string j = jid;

	boost::algorithm::to_lower(j);

	m_rooms[j] = name;

}

void DiscoInfoResponder::clearRooms() {

	m_rooms.clear();

}

void DiscoInfoResponder::addAdHocCommand(const std::string &node, const std::string &name) {

	m_commands[node] = node;

}

bool DiscoInfoResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::DiscoInfo> info) {

	// disco#info for transport

	if (to.getNode().empty()) {

		// Adhoc command

		if (m_commands.find(info->getNode()) != m_commands.end()) {

			boost::shared_ptr<DiscoInfo> res(new DiscoInfo());

			res->addFeature("http://jabber.org/protocol/commands");

			res->addFeature("jabber:x:data");

			res->addIdentity(DiscoInfo::Identity(m_commands[info->getNode()], "automation", "command-node"));

			res->setNode(info->getNode());

			sendResponse(from, to, id, res);

		}

		else if (info->getNode() == "http://jabber.org/protocol/commands") {

			boost::shared_ptr<DiscoInfo> res(new DiscoInfo());

			res->addIdentity(DiscoInfo::Identity("Commands", "automation", "command-list"));

			res->setNode(info->getNode());

			sendResponse(from, to, id, res);

		}

		else {

			if (!info->getNode().empty()) {

				sendError(from, id, ErrorPayload::ItemNotFound, ErrorPayload::Cancel);

				return true;

			}

			boost::shared_ptr<DiscoInfo> res(new DiscoInfo(m_transportInfo));

			res->setNode(info->getNode());

			sendResponse(from, id, res);

		}

	}

	// disco#info for room

	else if (m_rooms.find(to.toBare().toString()) != m_rooms.end()) {

		boost::shared_ptr<DiscoInfo> res(new DiscoInfo());

		res->addIdentity(DiscoInfo::Identity(m_rooms[to.toBare().toString()], "conference", "text"));

		res->setNode(info->getNode());

		sendResponse(from, to, id, res);

	}

	// disco#info for buddy

	else {

		boost::shared_ptr<DiscoInfo> res(new DiscoInfo(*m_buddyInfo));

		res->setNode(info->getNode());

		sendResponse(from, to, id, res);

	}

	return true;

}

}