diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2f65f3b3..e3362d64 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -12,6 +12,7 @@ message(STATUS "|- boost   : -DBOOST_INCLUDEDIR,     -DBOOST_LIBRARYDIR")
 message(STATUS "|- protobuf: -DPROTOBUF_INCLUDE_DIR, -DPROTOBUF_LIBRARY")
 message(STATUS "|- log4cxx : -DLOG4CXX_INCLUDE_DIR,  -DLOG4CXX_LIBRARY")
 message(STATUS "|- purple  : -DPURPLE_INCLUDE_DIR,   -DPURPLE_LIBRARY")
+message(STATUS "|- glib2   : -DGLIB2_INCLUDE_DIR,    -DGLIB2_LIBRARIES")
 
 if(NOT LIB_INSTALL_DIR)
 	set(LIB_INSTALL_DIR "lib")
@@ -54,8 +55,12 @@ else()
 endif()
 
 # FIND GLIB
-set(glib_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
-find_package(glib)
+if (GLIB2_INCLUDE_DIR AND GLIB2_LIBRARIES)
+	set(GLIB2_FOUND TRUE)
+else()
+	set(glib_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
+	find_package(glib)
+endif()
 
 # FIND LIBXML2
 # set(libxml2_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
diff --git a/backends/libpurple/geventloop.cpp b/backends/libpurple/geventloop.cpp
index bccf4b38..7e299d7c 100644
--- a/backends/libpurple/geventloop.cpp
+++ b/backends/libpurple/geventloop.cpp
@@ -98,7 +98,7 @@ static guint input_add(gint fd,
 	}
 
 #ifdef WIN32
-	channel = wpurple_g_io_channel_win32_new_socket(fd);
+	channel = wpurple_g_io_channel_win32_new_socket_wrapped(fd);
 #else
 	channel = g_io_channel_unix_new(fd);
 #endif
diff --git a/backends/libpurple/main.cpp b/backends/libpurple/main.cpp
index c3d1d911..db76217f 100644
--- a/backends/libpurple/main.cpp
+++ b/backends/libpurple/main.cpp
@@ -88,7 +88,7 @@ static gboolean ft_ui_ready(void *data) {
 	PurpleXfer *xfer = (PurpleXfer *) data;
 	FTData *ftdata = (FTData *) xfer->ui_data;
 	ftdata->timer = 0;
-	purple_xfer_ui_ready((PurpleXfer *) data);
+	purple_xfer_ui_ready_wrapped((PurpleXfer *) data);
 	return FALSE;
 }
 
@@ -166,11 +166,11 @@ static std::string getAlias(PurpleBuddy *m_buddy) {
 	if (contact && contact->alias) {
 		alias = contact->alias;
 	}
-	else if (purple_buddy_get_alias(m_buddy)) {
-		alias = (std::string) purple_buddy_get_alias(m_buddy);
+	else if (purple_buddy_get_alias_wrapped(m_buddy)) {
+		alias = (std::string) purple_buddy_get_alias_wrapped(m_buddy);
 	}
 	else {
-		alias = (std::string) purple_buddy_get_server_alias(m_buddy);
+		alias = (std::string) purple_buddy_get_server_alias_wrapped(m_buddy);
 	}
 	return alias;
 }
@@ -210,7 +210,7 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 			}
 
 			if (ret) {
-				purple_buddy_icons_set_account_icon(account, (guchar *) contents, length);
+				purple_buddy_icons_set_account_icon_wrapped(account, (guchar *) contents, length);
 			}
 		}
 
@@ -224,16 +224,16 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 				std::string strippedKey = boost::erase_first_copy(key, "purple.");
 
 				if (strippedKey == "fb_api_key" || strippedKey == "fb_api_secret") {
-					purple_account_set_bool(account, "auth_fb", TRUE);
+					purple_account_set_bool_wrapped(account, "auth_fb", TRUE);
  				}
 
-				PurplePlugin *plugin = purple_find_prpl(purple_account_get_protocol_id(account));
+				PurplePlugin *plugin = purple_find_prpl_wrapped(purple_account_get_protocol_id_wrapped(account));
 				PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(plugin);
 				bool found = false;
 				for (GList *l = prpl_info->protocol_options; l != NULL; l = l->next) {
 					PurpleAccountOption *option = (PurpleAccountOption *) l->data;
-					PurplePrefType type = purple_account_option_get_type(option);
-					std::string key2(purple_account_option_get_setting(option));
+					PurplePrefType type = purple_account_option_get_type_wrapped(option);
+					std::string key2(purple_account_option_get_setting_wrapped(option));
 					if (strippedKey != key2) {
 						continue;
 					}
@@ -241,16 +241,16 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 					found = true;
 					switch (type) {
 						case PURPLE_PREF_BOOLEAN:
-							purple_account_set_bool(account, strippedKey.c_str(), fromString<bool>(keyItem.second.as<std::string>()));
+							purple_account_set_bool_wrapped(account, strippedKey.c_str(), fromString<bool>(keyItem.second.as<std::string>()));
 							break;
 
 						case PURPLE_PREF_INT:
-							purple_account_set_int(account, strippedKey.c_str(), fromString<int>(keyItem.second.as<std::string>()));
+							purple_account_set_int_wrapped(account, strippedKey.c_str(), fromString<int>(keyItem.second.as<std::string>()));
 							break;
 
 						case PURPLE_PREF_STRING:
 						case PURPLE_PREF_STRING_LIST:
-							purple_account_set_string(account, strippedKey.c_str(), keyItem.second.as<std::string>().c_str());
+							purple_account_set_string_wrapped(account, strippedKey.c_str(), keyItem.second.as<std::string>().c_str());
 							break;
 						default:
 							continue;
@@ -259,7 +259,7 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 				}
 
 				if (!found) {
-					purple_account_set_string(account, strippedKey.c_str(), keyItem.second.as<std::string>().c_str());
+					purple_account_set_string_wrapped(account, strippedKey.c_str(), keyItem.second.as<std::string>().c_str());
 				}
 				i++;
 			}
@@ -268,17 +268,17 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 			gsize length;
 			gboolean ret = g_file_get_contents ("gfire.cfg", &contents, &length, NULL);
 			if (ret) {
-				purple_account_set_int(account, "version", fromString<int>(std::string(contents, length)));
+				purple_account_set_int_wrapped(account, "version", fromString<int>(std::string(contents, length)));
 			}
 
 
 			if (CONFIG_STRING(config, "service.protocol") == "prpl-novell") {
-				std::string username(purple_account_get_username(account));
+				std::string username(purple_account_get_username_wrapped(account));
 				std::vector <std::string> u = split(username, '@');
-				purple_account_set_username(account, (const char*) u.front().c_str());
+				purple_account_set_username_wrapped(account, (const char*) u.front().c_str());
 				std::vector <std::string> s = split(u.back(), ':'); 
-				purple_account_set_string(account, "server", s.front().c_str());
-				purple_account_set_int(account, "port", atoi(s.back().c_str()));  
+				purple_account_set_string_wrapped(account, "server", s.front().c_str());
+				purple_account_set_int_wrapped(account, "port", atoi(s.back().c_str()));  
 			}
 
 		}
@@ -296,14 +296,14 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 				return;
 			}
 
-			if (!purple_find_prpl(protocol.c_str())) {
+			if (!purple_find_prpl_wrapped(protocol.c_str())) {
 				LOG4CXX_INFO(logger,  name.c_str() << ": Invalid protocol '" << protocol << "'");
 				np->handleDisconnected(user, 0, "Invalid protocol " + protocol);
 				return;
 			}
 
-			if (purple_accounts_find(name.c_str(), protocol.c_str()) != NULL) {
-				account = purple_accounts_find(name.c_str(), protocol.c_str());
+			if (purple_accounts_find_wrapped(name.c_str(), protocol.c_str()) != NULL) {
+				account = purple_accounts_find_wrapped(name.c_str(), protocol.c_str());
 				if (m_accounts.find(account) != m_accounts.end() && m_accounts[account] != user) {
 					LOG4CXX_INFO(logger, "Account '" << name << "' is already used by '" << m_accounts[account] << "'");
 					np->handleDisconnected(user, 0, "Account '" + name + "' is already used by '" + m_accounts[account] + "'");
@@ -313,8 +313,8 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 			}
 			else {
 				LOG4CXX_INFO(logger, "Creating account with name '" << name.c_str() << "' and protocol '" << protocol << "'");
-				account = purple_account_new(name.c_str(), protocol.c_str());
-				purple_accounts_add(account);
+				account = purple_account_new_wrapped(name.c_str(), protocol.c_str());
+				purple_accounts_add_wrapped(account);
 			}
 
 			m_sessions[user] = account;
@@ -323,40 +323,40 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 			// Default avatar
 			setDefaultAvatar(account, legacyName);
 
-			purple_account_set_password(account, password.c_str());
-			purple_account_set_bool(account, "custom_smileys", FALSE);
-			purple_account_set_bool(account, "direct_connect", FALSE);
+			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(account, "spectrum", TRUE);
+			purple_account_set_enabled_wrapped(account, "spectrum", TRUE);
 			if (CONFIG_BOOL(config, "service.enable_privacy_lists")) {
-				purple_account_set_privacy_type(account, PURPLE_PRIVACY_DENY_USERS);
+				purple_account_set_privacy_type_wrapped(account, PURPLE_PRIVACY_DENY_USERS);
 			}
 
 			// Set the status
-			const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_AVAILABLE);
+			const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive_wrapped(account, PURPLE_STATUS_AVAILABLE);
 			if (status_type != NULL) {
-				purple_account_set_status(account, purple_status_type_get_id(status_type), TRUE, 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 (purple_account_get_int(account, "version", 0) != 0) {
-					std::string data = stringOf(purple_account_get_int(account, "version", 0));
+				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(account);
-				purple_account_set_enabled(account, "spectrum", FALSE);
+				purple_account_disconnect_wrapped(account);
+				purple_account_set_enabled_wrapped(account, "spectrum", FALSE);
 
 				m_accounts.erase(account);
 
-				purple_accounts_delete(account);
+				purple_accounts_delete_wrapped(account);
 #ifndef WIN32
 				malloc_trim(0);
 #endif
@@ -371,7 +371,7 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 				switch(status) {
 					case pbnetwork::STATUS_AWAY: {
 						st = PURPLE_STATUS_AWAY;
-						if (!purple_account_get_status_type_with_primitive(account, 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;
@@ -382,7 +382,7 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 						break;
 					}
 					case pbnetwork::STATUS_XA: {
-						if (!purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_EXTENDED_AWAY))
+						if (!purple_account_get_status_type_with_primitive_wrapped(account, PURPLE_STATUS_EXTENDED_AWAY))
 							st = PURPLE_STATUS_AWAY;
 						else
 							st = PURPLE_STATUS_EXTENDED_AWAY;
@@ -399,19 +399,19 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 						st = PURPLE_STATUS_AVAILABLE;
 						break;
 				}
-				gchar *_markup = purple_markup_escape_text(statusMessage.c_str(), -1);
+				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(account, (PurpleStatusPrimitive) st);
+				const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive_wrapped(account, (PurpleStatusPrimitive) st);
 				if (status_type != NULL) {
 					// send presence to legacy network
 					if (!markup.empty()) {
-						purple_account_set_status(account, purple_status_type_get_id(status_type), TRUE, "message", markup.c_str(), NULL);
+						purple_account_set_status_wrapped(account, purple_status_type_get_id_wrapped(status_type), TRUE, "message", markup.c_str(), NULL);
 					}
 					else {
-						purple_account_set_status(account, purple_status_type_get_id(status_type), TRUE, NULL);
+						purple_account_set_status_wrapped(account, purple_status_type_get_id_wrapped(status_type), TRUE, NULL);
 					}
 				}
 			}
@@ -420,29 +420,29 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 		void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &xhtml) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
-				PurpleConversation *conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, legacyName.c_str(), account);
+				PurpleConversation *conv = purple_find_conversation_with_account_wrapped(PURPLE_CONV_TYPE_CHAT, legacyName.c_str(), account);
 				if (!conv) {
-					conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, legacyName.c_str(), account);
+					conv = purple_find_conversation_with_account_wrapped(PURPLE_CONV_TYPE_IM, legacyName.c_str(), account);
 					if (!conv) {
-						conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, legacyName.c_str());
+						conv = purple_conversation_new_wrapped(PURPLE_CONV_TYPE_IM, account, legacyName.c_str());
 					}
 				}
 				if (xhtml.empty()) {
-					gchar *_markup = purple_markup_escape_text(message.c_str(), -1);
-					if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM) {
-						purple_conv_im_send(PURPLE_CONV_IM(conv), _markup);
+					gchar *_markup = purple_markup_escape_text_wrapped(message.c_str(), -1);
+					if (purple_conversation_get_type_wrapped(conv) == PURPLE_CONV_TYPE_IM) {
+						purple_conv_im_send_wrapped(PURPLE_CONV_IM_WRAPPED(conv), _markup);
 					}
-					else if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT) {
-						purple_conv_chat_send(PURPLE_CONV_CHAT(conv), _markup);
+					else if (purple_conversation_get_type_wrapped(conv) == PURPLE_CONV_TYPE_CHAT) {
+						purple_conv_chat_send_wrapped(PURPLE_CONV_CHAT_WRAPPED(conv), _markup);
 					}
 					g_free(_markup);
 				}
 				else {
-					if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM) {
-						purple_conv_im_send(PURPLE_CONV_IM(conv), xhtml.c_str());
+					if (purple_conversation_get_type_wrapped(conv) == PURPLE_CONV_TYPE_IM) {
+						purple_conv_im_send_wrapped(PURPLE_CONV_IM_WRAPPED(conv), xhtml.c_str());
 					}
-					else if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT) {
-						purple_conv_chat_send(PURPLE_CONV_CHAT(conv), xhtml.c_str());
+					else if (purple_conversation_get_type_wrapped(conv) == PURPLE_CONV_TYPE_CHAT) {
+						purple_conv_chat_send_wrapped(PURPLE_CONV_CHAT_WRAPPED(conv), xhtml.c_str());
 					}
 				}
 			}
@@ -457,13 +457,13 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 				}
 				m_vcards[user + name] = id;
 
-				if (CONFIG_BOOL(config, "backend.no_vcard_fetch") && name != purple_account_get_username(account)) {
-					PurpleNotifyUserInfo *user_info = purple_notify_user_info_new();
-					notify_user_info(purple_account_get_connection(account), name.c_str(), user_info);
-					purple_notify_user_info_destroy(user_info);
+				if (CONFIG_BOOL(config, "backend.no_vcard_fetch") && name != purple_account_get_username_wrapped(account)) {
+					PurpleNotifyUserInfo *user_info = purple_notify_user_info_new_wrapped();
+					notify_user_info(purple_account_get_connection_wrapped(account), name.c_str(), user_info);
+					purple_notify_user_info_destroy_wrapped(user_info);
 				}
 				else {
-					serv_get_info(purple_account_get_connection(account), name.c_str());
+					serv_get_info_wrapped(purple_account_get_connection_wrapped(account), name.c_str());
 				}
 				
 			}
@@ -472,8 +472,8 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 		void handleVCardUpdatedRequest(const std::string &user, const std::string &image, const std::string &nickname) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
-				purple_account_set_alias(account, nickname.c_str());
-				purple_account_set_public_alias(account, nickname.c_str(), NULL, NULL);
+				purple_account_set_alias_wrapped(account, nickname.c_str());
+				purple_account_set_public_alias_wrapped(account, nickname.c_str(), NULL, NULL);
 				gssize size = image.size();
 				// this will be freed by libpurple
 				guchar *photo = (guchar *) g_malloc(size * sizeof(guchar));
@@ -481,7 +481,7 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 
 				if (!photo)
 					return;
-				purple_buddy_icons_set_account_icon(account, photo, size);
+				purple_buddy_icons_set_account_icon_wrapped(account, photo, size);
 			}
 		}
 
@@ -492,10 +492,10 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 					m_authRequests[user + buddyName]->deny_cb(m_authRequests[user + buddyName]->user_data);
 					m_authRequests.erase(user + buddyName);
 				}
-				PurpleBuddy *buddy = purple_find_buddy(account, buddyName.c_str());
+				PurpleBuddy *buddy = purple_find_buddy_wrapped(account, buddyName.c_str());
 				if (buddy) {
-					purple_account_remove_buddy(account, buddy, purple_buddy_get_group(buddy));
-					purple_blist_remove_buddy(buddy);
+					purple_account_remove_buddy_wrapped(account, buddy, purple_buddy_get_group_wrapped(buddy));
+					purple_blist_remove_buddy_wrapped(buddy);
 				}
 			}
 		}
@@ -510,30 +510,30 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 					m_authRequests.erase(user + buddyName);
 				}
 
-				PurpleBuddy *buddy = purple_find_buddy(account, buddyName.c_str());
+				PurpleBuddy *buddy = purple_find_buddy_wrapped(account, buddyName.c_str());
 				if (buddy) {
 					if (getAlias(buddy) != alias) {
-						purple_blist_alias_buddy(buddy, alias.c_str());
-						purple_blist_server_alias_buddy(buddy, alias.c_str());
-						serv_alias_buddy(buddy);
+						purple_blist_alias_buddy_wrapped(buddy, alias.c_str());
+						purple_blist_server_alias_buddy_wrapped(buddy, alias.c_str());
+						serv_alias_buddy_wrapped(buddy);
 					}
 
-					PurpleGroup *group = purple_find_group(groups.c_str());
+					PurpleGroup *group = purple_find_group_wrapped(groups.c_str());
 					if (!group) {
-						group = purple_group_new(groups.c_str());
+						group = purple_group_new_wrapped(groups.c_str());
 					}
-					purple_blist_add_contact(purple_buddy_get_contact(buddy), group ,NULL);
+					purple_blist_add_contact_wrapped(purple_buddy_get_contact_wrapped(buddy), group ,NULL);
 				}
 				else {
-					PurpleBuddy *buddy = purple_buddy_new(account, buddyName.c_str(), alias.c_str());
+					PurpleBuddy *buddy = purple_buddy_new_wrapped(account, buddyName.c_str(), alias.c_str());
 
 					// Add newly created buddy to legacy network roster.
-					PurpleGroup *group = purple_find_group(groups.c_str());
+					PurpleGroup *group = purple_find_group_wrapped(groups.c_str());
 					if (!group) {
-						group = purple_group_new(groups.c_str());
+						group = purple_group_new_wrapped(groups.c_str());
 					}
-					purple_blist_add_buddy(buddy, NULL, group ,NULL);
-					purple_account_add_buddy(account, buddy);
+					purple_blist_add_buddy_wrapped(buddy, NULL, group ,NULL);
+					purple_account_add_buddy_wrapped(account, buddy);
 				}
 			}
 		}
@@ -543,10 +543,10 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 				PurpleAccount *account = m_sessions[user];
 				if (account) {
 					if (blocked) {
-						purple_privacy_deny(account, buddyName.c_str(), FALSE, FALSE);
+						purple_privacy_deny_wrapped(account, buddyName.c_str(), FALSE, FALSE);
 					}
 					else {
-						purple_privacy_allow(account, buddyName.c_str(), FALSE, FALSE);
+						purple_privacy_allow_wrapped(account, buddyName.c_str(), FALSE, FALSE);
 					}
 				}
 			}
@@ -555,28 +555,28 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 		void handleTypingRequest(const std::string &user, const std::string &buddyName) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
-				serv_send_typing(purple_account_get_connection(account), buddyName.c_str(), PURPLE_TYPING);
+				serv_send_typing_wrapped(purple_account_get_connection_wrapped(account), buddyName.c_str(), PURPLE_TYPING);
 			}
 		}
 
 		void handleTypedRequest(const std::string &user, const std::string &buddyName) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
-				serv_send_typing(purple_account_get_connection(account), buddyName.c_str(), PURPLE_TYPED);
+				serv_send_typing_wrapped(purple_account_get_connection_wrapped(account), buddyName.c_str(), PURPLE_TYPED);
 			}
 		}
 
 		void handleStoppedTypingRequest(const std::string &user, const std::string &buddyName) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
-				serv_send_typing(purple_account_get_connection(account), buddyName.c_str(), PURPLE_NOT_TYPING);
+				serv_send_typing_wrapped(purple_account_get_connection_wrapped(account), buddyName.c_str(), PURPLE_NOT_TYPING);
 			}
 		}
 
 		void handleAttentionRequest(const std::string &user, const std::string &buddyName, const std::string &message) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
-				purple_prpl_send_attention(purple_account_get_connection(account), buddyName.c_str(), 0);
+				purple_prpl_send_attention_wrapped(purple_account_get_connection_wrapped(account), buddyName.c_str(), 0);
 			}
 		}
 
@@ -586,13 +586,13 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 				return;
 			}
 
-			PurpleConnection *gc = purple_account_get_connection(account);
+			PurpleConnection *gc = purple_account_get_connection_wrapped(account);
 			GHashTable *comps = NULL;
 
 			// Check if the PurpleChat is not stored in buddy list
-			PurpleChat *chat = purple_blist_find_chat(account, room.c_str());
+			PurpleChat *chat = purple_blist_find_chat_wrapped(account, room.c_str());
 			if (chat) {
-				comps = purple_chat_get_components(chat);
+				comps = purple_chat_get_components_wrapped(chat);
 			}
 			else if (PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->chat_info_defaults != NULL) {
 				comps = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->chat_info_defaults(gc, room.c_str());
@@ -600,7 +600,7 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 
 			LOG4CXX_INFO(logger, user << ": Joining the room " << room);
 			if (comps) {
-				serv_join_chat(gc, comps);
+				serv_join_chat_wrapped(gc, comps);
 				g_hash_table_destroy(comps);
 			}
 		}
@@ -611,8 +611,8 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 				return;
 			}
 
-			PurpleConversation *conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, room.c_str(), account);
-			purple_conversation_destroy(conv);
+			PurpleConversation *conv = purple_find_conversation_with_account_wrapped(PURPLE_CONV_TYPE_CHAT, room.c_str(), account);
+			purple_conversation_destroy_wrapped(conv);
 		}
 
 		void handleFTStartRequest(const std::string &user, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long ftID) {
@@ -623,8 +623,8 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 				
 				ftData->id = ftID;
 				m_xfers[ftID] = xfer;
-				purple_xfer_request_accepted(xfer, fileName.c_str());
-				purple_xfer_ui_ready(xfer);
+				purple_xfer_request_accepted_wrapped(xfer, fileName.c_str());
+				purple_xfer_ui_ready_wrapped(xfer);
 			}
 		}
 
@@ -632,7 +632,7 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 			PurpleXfer *xfer = m_unhandledXfers[user + fileName + buddyName];
 			if (xfer) {
 				m_unhandledXfers.erase(user + fileName + buddyName);
-				purple_xfer_request_denied(xfer);
+				purple_xfer_request_denied_wrapped(xfer);
 			}
 		}
 
@@ -650,7 +650,7 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 				return;
 			FTData *ftData = (FTData *) xfer->ui_data;
 			ftData->paused = false;
-			purple_xfer_ui_ready(xfer);
+			purple_xfer_ui_ready_wrapped(xfer);
 		}
 
 		void sendData(const std::string &string) {
@@ -660,7 +660,7 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 			write(main_socket, string.c_str(), string.size());
 #endif
 			if (writeInput == 0)
-				writeInput = purple_input_add(main_socket, PURPLE_INPUT_WRITE, &transportDataReceived, NULL);
+				writeInput = purple_input_add_wrapped(main_socket, PURPLE_INPUT_WRITE, &transportDataReceived, NULL);
 		}
 
 		void readyForData() {
@@ -672,9 +672,9 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 			for (std::vector<PurpleXfer *>::const_iterator it = tmp.begin(); it != tmp.end(); it++) {
 				FTData *ftData = (FTData *) (*it)->ui_data;
 				if (ftData->timer == 0) {
-					ftData->timer = purple_timeout_add(1, ft_ui_ready, *it);
+					ftData->timer = purple_timeout_add_wrapped(1, ft_ui_ready, *it);
 				}
-// 				purple_xfer_ui_ready(xfer);
+// 				purple_xfer_ui_ready_wrapped(xfer);
 			}
 		}
 
@@ -688,13 +688,13 @@ class SpectrumNetworkPlugin : public NetworkPlugin {
 };
 
 static bool getStatus(PurpleBuddy *m_buddy, pbnetwork::StatusType &status, std::string &statusMessage) {
-	PurplePresence *pres = purple_buddy_get_presence(m_buddy);
+	PurplePresence *pres = purple_buddy_get_presence_wrapped(m_buddy);
 	if (pres == NULL)
 		return false;
-	PurpleStatus *stat = purple_presence_get_active_status(pres);
+	PurpleStatus *stat = purple_presence_get_active_status_wrapped(pres);
 	if (stat == NULL)
 		return false;
-	int st = purple_status_type_get_primitive(purple_status_get_type(stat));
+	int st = purple_status_type_get_primitive_wrapped(purple_status_get_type_wrapped(stat));
 
 	switch(st) {
 		case PURPLE_STATUS_AVAILABLE: {
@@ -722,10 +722,10 @@ static bool getStatus(PurpleBuddy *m_buddy, pbnetwork::StatusType &status, std::
 			break;
 	}
 
-	const char *message = purple_status_get_attr_string(stat, "message");
+	const char *message = purple_status_get_attr_string_wrapped(stat, "message");
 
 	if (message != NULL) {
-		char *stripped = purple_markup_strip_html(message);
+		char *stripped = purple_markup_strip_html_wrapped(message);
 		statusMessage = std::string(stripped);
 		g_free(stripped);
 	}
@@ -736,10 +736,10 @@ static bool getStatus(PurpleBuddy *m_buddy, pbnetwork::StatusType &status, std::
 
 static std::string getIconHash(PurpleBuddy *m_buddy) {
 	char *avatarHash = NULL;
-	PurpleBuddyIcon *icon = purple_buddy_icons_find(purple_buddy_get_account(m_buddy), purple_buddy_get_name(m_buddy));
+	PurpleBuddyIcon *icon = purple_buddy_icons_find_wrapped(purple_buddy_get_account_wrapped(m_buddy), purple_buddy_get_name_wrapped(m_buddy));
 	if (icon) {
-		avatarHash = purple_buddy_icon_get_full_path(icon);
-		purple_buddy_icon_unref(icon);
+		avatarHash = purple_buddy_icon_get_full_path_wrapped(icon);
+		purple_buddy_icon_unref_wrapped(icon);
 	}
 
 	if (avatarHash) {
@@ -769,14 +769,14 @@ static std::string getIconHash(PurpleBuddy *m_buddy) {
 
 static std::vector<std::string> getGroups(PurpleBuddy *m_buddy) {
 	std::vector<std::string> groups;
-	if (purple_buddy_get_name(m_buddy)) {
-		GSList *buddies = purple_find_buddies(purple_buddy_get_account(m_buddy), purple_buddy_get_name(m_buddy));
+	if (purple_buddy_get_name_wrapped(m_buddy)) {
+		GSList *buddies = purple_find_buddies_wrapped(purple_buddy_get_account_wrapped(m_buddy), purple_buddy_get_name_wrapped(m_buddy));
 		while(buddies) {
-			PurpleGroup *g = purple_buddy_get_group((PurpleBuddy *) buddies->data);
+			PurpleGroup *g = purple_buddy_get_group_wrapped((PurpleBuddy *) buddies->data);
 			buddies = g_slist_delete_link(buddies, buddies);
 
-			if(g && purple_group_get_name(g)) {
-				groups.push_back(purple_group_get_name(g));
+			if(g && purple_group_get_name_wrapped(g)) {
+				groups.push_back(purple_group_get_name_wrapped(g));
 			}
 		}
 	}
@@ -789,13 +789,13 @@ static std::vector<std::string> getGroups(PurpleBuddy *m_buddy) {
 }
 
 static void buddyListNewNode(PurpleBlistNode *node) {
-	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
+	if (!PURPLE_BLIST_NODE_IS_BUDDY_WRAPPED(node))
 		return;
 	PurpleBuddy *buddy = (PurpleBuddy *) node;
-	PurpleAccount *account = purple_buddy_get_account(buddy);
+	PurpleAccount *account = purple_buddy_get_account_wrapped(buddy);
 
 	std::vector<std::string> groups = getGroups(buddy);
-	LOG4CXX_INFO(logger, "Buddy updated " << np->m_accounts[account] << " " << purple_buddy_get_name(buddy) << " " << getAlias(buddy) << " group (" << groups.size() << ")=" << groups[0]);
+	LOG4CXX_INFO(logger, "Buddy updated " << np->m_accounts[account] << " " << purple_buddy_get_name_wrapped(buddy) << " " << getAlias(buddy) << " group (" << groups.size() << ")=" << groups[0]);
 
 	// Status
 	pbnetwork::StatusType status = pbnetwork::STATUS_NONE;
@@ -803,22 +803,22 @@ static void buddyListNewNode(PurpleBlistNode *node) {
 	getStatus(buddy, status, message);
 
 	// Tooltip
-	PurplePlugin *prpl = purple_find_prpl(purple_account_get_protocol_id(account));
+	PurplePlugin *prpl = purple_find_prpl_wrapped(purple_account_get_protocol_id_wrapped(account));
 	PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
 
 	bool blocked = false;
 	if (CONFIG_BOOL(config, "service.enable_privacy_lists")) {
 		if (prpl_info && prpl_info->tooltip_text) {
-			PurpleNotifyUserInfo *user_info = purple_notify_user_info_new();
+			PurpleNotifyUserInfo *user_info = purple_notify_user_info_new_wrapped();
 			prpl_info->tooltip_text(buddy, user_info, true);
-			GList *entries = purple_notify_user_info_get_entries(user_info);
+			GList *entries = purple_notify_user_info_get_entries_wrapped(user_info);
 
 			while (entries) {
 				PurpleNotifyUserInfoEntry *entry = (PurpleNotifyUserInfoEntry *)(entries->data);
-				if (purple_notify_user_info_entry_get_label(entry) && purple_notify_user_info_entry_get_value(entry)) {
-					std::string label = purple_notify_user_info_entry_get_label(entry);
+				if (purple_notify_user_info_entry_get_label_wrapped(entry) && purple_notify_user_info_entry_get_value_wrapped(entry)) {
+					std::string label = purple_notify_user_info_entry_get_label_wrapped(entry);
 					if (label == "Blocked" ) {
-						if (std::string(purple_notify_user_info_entry_get_value(entry)) == "Yes") {
+						if (std::string(purple_notify_user_info_entry_get_value_wrapped(entry)) == "Yes") {
 							blocked = true;
 							break;
 						}
@@ -826,39 +826,39 @@ static void buddyListNewNode(PurpleBlistNode *node) {
 				}
 				entries = entries->next;
 			}
-			purple_notify_user_info_destroy(user_info);
+			purple_notify_user_info_destroy_wrapped(user_info);
 		}
 
 		if (!blocked) {
-			blocked = purple_privacy_check(account, purple_buddy_get_name(buddy)) == false;
+			blocked = purple_privacy_check_wrapped(account, purple_buddy_get_name_wrapped(buddy)) == false;
 		}
 		else {
-			bool purpleBlocked = purple_privacy_check(account, purple_buddy_get_name(buddy)) == false;
+			bool purpleBlocked = purple_privacy_check_wrapped(account, purple_buddy_get_name_wrapped(buddy)) == false;
 			if (blocked != purpleBlocked) {
-				purple_privacy_deny(account, purple_buddy_get_name(buddy), FALSE, FALSE);
+				purple_privacy_deny_wrapped(account, purple_buddy_get_name_wrapped(buddy), FALSE, FALSE);
 			}
 		}
 	}
 
-	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy), status, message, getIconHash(buddy),
+	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name_wrapped(buddy), getAlias(buddy), getGroups(buddy), status, message, getIconHash(buddy),
 		blocked
 	);
 }
 
 static void buddyListUpdate(PurpleBuddyList *list, PurpleBlistNode *node) {
-	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
+	if (!PURPLE_BLIST_NODE_IS_BUDDY_WRAPPED(node))
 		return;
 	buddyListNewNode(node);
 }
 
 static void buddyPrivacyChanged(PurpleBlistNode *node, void *data) {
-	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
+	if (!PURPLE_BLIST_NODE_IS_BUDDY_WRAPPED(node))
 		return;
 	buddyListUpdate(NULL, node);
 }
 
 static void NodeRemoved(PurpleBlistNode *node, void *data) {
-	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
+	if (!PURPLE_BLIST_NODE_IS_BUDDY_WRAPPED(node))
 		return;
 // 	PurpleBuddy *buddy = (PurpleBuddy *) node;
 }
@@ -883,24 +883,24 @@ static PurpleBlistUiOps blistUiOps =
 
 static void conv_write_im(PurpleConversation *conv, const char *who, const char *msg, PurpleMessageFlags flags, time_t mtime) {
 	// Don't forwards our own messages.
-	if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM && (flags & PURPLE_MESSAGE_SEND || flags & PURPLE_MESSAGE_SYSTEM)) {
+	if (purple_conversation_get_type_wrapped(conv) == PURPLE_CONV_TYPE_IM && (flags & PURPLE_MESSAGE_SEND || flags & PURPLE_MESSAGE_SYSTEM)) {
 		return;
 	}
-	PurpleAccount *account = purple_conversation_get_account(conv);
+	PurpleAccount *account = purple_conversation_get_account_wrapped(conv);
 
-// 	char *striped = purple_markup_strip_html(message);
+// 	char *striped = purple_markup_strip_html_wrapped(message);
 // 	std::string msg = striped;
 // 	g_free(striped);
 
-	std::string w = purple_normalize(account, who);
+	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);
 
 	// Escape HTML characters.
-	char *newline = purple_strdup_withhtml(msg);
+	char *newline = purple_strdup_withhtml_wrapped(msg);
 	char *strip, *xhtml;
-	purple_markup_html_to_xhtml(newline, &xhtml, &strip);
+	purple_markup_html_to_xhtml_wrapped(newline, &xhtml, &strip);
 // 	xhtml_linkified = spectrum_markup_linkify(xhtml);
 	std::string message_(strip);
 
@@ -924,17 +924,17 @@ static void conv_write_im(PurpleConversation *conv, const char *who, const char
 
 // 	LOG4CXX_INFO(logger, "Received message body='" << message_ << "' xhtml='" << xhtml_ << "'");
 
-	if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM) {
+	if (purple_conversation_get_type_wrapped(conv) == PURPLE_CONV_TYPE_IM) {
 		np->handleMessage(np->m_accounts[account], w, message_, "", xhtml_);
 	}
 	else {
-		LOG4CXX_INFO(logger, "Received message body='" << message_ << "' name='" << purple_conversation_get_name(conv) << "' " << w);
-		np->handleMessage(np->m_accounts[account], purple_conversation_get_name(conv), message_, w, xhtml_);
+		LOG4CXX_INFO(logger, "Received message body='" << message_ << "' name='" << purple_conversation_get_name_wrapped(conv) << "' " << w);
+		np->handleMessage(np->m_accounts[account], purple_conversation_get_name_wrapped(conv), message_, w, xhtml_);
 	}
 }
 
 static void conv_chat_add_users(PurpleConversation *conv, GList *cbuddies, gboolean new_arrivals) {
-	PurpleAccount *account = purple_conversation_get_account(conv);
+	PurpleAccount *account = purple_conversation_get_account_wrapped(conv);
 
 	GList *l = cbuddies;
 	while (l != NULL) {
@@ -957,19 +957,19 @@ static void conv_chat_add_users(PurpleConversation *conv, GList *cbuddies, gbool
 // 			item->addAttribute("role", "participant");
 		}
 
-		np->handleParticipantChanged(np->m_accounts[account], name, purple_conversation_get_name(conv), (int) flags, pbnetwork::STATUS_ONLINE);
+		np->handleParticipantChanged(np->m_accounts[account], name, purple_conversation_get_name_wrapped(conv), (int) flags, pbnetwork::STATUS_ONLINE);
 
 		l = l->next;
 	}
 }
 
 static void conv_chat_remove_users(PurpleConversation *conv, GList *users) {
-	PurpleAccount *account = purple_conversation_get_account(conv);
+	PurpleAccount *account = purple_conversation_get_account_wrapped(conv);
 
 	GList *l = users;
 	while (l != NULL) {
 		std::string name((char *) l->data);
-		np->handleParticipantChanged(np->m_accounts[account], name, purple_conversation_get_name(conv), 0, pbnetwork::STATUS_NONE);
+		np->handleParticipantChanged(np->m_accounts[account], name, purple_conversation_get_name_wrapped(conv), 0, pbnetwork::STATUS_NONE);
 
 		l = l->next;
 	}
@@ -1005,11 +1005,11 @@ struct Dis {
 
 static gboolean disconnectMe(void *data) {
 	Dis *d = (Dis *) data;
-	PurpleAccount *account = purple_accounts_find(d->name.c_str(), d->protocol.c_str());
+	PurpleAccount *account = purple_accounts_find_wrapped(d->name.c_str(), d->protocol.c_str());
 	delete d;
 
 	if (account) {
-		np->handleLogoutRequest(np->m_accounts[account], purple_account_get_username(account));
+		np->handleLogoutRequest(np->m_accounts[account], purple_account_get_username_wrapped(account));
 	}
 	return FALSE;
 }
@@ -1020,12 +1020,12 @@ static gboolean pingTimeout(void *data) {
 }
 
 static void connection_report_disconnect(PurpleConnection *gc, PurpleConnectionError reason, const char *text){
-	PurpleAccount *account = purple_connection_get_account(gc);
+	PurpleAccount *account = purple_connection_get_account_wrapped(gc);
 	np->handleDisconnected(np->m_accounts[account], (int) reason, text ? text : "");
 	Dis *d = new Dis;
-	d->name = purple_account_get_username(account);
-	d->protocol = purple_account_get_protocol_id(account);
-	purple_timeout_add_seconds(10, disconnectMe, d);
+	d->name = purple_account_get_username_wrapped(account);
+	d->protocol = purple_account_get_protocol_id_wrapped(account);
+	purple_timeout_add_seconds_wrapped(10, disconnectMe, d);
 }
 
 static PurpleConnectionUiOps conn_ui_ops =
@@ -1044,8 +1044,8 @@ static PurpleConnectionUiOps conn_ui_ops =
 };
 
 static void *notify_user_info(PurpleConnection *gc, const char *who, PurpleNotifyUserInfo *user_info) {
-	PurpleAccount *account = purple_connection_get_account(gc);
-	std::string name(purple_normalize(account, who));
+	PurpleAccount *account = purple_connection_get_account_wrapped(gc);
+	std::string name(purple_normalize_wrapped(account, who));
 	std::transform(name.begin(), name.end(), name.begin(), ::tolower);
 
 	size_t pos = name.find("/");
@@ -1053,7 +1053,7 @@ static void *notify_user_info(PurpleConnection *gc, const char *who, PurpleNotif
 		name.erase((int) pos, name.length() - (int) pos);
 
 	
-	GList *vcardEntries = purple_notify_user_info_get_entries(user_info);
+	GList *vcardEntries = purple_notify_user_info_get_entries_wrapped(user_info);
 	PurpleNotifyUserInfoEntry *vcardEntry;
 	std::string firstName;
 	std::string lastName;
@@ -1065,22 +1065,22 @@ static void *notify_user_info(PurpleConnection *gc, const char *who, PurpleNotif
 
 	while (vcardEntries) {
 		vcardEntry = (PurpleNotifyUserInfoEntry *)(vcardEntries->data);
-		if (purple_notify_user_info_entry_get_label(vcardEntry) && purple_notify_user_info_entry_get_value(vcardEntry)){
-			label = purple_notify_user_info_entry_get_label(vcardEntry);
+		if (purple_notify_user_info_entry_get_label_wrapped(vcardEntry) && purple_notify_user_info_entry_get_value_wrapped(vcardEntry)){
+			label = purple_notify_user_info_entry_get_label_wrapped(vcardEntry);
 			if (label == "Given Name" || label == "First Name") {
-				firstName = purple_notify_user_info_entry_get_value(vcardEntry);
+				firstName = purple_notify_user_info_entry_get_value_wrapped(vcardEntry);
 			}
 			else if (label == "Family Name" || label == "Last Name") {
-				lastName = purple_notify_user_info_entry_get_value(vcardEntry);
+				lastName = purple_notify_user_info_entry_get_value_wrapped(vcardEntry);
 			}
 			else if (label=="Nickname" || label == "Nick") {
-				nickname = purple_notify_user_info_entry_get_value(vcardEntry);
+				nickname = purple_notify_user_info_entry_get_value_wrapped(vcardEntry);
 			}
 			else if (label=="Full Name") {
-				fullName = purple_notify_user_info_entry_get_value(vcardEntry);
+				fullName = purple_notify_user_info_entry_get_value_wrapped(vcardEntry);
 			}
 			else {
-				LOG4CXX_WARN(logger, "Unhandled VCard Label '" << purple_notify_user_info_entry_get_label(vcardEntry) << "' " << purple_notify_user_info_entry_get_value(vcardEntry));
+				LOG4CXX_WARN(logger, "Unhandled VCard Label '" << purple_notify_user_info_entry_get_label_wrapped(vcardEntry) << "' " << purple_notify_user_info_entry_get_value_wrapped(vcardEntry));
 			}
 		}
 		vcardEntries = vcardEntries->next;
@@ -1093,12 +1093,12 @@ static void *notify_user_info(PurpleConnection *gc, const char *who, PurpleNotif
 		nickname = fullName;
 	}
 
-	bool ownInfo = name == purple_account_get_username(account);
+	bool ownInfo = name == purple_account_get_username_wrapped(account);
 
 	if (ownInfo) {
-		const gchar *displayname = purple_connection_get_display_name(gc);
+		const gchar *displayname = purple_connection_get_display_name_wrapped(gc);
 		if (!displayname) {
-			displayname = purple_account_get_name_for_display(account);
+			displayname = purple_account_get_name_for_display_wrapped(account);
 		}
 
 		if (displayname && nickname.empty()) {
@@ -1106,26 +1106,26 @@ static void *notify_user_info(PurpleConnection *gc, const char *who, PurpleNotif
 		}
 
 		// avatar
-		PurpleStoredImage *avatar = purple_buddy_icons_find_account_icon(account);
+		PurpleStoredImage *avatar = purple_buddy_icons_find_account_icon_wrapped(account);
 		if (avatar) {
-			const gchar * data = (const gchar *) purple_imgstore_get_data(avatar);
-			size_t len = purple_imgstore_get_size(avatar);
+			const gchar * data = (const gchar *) purple_imgstore_get_data_wrapped(avatar);
+			size_t len = purple_imgstore_get_size_wrapped(avatar);
 			if (len < 300000 && data) {
 				photo = std::string(data, len);
 			}
-			purple_imgstore_unref(avatar);
+			purple_imgstore_unref_wrapped(avatar);
 		}
 	}
 
-	PurpleBuddy *buddy = purple_find_buddy(purple_connection_get_account(gc), who);
+	PurpleBuddy *buddy = purple_find_buddy_wrapped(purple_connection_get_account_wrapped(gc), who);
 	if (buddy && photo.size() == 0) {
 		gsize len;
 		PurpleBuddyIcon *icon = NULL;
-		icon = purple_buddy_icons_find(purple_connection_get_account(gc), name.c_str());
+		icon = purple_buddy_icons_find_wrapped(purple_connection_get_account_wrapped(gc), name.c_str());
 		if (icon) {
 			if (true) {
 				gchar *data;
-				gchar *path = purple_buddy_icon_get_full_path(icon);
+				gchar *path = purple_buddy_icon_get_full_path_wrapped(icon);
 				if (path) {
 					if (g_file_get_contents(path, &data, &len, NULL)) {
 						photo = std::string(data, len);
@@ -1135,12 +1135,12 @@ static void *notify_user_info(PurpleConnection *gc, const char *who, PurpleNotif
 				}
 			}
 			else {
-				const gchar * data = (gchar*)purple_buddy_icon_get_data(icon, &len);
+				const gchar * data = (gchar*)purple_buddy_icon_get_data_wrapped(icon, &len);
 				if (len < 300000 && data) {
 					photo = std::string(data, len);
 				}
 			}
-			purple_buddy_icon_unref(icon);
+			purple_buddy_icon_unref_wrapped(icon);
 		}
 	}
 
@@ -1221,7 +1221,7 @@ static void XferCreated(PurpleXfer *xfer) {
 		return;
 	}
 
-// 	PurpleAccount *account = purple_xfer_get_account(xfer);
+// 	PurpleAccount *account = purple_xfer_get_account_wrapped(xfer);
 // 	np->handleFTStart(np->m_accounts[account], xfer->who, xfer, "", xhtml_);
 }
 
@@ -1229,7 +1229,7 @@ static void XferDestroyed(PurpleXfer *xfer) {
 	std::remove(np->m_waitingXfers.begin(), np->m_waitingXfers.end(), xfer);
 	FTData *ftdata = (FTData *) xfer->ui_data;
 	if (ftdata && ftdata->timer) {
-		purple_timeout_remove(ftdata->timer);
+		purple_timeout_remove_wrapped(ftdata->timer);
 	}
 	if (ftdata) {
 		np->m_xfers.erase(ftdata->id);
@@ -1237,8 +1237,8 @@ static void XferDestroyed(PurpleXfer *xfer) {
 }
 
 static void xferCanceled(PurpleXfer *xfer) {
-	PurpleAccount *account = purple_xfer_get_account(xfer);
-	std::string filename(xfer ? purple_xfer_get_filename(xfer) : "");
+	PurpleAccount *account = purple_xfer_get_account_wrapped(xfer);
+	std::string filename(xfer ? purple_xfer_get_filename_wrapped(xfer) : "");
 	std::string w = xfer->who;
 	size_t pos = w.find("/");
 	if (pos != std::string::npos)
@@ -1246,12 +1246,12 @@ static void xferCanceled(PurpleXfer *xfer) {
 
 	FTData *ftdata = (FTData *) xfer->ui_data;
 
-	np->handleFTFinish(np->m_accounts[account], w, filename, purple_xfer_get_size(xfer), ftdata ? ftdata->id : 0);
+	np->handleFTFinish(np->m_accounts[account], w, filename, purple_xfer_get_size_wrapped(xfer), ftdata ? ftdata->id : 0);
 	std::remove(np->m_waitingXfers.begin(), np->m_waitingXfers.end(), xfer);
 	if (ftdata && ftdata->timer) {
-		purple_timeout_remove(ftdata->timer);
+		purple_timeout_remove_wrapped(ftdata->timer);
 	}
-	purple_xfer_unref(xfer);
+	purple_xfer_unref_wrapped(xfer);
 }
 
 static void fileSendStart(PurpleXfer *xfer) {
@@ -1264,14 +1264,14 @@ static void fileRecvStart(PurpleXfer *xfer) {
 // 	repeater->fileRecvStart();
 	FTData *ftData = (FTData *) xfer->ui_data;
 	if (ftData->timer == 0) {
-		ftData->timer = purple_timeout_add(1, ft_ui_ready, xfer);
+		ftData->timer = purple_timeout_add_wrapped(1, ft_ui_ready, xfer);
 	}
 }
 
 static void newXfer(PurpleXfer *xfer) {
-	PurpleAccount *account = purple_xfer_get_account(xfer);
-	std::string filename(xfer ? purple_xfer_get_filename(xfer) : "");
-	purple_xfer_ref(xfer);
+	PurpleAccount *account = purple_xfer_get_account_wrapped(xfer);
+	std::string filename(xfer ? purple_xfer_get_filename_wrapped(xfer) : "");
+	purple_xfer_ref_wrapped(xfer);
 	std::string w = xfer->who;
 	size_t pos = w.find("/");
 	if (pos != std::string::npos)
@@ -1285,7 +1285,7 @@ static void newXfer(PurpleXfer *xfer) {
 
 	np->m_unhandledXfers[np->m_accounts[account] + filename + w] = xfer;
 
-	np->handleFTStart(np->m_accounts[account], w, filename, purple_xfer_get_size(xfer));
+	np->handleFTStart(np->m_accounts[account], w, filename, purple_xfer_get_size_wrapped(xfer));
 }
 
 static void XferReceiveComplete(PurpleXfer *xfer) {
@@ -1295,9 +1295,9 @@ static void XferReceiveComplete(PurpleXfer *xfer) {
 	std::remove(np->m_waitingXfers.begin(), np->m_waitingXfers.end(), xfer);
 	FTData *ftdata = (FTData *) xfer->ui_data;
 	if (ftdata && ftdata->timer) {
-		purple_timeout_remove(ftdata->timer);
+		purple_timeout_remove_wrapped(ftdata->timer);
 	}
-	purple_xfer_unref(xfer);
+	purple_xfer_unref_wrapped(xfer);
 }
 
 static void XferSendComplete(PurpleXfer *xfer) {
@@ -1306,9 +1306,9 @@ static void XferSendComplete(PurpleXfer *xfer) {
 	std::remove(np->m_waitingXfers.begin(), np->m_waitingXfers.end(), xfer);
 	FTData *ftdata = (FTData *) xfer->ui_data;
 	if (ftdata && ftdata->timer) {
-		purple_timeout_remove(ftdata->timer);
+		purple_timeout_remove_wrapped(ftdata->timer);
 	}
-	purple_xfer_unref(xfer);
+	purple_xfer_unref_wrapped(xfer);
 }
 
 static gssize XferWrite(PurpleXfer *xfer, const guchar *buffer, gssize size) {
@@ -1354,15 +1354,15 @@ static PurpleXferUiOps xferUiOps =
 
 static void transport_core_ui_init(void)
 {
-	purple_blist_set_ui_ops(&blistUiOps);
-	purple_accounts_set_ui_ops(&accountUiOps);
-	purple_notify_set_ui_ops(&notifyUiOps);
-	purple_request_set_ui_ops(&requestUiOps);
-	purple_xfers_set_ui_ops(&xferUiOps);
-	purple_connections_set_ui_ops(&conn_ui_ops);
-	purple_conversations_set_ui_ops(&conversation_ui_ops);
+	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(getDNSUiOps());
+// 	purple_dnsquery_set_ui_ops_wrapped(getDNSUiOps());
 // #endif
 }
 
@@ -1395,10 +1395,10 @@ spectrum_glib_log_handler(const gchar *domain,
 	}
 
 	if (message != NULL)
-		new_msg = purple_utf8_try_convert(message);
+		new_msg = purple_utf8_try_convert_wrapped(message);
 
 	if (domain != NULL)
-		new_domain = purple_utf8_try_convert(domain);
+		new_domain = purple_utf8_try_convert_wrapped(domain);
 
 	if (new_msg != NULL) {
 		std::string area("glib");
@@ -1449,7 +1449,7 @@ static PurpleCoreUiOps coreUiOps =
 };
 
 static void signed_on(PurpleConnection *gc, gpointer unused) {
-	PurpleAccount *account = purple_connection_get_account(gc);
+	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
@@ -1488,7 +1488,7 @@ static PurpleDebugUiOps debugUiOps =
 };
 
 static void buddyTyping(PurpleAccount *account, const char *who, gpointer null) {
-	std::string w = purple_normalize(account, who);
+	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);
@@ -1496,7 +1496,7 @@ static void buddyTyping(PurpleAccount *account, const char *who, gpointer null)
 }
 
 static void buddyTyped(PurpleAccount *account, const char *who, gpointer null) {
-	std::string w = purple_normalize(account, who);
+	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);
@@ -1504,7 +1504,7 @@ static void buddyTyped(PurpleAccount *account, const char *who, gpointer null) {
 }
 
 static void buddyTypingStopped(PurpleAccount *account, const char *who, gpointer null){
-	std::string w = purple_normalize(account, who);
+	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);
@@ -1512,7 +1512,7 @@ static void buddyTypingStopped(PurpleAccount *account, const char *who, gpointer
 }
 
 static void gotAttention(PurpleAccount *account, const char *who, PurpleConversation *conv, guint type) {
-	std::string w = purple_normalize(account, who);
+	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);
@@ -1527,71 +1527,71 @@ static bool initPurple() {
 		return false;
 	}
 
-	purple_plugins_add_search_path("./plugins");
+	purple_plugins_add_search_path_wrapped("./plugins");
 
-	purple_util_set_user_dir("./");
+	purple_util_set_user_dir_wrapped("./");
 	remove("./accounts.xml");
 	remove("./blist.xml");
 
-	purple_debug_set_ui_ops(&debugUiOps);
-	purple_debug_set_verbose(true);
+	purple_debug_set_ui_ops_wrapped(&debugUiOps);
+	purple_debug_set_verbose_wrapped(true);
 
-	purple_core_set_ui_ops(&coreUiOps);
+	purple_core_set_ui_ops_wrapped(&coreUiOps);
 	if (CONFIG_STRING_DEFAULTED(config, "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(CONFIG_STRING_DEFAULTED(config, "service.eventloop", "") == "libev"));
+	purple_eventloop_set_ui_ops_wrapped(getEventLoopUiOps(CONFIG_STRING_DEFAULTED(config, "service.eventloop", "") == "libev"));
 
-	ret = purple_core_init("spectrum");
+	ret = purple_core_init_wrapped("spectrum");
 	if (ret) {
 		static int blist_handle;
 		static int conversation_handle;
 
-		purple_set_blist(purple_blist_new());
-		purple_blist_load();
+		purple_set_blist_wrapped(purple_blist_new_wrapped());
+		purple_blist_load_wrapped();
 
-		purple_prefs_load();
+		purple_prefs_load_wrapped();
 
 		/* 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);
+		purple_prefs_set_bool_wrapped("/purple/away/away_when_idle", false);
 		/*
 		 * This must be set to something not "none" for idle reporting to work
 		 * for, e.g., the OSCAR prpl. We don't implement the UI ops, so this is
 		 * okay for now.
 		 */
-		purple_prefs_set_string("/purple/away/idle_reporting", "system");
+		purple_prefs_set_string_wrapped("/purple/away/idle_reporting", "system");
 
 		/* Disable all logging */
-		purple_prefs_set_bool("/purple/logging/log_ims", false);
-		purple_prefs_set_bool("/purple/logging/log_chats", false);
-		purple_prefs_set_bool("/purple/logging/log_system", false);
+		purple_prefs_set_bool_wrapped("/purple/logging/log_ims", false);
+		purple_prefs_set_bool_wrapped("/purple/logging/log_chats", false);
+		purple_prefs_set_bool_wrapped("/purple/logging/log_system", false);
 
 
-// 		purple_signal_connect(purple_conversations_get_handle(), "received-im-msg", &conversation_handle, PURPLE_CALLBACK(newMessageReceived), NULL);
-		purple_signal_connect(purple_conversations_get_handle(), "buddy-typing", &conversation_handle, PURPLE_CALLBACK(buddyTyping), NULL);
-		purple_signal_connect(purple_conversations_get_handle(), "buddy-typed", &conversation_handle, PURPLE_CALLBACK(buddyTyped), NULL);
-		purple_signal_connect(purple_conversations_get_handle(), "buddy-typing-stopped", &conversation_handle, PURPLE_CALLBACK(buddyTypingStopped), NULL);
-		purple_signal_connect(purple_blist_get_handle(), "buddy-privacy-changed", &conversation_handle, PURPLE_CALLBACK(buddyPrivacyChanged), NULL);
-		purple_signal_connect(purple_conversations_get_handle(), "got-attention", &conversation_handle, PURPLE_CALLBACK(gotAttention), NULL);
-		purple_signal_connect(purple_connections_get_handle(), "signed-on", &blist_handle,PURPLE_CALLBACK(signed_on), NULL);
-// 		purple_signal_connect(purple_blist_get_handle(), "buddy-removed", &blist_handle,PURPLE_CALLBACK(buddyRemoved), NULL);
-// 		purple_signal_connect(purple_blist_get_handle(), "buddy-signed-on", &blist_handle,PURPLE_CALLBACK(buddySignedOn), NULL);
-// 		purple_signal_connect(purple_blist_get_handle(), "buddy-signed-off", &blist_handle,PURPLE_CALLBACK(buddySignedOff), NULL);
-// 		purple_signal_connect(purple_blist_get_handle(), "buddy-status-changed", &blist_handle,PURPLE_CALLBACK(buddyStatusChanged), NULL);
-		purple_signal_connect(purple_blist_get_handle(), "blist-node-removed", &blist_handle,PURPLE_CALLBACK(NodeRemoved), NULL);
-// 		purple_signal_connect(purple_conversations_get_handle(), "chat-topic-changed", &conversation_handle, PURPLE_CALLBACK(conv_chat_topic_changed), NULL);
+// 		purple_signal_connect_wrapped(purple_conversations_get_handle_wrapped(), "received-im-msg", &conversation_handle, PURPLE_CALLBACK(newMessageReceived), NULL);
+		purple_signal_connect_wrapped(purple_conversations_get_handle_wrapped(), "buddy-typing", &conversation_handle, PURPLE_CALLBACK(buddyTyping), NULL);
+		purple_signal_connect_wrapped(purple_conversations_get_handle_wrapped(), "buddy-typed", &conversation_handle, PURPLE_CALLBACK(buddyTyped), NULL);
+		purple_signal_connect_wrapped(purple_conversations_get_handle_wrapped(), "buddy-typing-stopped", &conversation_handle, PURPLE_CALLBACK(buddyTypingStopped), NULL);
+		purple_signal_connect_wrapped(purple_blist_get_handle_wrapped(), "buddy-privacy-changed", &conversation_handle, PURPLE_CALLBACK(buddyPrivacyChanged), NULL);
+		purple_signal_connect_wrapped(purple_conversations_get_handle_wrapped(), "got-attention", &conversation_handle, PURPLE_CALLBACK(gotAttention), NULL);
+		purple_signal_connect_wrapped(purple_connections_get_handle_wrapped(), "signed-on", &blist_handle,PURPLE_CALLBACK(signed_on), NULL);
+// 		purple_signal_connect_wrapped(purple_blist_get_handle_wrapped(), "buddy-removed", &blist_handle,PURPLE_CALLBACK(buddyRemoved), NULL);
+// 		purple_signal_connect_wrapped(purple_blist_get_handle_wrapped(), "buddy-signed-on", &blist_handle,PURPLE_CALLBACK(buddySignedOn), NULL);
+// 		purple_signal_connect_wrapped(purple_blist_get_handle_wrapped(), "buddy-signed-off", &blist_handle,PURPLE_CALLBACK(buddySignedOff), NULL);
+// 		purple_signal_connect_wrapped(purple_blist_get_handle_wrapped(), "buddy-status-changed", &blist_handle,PURPLE_CALLBACK(buddyStatusChanged), NULL);
+		purple_signal_connect_wrapped(purple_blist_get_handle_wrapped(), "blist-node-removed", &blist_handle,PURPLE_CALLBACK(NodeRemoved), NULL);
+// 		purple_signal_connect_wrapped(purple_conversations_get_handle_wrapped(), "chat-topic-changed", &conversation_handle, PURPLE_CALLBACK(conv_chat_topic_changed), NULL);
 		static int xfer_handle;
-		purple_signal_connect(purple_xfers_get_handle(), "file-send-start", &xfer_handle, PURPLE_CALLBACK(fileSendStart), NULL);
-		purple_signal_connect(purple_xfers_get_handle(), "file-recv-start", &xfer_handle, PURPLE_CALLBACK(fileRecvStart), NULL);
-		purple_signal_connect(purple_xfers_get_handle(), "file-recv-request", &xfer_handle, PURPLE_CALLBACK(newXfer), NULL);
-		purple_signal_connect(purple_xfers_get_handle(), "file-recv-complete", &xfer_handle, PURPLE_CALLBACK(XferReceiveComplete), NULL);
-		purple_signal_connect(purple_xfers_get_handle(), "file-send-complete", &xfer_handle, PURPLE_CALLBACK(XferSendComplete), NULL);
+		purple_signal_connect_wrapped(purple_xfers_get_handle_wrapped(), "file-send-start", &xfer_handle, PURPLE_CALLBACK(fileSendStart), NULL);
+		purple_signal_connect_wrapped(purple_xfers_get_handle_wrapped(), "file-recv-start", &xfer_handle, PURPLE_CALLBACK(fileRecvStart), NULL);
+		purple_signal_connect_wrapped(purple_xfers_get_handle_wrapped(), "file-recv-request", &xfer_handle, PURPLE_CALLBACK(newXfer), NULL);
+		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();
 
@@ -1621,7 +1621,7 @@ static void transportDataReceived(gpointer data, gint source, PurpleInputConditi
 	}
 	else {
 		if (writeInput != 0) {
-			purple_input_remove(writeInput);
+			purple_input_remove_wrapped(writeInput);
 			writeInput = 0;
 		}
 		np->readyForData();
@@ -1691,8 +1691,8 @@ int main(int argc, char **argv) {
 	initPurple();
  
 	main_socket = create_socket(host.c_str(), port);
-	purple_input_add(main_socket, PURPLE_INPUT_READ, &transportDataReceived, NULL);
-	purple_timeout_add_seconds(30, pingTimeout, NULL);
+	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";
diff --git a/backends/libpurple/purple_defs.cpp b/backends/libpurple/purple_defs.cpp
index c6df1b68..6384d087 100644
--- a/backends/libpurple/purple_defs.cpp
+++ b/backends/libpurple/purple_defs.cpp
@@ -1,5 +1,684 @@
 #include "purple_defs.h"
+
+#ifdef WIN32
+static HMODULE f_hPurple = 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_request_set_ui_ops_wrapped_fnc purple_request_set_ui_ops_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_markup_escape_text_wrapped_fnc purple_markup_escape_text_wrapped = NULL;
+purple_markup_strip_html_wrapped_fnc purple_markup_strip_html_wrapped = NULL;
+purple_normalize_wrapped_fnc purple_normalize_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_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;
+purple_blist_node_get_type_wrapped_fnc purple_blist_node_get_type_wrapped = NULL;
+purple_buddy_get_alias_wrapped_fnc purple_buddy_get_alias_wrapped = NULL;
+purple_buddy_get_server_alias_wrapped_fnc purple_buddy_get_server_alias_wrapped = NULL;
+purple_find_buddy_wrapped_fnc purple_find_buddy_wrapped = NULL;
+purple_buddy_get_group_wrapped_fnc purple_buddy_get_group_wrapped = NULL;
+purple_blist_remove_buddy_wrapped_fnc purple_blist_remove_buddy_wrapped = NULL;
+purple_blist_alias_buddy_wrapped_fnc purple_blist_alias_buddy_wrapped = NULL;
+purple_blist_server_alias_buddy_wrapped_fnc purple_blist_server_alias_buddy_wrapped = NULL;
+purple_find_group_wrapped_fnc purple_find_group_wrapped = NULL;
+purple_group_new_wrapped_fnc purple_group_new_wrapped = NULL;
+purple_blist_add_contact_wrapped_fnc purple_blist_add_contact_wrapped = NULL;
+purple_buddy_get_contact_wrapped_fnc purple_buddy_get_contact_wrapped = NULL;
+purple_buddy_new_wrapped_fnc purple_buddy_new_wrapped = NULL;
+purple_blist_add_buddy_wrapped_fnc purple_blist_add_buddy_wrapped = NULL;
+purple_blist_find_chat_wrapped_fnc purple_blist_find_chat_wrapped = NULL;
+purple_chat_get_components_wrapped_fnc purple_chat_get_components_wrapped = NULL;
+purple_buddy_get_presence_wrapped_fnc purple_buddy_get_presence_wrapped = NULL;
+purple_buddy_get_account_wrapped_fnc purple_buddy_get_account_wrapped = NULL;
+purple_buddy_get_name_wrapped_fnc purple_buddy_get_name_wrapped = NULL;
+purple_find_buddies_wrapped_fnc purple_find_buddies_wrapped = NULL;
+purple_group_get_name_wrapped_fnc purple_group_get_name_wrapped = NULL;
+purple_blist_set_ui_ops_wrapped_fnc purple_blist_set_ui_ops_wrapped = NULL;
+purple_set_blist_wrapped_fnc purple_set_blist_wrapped = NULL;
+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_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_signal_connect_wrapped_fnc purple_signal_connect_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_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_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_account_set_bool_wrapped_fnc purple_account_set_bool_wrapped = NULL;
+purple_account_get_protocol_id_wrapped_fnc purple_account_get_protocol_id_wrapped = NULL;
+purple_account_set_int_wrapped_fnc purple_account_set_int_wrapped = NULL;
+purple_account_set_string_wrapped_fnc purple_account_set_string_wrapped = NULL;
+purple_account_get_username_wrapped_fnc purple_account_get_username_wrapped = NULL;
+purple_account_set_username_wrapped_fnc purple_account_set_username_wrapped = NULL;
+purple_accounts_find_wrapped_fnc purple_accounts_find_wrapped = NULL;
+purple_account_new_wrapped_fnc purple_account_new_wrapped = NULL;
+purple_accounts_add_wrapped_fnc purple_accounts_add_wrapped = NULL;
+purple_account_set_password_wrapped_fnc purple_account_set_password_wrapped = NULL;
+purple_account_set_enabled_wrapped_fnc purple_account_set_enabled_wrapped = NULL;
+purple_account_set_privacy_type_wrapped_fnc purple_account_set_privacy_type_wrapped = NULL;
+purple_account_get_status_type_with_primitive_wrapped_fnc purple_account_get_status_type_with_primitive_wrapped = NULL;
+purple_account_set_status_wrapped_fnc purple_account_set_status_wrapped = NULL;
+purple_account_get_int_wrapped_fnc purple_account_get_int_wrapped = NULL;
+purple_account_disconnect_wrapped_fnc purple_account_disconnect_wrapped = NULL;
+purple_accounts_delete_wrapped_fnc purple_accounts_delete_wrapped = NULL;
+purple_account_get_connection_wrapped_fnc purple_account_get_connection_wrapped = NULL;
+purple_account_set_alias_wrapped_fnc purple_account_set_alias_wrapped = NULL;
+purple_account_set_public_alias_wrapped_fnc purple_account_set_public_alias_wrapped = NULL;
+purple_account_remove_buddy_wrapped_fnc purple_account_remove_buddy_wrapped = NULL;
+purple_account_add_buddy_wrapped_fnc purple_account_add_buddy_wrapped = NULL;
+purple_account_get_name_for_display_wrapped_fnc purple_account_get_name_for_display_wrapped = NULL;
+purple_accounts_set_ui_ops_wrapped_fnc purple_accounts_set_ui_ops_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;
+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_dnsquery_set_ui_ops_wrapped_fnc purple_dnsquery_set_ui_ops_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_plugin_action_free_wrapped_fnc purple_plugin_action_free_wrapped = NULL;
+purple_plugins_add_search_path_wrapped_fnc purple_plugins_add_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_core_set_ui_ops_wrapped_fnc purple_core_set_ui_ops_wrapped = NULL;
+purple_core_init_wrapped_fnc purple_core_init_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_timeout_remove_wrapped_fnc purple_timeout_remove_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_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_find_prpl_wrapped_fnc purple_find_prpl_wrapped = NULL;
+purple_prpl_send_attention_wrapped_fnc purple_prpl_send_attention_wrapped = NULL;
+purple_account_option_get_type_wrapped_fnc purple_account_option_get_type_wrapped = NULL;
+purple_account_option_get_setting_wrapped_fnc purple_account_option_get_setting_wrapped = NULL;
+wpurple_g_io_channel_win32_new_socket_wrapped_fnc wpurple_g_io_channel_win32_new_socket_wrapped = NULL;
+#endif
 bool resolvePurpleFunctions() {
+#ifdef WIN32
+	f_hPurple = LoadLibrary("libpurple.dll");
+	if (!f_hPurple)
+			return false;
+	purple_debug_set_ui_ops_wrapped = (purple_debug_set_ui_ops_wrapped_fnc)GetProcAddress(f_hPurple, "purple_debug_set_ui_ops");
+	if (!purple_debug_set_ui_ops_wrapped)
+		return false;
+
+	purple_debug_set_verbose_wrapped = (purple_debug_set_verbose_wrapped_fnc)GetProcAddress(f_hPurple, "purple_debug_set_verbose");
+	if (!purple_debug_set_verbose_wrapped)
+		return false;
+
+	purple_request_set_ui_ops_wrapped = (purple_request_set_ui_ops_wrapped_fnc)GetProcAddress(f_hPurple, "purple_request_set_ui_ops");
+	if (!purple_request_set_ui_ops_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_markup_escape_text_wrapped = (purple_markup_escape_text_wrapped_fnc)GetProcAddress(f_hPurple, "purple_markup_escape_text");
+	if (!purple_markup_escape_text_wrapped)
+		return false;
+
+	purple_markup_strip_html_wrapped = (purple_markup_strip_html_wrapped_fnc)GetProcAddress(f_hPurple, "purple_markup_strip_html");
+	if (!purple_markup_strip_html_wrapped)
+		return false;
+
+	purple_normalize_wrapped = (purple_normalize_wrapped_fnc)GetProcAddress(f_hPurple, "purple_normalize");
+	if (!purple_normalize_wrapped)
+		return false;
+
+	purple_strdup_withhtml_wrapped = (purple_strdup_withhtml_wrapped_fnc)GetProcAddress(f_hPurple, "purple_strdup_withhtml");
+	if (!purple_strdup_withhtml_wrapped)
+		return false;
+
+	purple_markup_html_to_xhtml_wrapped = (purple_markup_html_to_xhtml_wrapped_fnc)GetProcAddress(f_hPurple, "purple_markup_html_to_xhtml");
+	if (!purple_markup_html_to_xhtml_wrapped)
+		return false;
+
+	purple_utf8_try_convert_wrapped = (purple_utf8_try_convert_wrapped_fnc)GetProcAddress(f_hPurple, "purple_utf8_try_convert");
+	if (!purple_utf8_try_convert_wrapped)
+		return false;
+
+	purple_util_set_user_dir_wrapped = (purple_util_set_user_dir_wrapped_fnc)GetProcAddress(f_hPurple, "purple_util_set_user_dir");
+	if (!purple_util_set_user_dir_wrapped)
+		return false;
+
+	purple_blist_node_get_type_wrapped = (purple_blist_node_get_type_wrapped_fnc)GetProcAddress(f_hPurple, "purple_blist_node_get_type");
+	if (!purple_blist_node_get_type_wrapped)
+		return false;
+
+	purple_buddy_get_alias_wrapped = (purple_buddy_get_alias_wrapped_fnc)GetProcAddress(f_hPurple, "purple_buddy_get_alias");
+	if (!purple_buddy_get_alias_wrapped)
+		return false;
+
+	purple_buddy_get_server_alias_wrapped = (purple_buddy_get_server_alias_wrapped_fnc)GetProcAddress(f_hPurple, "purple_buddy_get_server_alias");
+	if (!purple_buddy_get_server_alias_wrapped)
+		return false;
+
+	purple_find_buddy_wrapped = (purple_find_buddy_wrapped_fnc)GetProcAddress(f_hPurple, "purple_find_buddy");
+	if (!purple_find_buddy_wrapped)
+		return false;
+
+	purple_buddy_get_group_wrapped = (purple_buddy_get_group_wrapped_fnc)GetProcAddress(f_hPurple, "purple_buddy_get_group");
+	if (!purple_buddy_get_group_wrapped)
+		return false;
+
+	purple_blist_remove_buddy_wrapped = (purple_blist_remove_buddy_wrapped_fnc)GetProcAddress(f_hPurple, "purple_blist_remove_buddy");
+	if (!purple_blist_remove_buddy_wrapped)
+		return false;
+
+	purple_blist_alias_buddy_wrapped = (purple_blist_alias_buddy_wrapped_fnc)GetProcAddress(f_hPurple, "purple_blist_alias_buddy");
+	if (!purple_blist_alias_buddy_wrapped)
+		return false;
+
+	purple_blist_server_alias_buddy_wrapped = (purple_blist_server_alias_buddy_wrapped_fnc)GetProcAddress(f_hPurple, "purple_blist_server_alias_buddy");
+	if (!purple_blist_server_alias_buddy_wrapped)
+		return false;
+
+	purple_find_group_wrapped = (purple_find_group_wrapped_fnc)GetProcAddress(f_hPurple, "purple_find_group");
+	if (!purple_find_group_wrapped)
+		return false;
+
+	purple_group_new_wrapped = (purple_group_new_wrapped_fnc)GetProcAddress(f_hPurple, "purple_group_new");
+	if (!purple_group_new_wrapped)
+		return false;
+
+	purple_blist_add_contact_wrapped = (purple_blist_add_contact_wrapped_fnc)GetProcAddress(f_hPurple, "purple_blist_add_contact");
+	if (!purple_blist_add_contact_wrapped)
+		return false;
+
+	purple_buddy_get_contact_wrapped = (purple_buddy_get_contact_wrapped_fnc)GetProcAddress(f_hPurple, "purple_buddy_get_contact");
+	if (!purple_buddy_get_contact_wrapped)
+		return false;
+
+	purple_buddy_new_wrapped = (purple_buddy_new_wrapped_fnc)GetProcAddress(f_hPurple, "purple_buddy_new");
+	if (!purple_buddy_new_wrapped)
+		return false;
+
+	purple_blist_add_buddy_wrapped = (purple_blist_add_buddy_wrapped_fnc)GetProcAddress(f_hPurple, "purple_blist_add_buddy");
+	if (!purple_blist_add_buddy_wrapped)
+		return false;
+
+	purple_blist_find_chat_wrapped = (purple_blist_find_chat_wrapped_fnc)GetProcAddress(f_hPurple, "purple_blist_find_chat");
+	if (!purple_blist_find_chat_wrapped)
+		return false;
+
+	purple_chat_get_components_wrapped = (purple_chat_get_components_wrapped_fnc)GetProcAddress(f_hPurple, "purple_chat_get_components");
+	if (!purple_chat_get_components_wrapped)
+		return false;
+
+	purple_buddy_get_presence_wrapped = (purple_buddy_get_presence_wrapped_fnc)GetProcAddress(f_hPurple, "purple_buddy_get_presence");
+	if (!purple_buddy_get_presence_wrapped)
+		return false;
+
+	purple_buddy_get_account_wrapped = (purple_buddy_get_account_wrapped_fnc)GetProcAddress(f_hPurple, "purple_buddy_get_account");
+	if (!purple_buddy_get_account_wrapped)
+		return false;
+
+	purple_buddy_get_name_wrapped = (purple_buddy_get_name_wrapped_fnc)GetProcAddress(f_hPurple, "purple_buddy_get_name");
+	if (!purple_buddy_get_name_wrapped)
+		return false;
+
+	purple_find_buddies_wrapped = (purple_find_buddies_wrapped_fnc)GetProcAddress(f_hPurple, "purple_find_buddies");
+	if (!purple_find_buddies_wrapped)
+		return false;
+
+	purple_group_get_name_wrapped = (purple_group_get_name_wrapped_fnc)GetProcAddress(f_hPurple, "purple_group_get_name");
+	if (!purple_group_get_name_wrapped)
+		return false;
+
+	purple_blist_set_ui_ops_wrapped = (purple_blist_set_ui_ops_wrapped_fnc)GetProcAddress(f_hPurple, "purple_blist_set_ui_ops");
+	if (!purple_blist_set_ui_ops_wrapped)
+		return false;
+
+	purple_set_blist_wrapped = (purple_set_blist_wrapped_fnc)GetProcAddress(f_hPurple, "purple_set_blist");
+	if (!purple_set_blist_wrapped)
+		return false;
+
+	purple_blist_new_wrapped = (purple_blist_new_wrapped_fnc)GetProcAddress(f_hPurple, "purple_blist_new");
+	if (!purple_blist_new_wrapped)
+		return false;
+
+	purple_blist_load_wrapped = (purple_blist_load_wrapped_fnc)GetProcAddress(f_hPurple, "purple_blist_load");
+	if (!purple_blist_load_wrapped)
+		return false;
+
+	purple_blist_get_handle_wrapped = (purple_blist_get_handle_wrapped_fnc)GetProcAddress(f_hPurple, "purple_blist_get_handle");
+	if (!purple_blist_get_handle_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_signal_connect_wrapped = (purple_signal_connect_wrapped_fnc)GetProcAddress(f_hPurple, "purple_signal_connect");
+	if (!purple_signal_connect_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;
+
+	purple_prefs_set_bool_wrapped = (purple_prefs_set_bool_wrapped_fnc)GetProcAddress(f_hPurple, "purple_prefs_set_bool");
+	if (!purple_prefs_set_bool_wrapped)
+		return false;
+
+	purple_prefs_set_string_wrapped = (purple_prefs_set_string_wrapped_fnc)GetProcAddress(f_hPurple, "purple_prefs_set_string");
+	if (!purple_prefs_set_string_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_buddy_icons_set_account_icon_wrapped = (purple_buddy_icons_set_account_icon_wrapped_fnc)GetProcAddress(f_hPurple, "purple_buddy_icons_set_account_icon");
+	if (!purple_buddy_icons_set_account_icon_wrapped)
+		return false;
+
+	purple_buddy_icons_find_wrapped = (purple_buddy_icons_find_wrapped_fnc)GetProcAddress(f_hPurple, "purple_buddy_icons_find");
+	if (!purple_buddy_icons_find_wrapped)
+		return false;
+
+	purple_buddy_icon_get_full_path_wrapped = (purple_buddy_icon_get_full_path_wrapped_fnc)GetProcAddress(f_hPurple, "purple_buddy_icon_get_full_path");
+	if (!purple_buddy_icon_get_full_path_wrapped)
+		return false;
+
+	purple_buddy_icon_unref_wrapped = (purple_buddy_icon_unref_wrapped_fnc)GetProcAddress(f_hPurple, "purple_buddy_icon_unref");
+	if (!purple_buddy_icon_unref_wrapped)
+		return false;
+
+	purple_buddy_icons_find_account_icon_wrapped = (purple_buddy_icons_find_account_icon_wrapped_fnc)GetProcAddress(f_hPurple, "purple_buddy_icons_find_account_icon");
+	if (!purple_buddy_icons_find_account_icon_wrapped)
+		return false;
+
+	purple_buddy_icon_get_data_wrapped = (purple_buddy_icon_get_data_wrapped_fnc)GetProcAddress(f_hPurple, "purple_buddy_icon_get_data");
+	if (!purple_buddy_icon_get_data_wrapped)
+		return false;
+
+	purple_account_set_bool_wrapped = (purple_account_set_bool_wrapped_fnc)GetProcAddress(f_hPurple, "purple_account_set_bool");
+	if (!purple_account_set_bool_wrapped)
+		return false;
+
+	purple_account_get_protocol_id_wrapped = (purple_account_get_protocol_id_wrapped_fnc)GetProcAddress(f_hPurple, "purple_account_get_protocol_id");
+	if (!purple_account_get_protocol_id_wrapped)
+		return false;
+
+	purple_account_set_int_wrapped = (purple_account_set_int_wrapped_fnc)GetProcAddress(f_hPurple, "purple_account_set_int");
+	if (!purple_account_set_int_wrapped)
+		return false;
+
+	purple_account_set_string_wrapped = (purple_account_set_string_wrapped_fnc)GetProcAddress(f_hPurple, "purple_account_set_string");
+	if (!purple_account_set_string_wrapped)
+		return false;
+
+	purple_account_get_username_wrapped = (purple_account_get_username_wrapped_fnc)GetProcAddress(f_hPurple, "purple_account_get_username");
+	if (!purple_account_get_username_wrapped)
+		return false;
+
+	purple_account_set_username_wrapped = (purple_account_set_username_wrapped_fnc)GetProcAddress(f_hPurple, "purple_account_set_username");
+	if (!purple_account_set_username_wrapped)
+		return false;
+
+	purple_accounts_find_wrapped = (purple_accounts_find_wrapped_fnc)GetProcAddress(f_hPurple, "purple_accounts_find");
+	if (!purple_accounts_find_wrapped)
+		return false;
+
+	purple_account_new_wrapped = (purple_account_new_wrapped_fnc)GetProcAddress(f_hPurple, "purple_account_new");
+	if (!purple_account_new_wrapped)
+		return false;
+
+	purple_accounts_add_wrapped = (purple_accounts_add_wrapped_fnc)GetProcAddress(f_hPurple, "purple_accounts_add");
+	if (!purple_accounts_add_wrapped)
+		return false;
+
+	purple_account_set_password_wrapped = (purple_account_set_password_wrapped_fnc)GetProcAddress(f_hPurple, "purple_account_set_password");
+	if (!purple_account_set_password_wrapped)
+		return false;
+
+	purple_account_set_enabled_wrapped = (purple_account_set_enabled_wrapped_fnc)GetProcAddress(f_hPurple, "purple_account_set_enabled");
+	if (!purple_account_set_enabled_wrapped)
+		return false;
+
+	purple_account_set_privacy_type_wrapped = (purple_account_set_privacy_type_wrapped_fnc)GetProcAddress(f_hPurple, "purple_account_set_privacy_type");
+	if (!purple_account_set_privacy_type_wrapped)
+		return false;
+
+	purple_account_get_status_type_with_primitive_wrapped = (purple_account_get_status_type_with_primitive_wrapped_fnc)GetProcAddress(f_hPurple, "purple_account_get_status_type_with_primitive");
+	if (!purple_account_get_status_type_with_primitive_wrapped)
+		return false;
+
+	purple_account_set_status_wrapped = (purple_account_set_status_wrapped_fnc)GetProcAddress(f_hPurple, "purple_account_set_status");
+	if (!purple_account_set_status_wrapped)
+		return false;
+
+	purple_account_get_int_wrapped = (purple_account_get_int_wrapped_fnc)GetProcAddress(f_hPurple, "purple_account_get_int");
+	if (!purple_account_get_int_wrapped)
+		return false;
+
+	purple_account_disconnect_wrapped = (purple_account_disconnect_wrapped_fnc)GetProcAddress(f_hPurple, "purple_account_disconnect");
+	if (!purple_account_disconnect_wrapped)
+		return false;
+
+	purple_accounts_delete_wrapped = (purple_accounts_delete_wrapped_fnc)GetProcAddress(f_hPurple, "purple_accounts_delete");
+	if (!purple_accounts_delete_wrapped)
+		return false;
+
+	purple_account_get_connection_wrapped = (purple_account_get_connection_wrapped_fnc)GetProcAddress(f_hPurple, "purple_account_get_connection");
+	if (!purple_account_get_connection_wrapped)
+		return false;
+
+	purple_account_set_alias_wrapped = (purple_account_set_alias_wrapped_fnc)GetProcAddress(f_hPurple, "purple_account_set_alias");
+	if (!purple_account_set_alias_wrapped)
+		return false;
+
+	purple_account_set_public_alias_wrapped = (purple_account_set_public_alias_wrapped_fnc)GetProcAddress(f_hPurple, "purple_account_set_public_alias");
+	if (!purple_account_set_public_alias_wrapped)
+		return false;
+
+	purple_account_remove_buddy_wrapped = (purple_account_remove_buddy_wrapped_fnc)GetProcAddress(f_hPurple, "purple_account_remove_buddy");
+	if (!purple_account_remove_buddy_wrapped)
+		return false;
+
+	purple_account_add_buddy_wrapped = (purple_account_add_buddy_wrapped_fnc)GetProcAddress(f_hPurple, "purple_account_add_buddy");
+	if (!purple_account_add_buddy_wrapped)
+		return false;
+
+	purple_account_get_name_for_display_wrapped = (purple_account_get_name_for_display_wrapped_fnc)GetProcAddress(f_hPurple, "purple_account_get_name_for_display");
+	if (!purple_account_get_name_for_display_wrapped)
+		return false;
+
+	purple_accounts_set_ui_ops_wrapped = (purple_accounts_set_ui_ops_wrapped_fnc)GetProcAddress(f_hPurple, "purple_accounts_set_ui_ops");
+	if (!purple_accounts_set_ui_ops_wrapped)
+		return false;
+
+	purple_status_type_get_id_wrapped = (purple_status_type_get_id_wrapped_fnc)GetProcAddress(f_hPurple, "purple_status_type_get_id");
+	if (!purple_status_type_get_id_wrapped)
+		return false;
+
+	purple_presence_get_active_status_wrapped = (purple_presence_get_active_status_wrapped_fnc)GetProcAddress(f_hPurple, "purple_presence_get_active_status");
+	if (!purple_presence_get_active_status_wrapped)
+		return false;
+
+	purple_status_type_get_primitive_wrapped = (purple_status_type_get_primitive_wrapped_fnc)GetProcAddress(f_hPurple, "purple_status_type_get_primitive");
+	if (!purple_status_type_get_primitive_wrapped)
+		return false;
+
+	purple_status_get_type_wrapped = (purple_status_get_type_wrapped_fnc)GetProcAddress(f_hPurple, "purple_status_get_type");
+	if (!purple_status_get_type_wrapped)
+		return false;
+
+	purple_status_get_attr_string_wrapped = (purple_status_get_attr_string_wrapped_fnc)GetProcAddress(f_hPurple, "purple_status_get_attr_string");
+	if (!purple_status_get_attr_string_wrapped)
+		return false;
+
+	serv_get_info_wrapped = (serv_get_info_wrapped_fnc)GetProcAddress(f_hPurple, "serv_get_info");
+	if (!serv_get_info_wrapped)
+		return false;
+
+	serv_alias_buddy_wrapped = (serv_alias_buddy_wrapped_fnc)GetProcAddress(f_hPurple, "serv_alias_buddy");
+	if (!serv_alias_buddy_wrapped)
+		return false;
+
+	serv_send_typing_wrapped = (serv_send_typing_wrapped_fnc)GetProcAddress(f_hPurple, "serv_send_typing");
+	if (!serv_send_typing_wrapped)
+		return false;
+
+	serv_join_chat_wrapped = (serv_join_chat_wrapped_fnc)GetProcAddress(f_hPurple, "serv_join_chat");
+	if (!serv_join_chat_wrapped)
+		return false;
+
+	purple_dnsquery_set_ui_ops_wrapped = (purple_dnsquery_set_ui_ops_wrapped_fnc)GetProcAddress(f_hPurple, "purple_dnsquery_set_ui_ops");
+	if (!purple_dnsquery_set_ui_ops_wrapped)
+		return false;
+
+	purple_conversation_get_im_data_wrapped = (purple_conversation_get_im_data_wrapped_fnc)GetProcAddress(f_hPurple, "purple_conversation_get_im_data");
+	if (!purple_conversation_get_im_data_wrapped)
+		return false;
+
+	purple_conversation_get_chat_data_wrapped = (purple_conversation_get_chat_data_wrapped_fnc)GetProcAddress(f_hPurple, "purple_conversation_get_chat_data");
+	if (!purple_conversation_get_chat_data_wrapped)
+		return false;
+
+	purple_find_conversation_with_account_wrapped = (purple_find_conversation_with_account_wrapped_fnc)GetProcAddress(f_hPurple, "purple_find_conversation_with_account");
+	if (!purple_find_conversation_with_account_wrapped)
+		return false;
+
+	purple_conversation_new_wrapped = (purple_conversation_new_wrapped_fnc)GetProcAddress(f_hPurple, "purple_conversation_new");
+	if (!purple_conversation_new_wrapped)
+		return false;
+
+	purple_conversation_get_type_wrapped = (purple_conversation_get_type_wrapped_fnc)GetProcAddress(f_hPurple, "purple_conversation_get_type");
+	if (!purple_conversation_get_type_wrapped)
+		return false;
+
+	purple_conv_im_send_wrapped = (purple_conv_im_send_wrapped_fnc)GetProcAddress(f_hPurple, "purple_conv_im_send");
+	if (!purple_conv_im_send_wrapped)
+		return false;
+
+	purple_conv_chat_send_wrapped = (purple_conv_chat_send_wrapped_fnc)GetProcAddress(f_hPurple, "purple_conv_chat_send");
+	if (!purple_conv_chat_send_wrapped)
+		return false;
+
+	purple_conversation_destroy_wrapped = (purple_conversation_destroy_wrapped_fnc)GetProcAddress(f_hPurple, "purple_conversation_destroy");
+	if (!purple_conversation_destroy_wrapped)
+		return false;
+
+	purple_conversation_get_account_wrapped = (purple_conversation_get_account_wrapped_fnc)GetProcAddress(f_hPurple, "purple_conversation_get_account");
+	if (!purple_conversation_get_account_wrapped)
+		return false;
+
+	purple_conversation_get_name_wrapped = (purple_conversation_get_name_wrapped_fnc)GetProcAddress(f_hPurple, "purple_conversation_get_name");
+	if (!purple_conversation_get_name_wrapped)
+		return false;
+
+	purple_conversations_set_ui_ops_wrapped = (purple_conversations_set_ui_ops_wrapped_fnc)GetProcAddress(f_hPurple, "purple_conversations_set_ui_ops");
+	if (!purple_conversations_set_ui_ops_wrapped)
+		return false;
+
+	purple_conversations_get_handle_wrapped = (purple_conversations_get_handle_wrapped_fnc)GetProcAddress(f_hPurple, "purple_conversations_get_handle");
+	if (!purple_conversations_get_handle_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_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_connection_get_state_wrapped = (purple_connection_get_state_wrapped_fnc)GetProcAddress(f_hPurple, "purple_connection_get_state");
+	if (!purple_connection_get_state_wrapped)
+		return false;
+
+	purple_connection_get_account_wrapped = (purple_connection_get_account_wrapped_fnc)GetProcAddress(f_hPurple, "purple_connection_get_account");
+	if (!purple_connection_get_account_wrapped)
+		return false;
+
+	purple_connection_get_display_name_wrapped = (purple_connection_get_display_name_wrapped_fnc)GetProcAddress(f_hPurple, "purple_connection_get_display_name");
+	if (!purple_connection_get_display_name_wrapped)
+		return false;
+
+	purple_connections_set_ui_ops_wrapped = (purple_connections_set_ui_ops_wrapped_fnc)GetProcAddress(f_hPurple, "purple_connections_set_ui_ops");
+	if (!purple_connections_set_ui_ops_wrapped)
+		return false;
+
+	purple_connections_get_handle_wrapped = (purple_connections_get_handle_wrapped_fnc)GetProcAddress(f_hPurple, "purple_connections_get_handle");
+	if (!purple_connections_get_handle_wrapped)
+		return false;
+
+	purple_core_set_ui_ops_wrapped = (purple_core_set_ui_ops_wrapped_fnc)GetProcAddress(f_hPurple, "purple_core_set_ui_ops");
+	if (!purple_core_set_ui_ops_wrapped)
+		return false;
+
+	purple_core_init_wrapped = (purple_core_init_wrapped_fnc)GetProcAddress(f_hPurple, "purple_core_init");
+	if (!purple_core_init_wrapped)
+		return false;
+
+	purple_input_add_wrapped = (purple_input_add_wrapped_fnc)GetProcAddress(f_hPurple, "purple_input_add");
+	if (!purple_input_add_wrapped)
+		return false;
+
+	purple_timeout_add_wrapped = (purple_timeout_add_wrapped_fnc)GetProcAddress(f_hPurple, "purple_timeout_add");
+	if (!purple_timeout_add_wrapped)
+		return false;
+
+	purple_timeout_add_seconds_wrapped = (purple_timeout_add_seconds_wrapped_fnc)GetProcAddress(f_hPurple, "purple_timeout_add_seconds");
+	if (!purple_timeout_add_seconds_wrapped)
+		return false;
+
+	purple_timeout_remove_wrapped = (purple_timeout_remove_wrapped_fnc)GetProcAddress(f_hPurple, "purple_timeout_remove");
+	if (!purple_timeout_remove_wrapped)
+		return false;
+
+	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_privacy_deny_wrapped = (purple_privacy_deny_wrapped_fnc)GetProcAddress(f_hPurple, "purple_privacy_deny");
+	if (!purple_privacy_deny_wrapped)
+		return false;
+
+	purple_privacy_allow_wrapped = (purple_privacy_allow_wrapped_fnc)GetProcAddress(f_hPurple, "purple_privacy_allow");
+	if (!purple_privacy_allow_wrapped)
+		return false;
+
+	purple_privacy_check_wrapped = (purple_privacy_check_wrapped_fnc)GetProcAddress(f_hPurple, "purple_privacy_check");
+	if (!purple_privacy_check_wrapped)
+		return false;
+
+	purple_find_prpl_wrapped = (purple_find_prpl_wrapped_fnc)GetProcAddress(f_hPurple, "purple_find_prpl");
+	if (!purple_find_prpl_wrapped)
+		return false;
+
+	purple_prpl_send_attention_wrapped = (purple_prpl_send_attention_wrapped_fnc)GetProcAddress(f_hPurple, "purple_prpl_send_attention");
+	if (!purple_prpl_send_attention_wrapped)
+		return false;
+
+	purple_account_option_get_type_wrapped = (purple_account_option_get_type_wrapped_fnc)GetProcAddress(f_hPurple, "purple_account_option_get_type");
+	if (!purple_account_option_get_type_wrapped)
+		return false;
+
+	purple_account_option_get_setting_wrapped = (purple_account_option_get_setting_wrapped_fnc)GetProcAddress(f_hPurple, "purple_account_option_get_setting");
+	if (!purple_account_option_get_setting_wrapped)
+		return false;
+
+	wpurple_g_io_channel_win32_new_socket_wrapped = (wpurple_g_io_channel_win32_new_socket_wrapped_fnc)GetProcAddress(f_hPurple, "wpurple_g_io_channel_win32_new_socket");
+	if (!wpurple_g_io_channel_win32_new_socket_wrapped)
+		return false;
+
+#endif
 	return true;
 }
 
diff --git a/backends/libpurple/purple_defs.h b/backends/libpurple/purple_defs.h
index 3058786c..f6bcf660 100644
--- a/backends/libpurple/purple_defs.h
+++ b/backends/libpurple/purple_defs.h
@@ -1,3 +1,570 @@
 #pragma once
+#ifdef WIN32
+
+#include <Windows.h>
+#include <purple.h>
+
+#define PURPLE_BLIST_NODE_IS_CHAT_WRAPPED(n)    (purple_blist_node_get_type_wrapped(n) == PURPLE_BLIST_CHAT_NODE)
+#define PURPLE_BLIST_NODE_IS_BUDDY_WRAPPED(n)   (purple_blist_node_get_type_wrapped(n) == PURPLE_BLIST_BUDDY_NODE)
+#define PURPLE_BLIST_NODE_IS_CONTACT_WRAPPED(n) (purple_blist_node_get_type_wrapped(n) == PURPLE_BLIST_CONTACT_NODE)
+#define PURPLE_BLIST_NODE_IS_GROUP_WRAPPED(n)   (purple_blist_node_get_type_wrapped(n) == PURPLE_BLIST_GROUP_NODE)
+
+#define PURPLE_CONV_IM_WRAPPED(c) (purple_conversation_get_im_data_wrapped(c))
+#define PURPLE_CONV_CHAT_WRAPPED(c) (purple_conversation_get_chat_data_wrapped(c))
+
+#define PURPLE_CONNECTION_IS_CONNECTED_WRAPPED(gc) 	(purple_connection_get_state_wrapped(gc) == PURPLE_CONNECTED)
+
+typedef void  (_cdecl * purple_debug_set_ui_ops_wrapped_fnc)(PurpleDebugUiOps *ops);
+extern purple_debug_set_ui_ops_wrapped_fnc purple_debug_set_ui_ops_wrapped;
+
+typedef void  (_cdecl * purple_debug_set_verbose_wrapped_fnc)(gboolean verbose);
+extern purple_debug_set_verbose_wrapped_fnc purple_debug_set_verbose_wrapped;
+
+typedef void  (_cdecl * purple_request_set_ui_ops_wrapped_fnc)(PurpleRequestUiOps *ops);
+extern purple_request_set_ui_ops_wrapped_fnc purple_request_set_ui_ops_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 gchar * (_cdecl * purple_markup_escape_text_wrapped_fnc)(const gchar *text, gssize length);
+extern purple_markup_escape_text_wrapped_fnc purple_markup_escape_text_wrapped;
+
+typedef char * (_cdecl * purple_markup_strip_html_wrapped_fnc)(const char *str);
+extern purple_markup_strip_html_wrapped_fnc purple_markup_strip_html_wrapped;
+
+typedef const char * (_cdecl * purple_normalize_wrapped_fnc)(const PurpleAccount *account, const char *str);
+extern purple_normalize_wrapped_fnc purple_normalize_wrapped;
+
+typedef gchar * (_cdecl * purple_strdup_withhtml_wrapped_fnc)(const gchar *src);
+extern purple_strdup_withhtml_wrapped_fnc purple_strdup_withhtml_wrapped;
+
+typedef void  (_cdecl * purple_markup_html_to_xhtml_wrapped_fnc)(const char *html, char **dest_xhtml, char **dest_plain);
+extern purple_markup_html_to_xhtml_wrapped_fnc purple_markup_html_to_xhtml_wrapped;
+
+typedef gchar * (_cdecl * purple_utf8_try_convert_wrapped_fnc)(const char *str);
+extern purple_utf8_try_convert_wrapped_fnc purple_utf8_try_convert_wrapped;
+
+typedef void  (_cdecl * purple_util_set_user_dir_wrapped_fnc)(const char *dir);
+extern purple_util_set_user_dir_wrapped_fnc purple_util_set_user_dir_wrapped;
+
+typedef PurpleBlistNodeType  (_cdecl * purple_blist_node_get_type_wrapped_fnc)(PurpleBlistNode *node);
+extern purple_blist_node_get_type_wrapped_fnc purple_blist_node_get_type_wrapped;
+
+typedef const char * (_cdecl * purple_buddy_get_alias_wrapped_fnc)(PurpleBuddy *buddy);
+extern purple_buddy_get_alias_wrapped_fnc purple_buddy_get_alias_wrapped;
+
+typedef const char * (_cdecl * purple_buddy_get_server_alias_wrapped_fnc)(PurpleBuddy *buddy);
+extern purple_buddy_get_server_alias_wrapped_fnc purple_buddy_get_server_alias_wrapped;
+
+typedef PurpleBuddy * (_cdecl * purple_find_buddy_wrapped_fnc)(PurpleAccount *account, const char *name);
+extern purple_find_buddy_wrapped_fnc purple_find_buddy_wrapped;
+
+typedef PurpleGroup * (_cdecl * purple_buddy_get_group_wrapped_fnc)(PurpleBuddy *buddy);
+extern purple_buddy_get_group_wrapped_fnc purple_buddy_get_group_wrapped;
+
+typedef void  (_cdecl * purple_blist_remove_buddy_wrapped_fnc)(PurpleBuddy *buddy);
+extern purple_blist_remove_buddy_wrapped_fnc purple_blist_remove_buddy_wrapped;
+
+typedef void  (_cdecl * purple_blist_alias_buddy_wrapped_fnc)(PurpleBuddy *buddy, const char *alias);
+extern purple_blist_alias_buddy_wrapped_fnc purple_blist_alias_buddy_wrapped;
+
+typedef void  (_cdecl * purple_blist_server_alias_buddy_wrapped_fnc)(PurpleBuddy *buddy, const char *alias);
+extern purple_blist_server_alias_buddy_wrapped_fnc purple_blist_server_alias_buddy_wrapped;
+
+typedef PurpleGroup * (_cdecl * purple_find_group_wrapped_fnc)(const char *name);
+extern purple_find_group_wrapped_fnc purple_find_group_wrapped;
+
+typedef PurpleGroup * (_cdecl * purple_group_new_wrapped_fnc)(const char *name);
+extern purple_group_new_wrapped_fnc purple_group_new_wrapped;
+
+typedef void  (_cdecl * purple_blist_add_contact_wrapped_fnc)(PurpleContact *contact, PurpleGroup *group, PurpleBlistNode *node);
+extern purple_blist_add_contact_wrapped_fnc purple_blist_add_contact_wrapped;
+
+typedef PurpleContact * (_cdecl * purple_buddy_get_contact_wrapped_fnc)(PurpleBuddy *buddy);
+extern purple_buddy_get_contact_wrapped_fnc purple_buddy_get_contact_wrapped;
+
+typedef PurpleBuddy * (_cdecl * purple_buddy_new_wrapped_fnc)(PurpleAccount *account, const char *name, const char *alias);
+extern purple_buddy_new_wrapped_fnc purple_buddy_new_wrapped;
+
+typedef void  (_cdecl * purple_blist_add_buddy_wrapped_fnc)(PurpleBuddy *buddy, PurpleContact *contact, PurpleGroup *group, PurpleBlistNode *node);
+extern purple_blist_add_buddy_wrapped_fnc purple_blist_add_buddy_wrapped;
+
+typedef PurpleChat * (_cdecl * purple_blist_find_chat_wrapped_fnc)(PurpleAccount *account, const char *name);
+extern purple_blist_find_chat_wrapped_fnc purple_blist_find_chat_wrapped;
+
+typedef GHashTable * (_cdecl * purple_chat_get_components_wrapped_fnc)(PurpleChat *chat);
+extern purple_chat_get_components_wrapped_fnc purple_chat_get_components_wrapped;
+
+typedef PurplePresence * (_cdecl * purple_buddy_get_presence_wrapped_fnc)(const PurpleBuddy *buddy);
+extern purple_buddy_get_presence_wrapped_fnc purple_buddy_get_presence_wrapped;
+
+typedef PurpleAccount * (_cdecl * purple_buddy_get_account_wrapped_fnc)(const PurpleBuddy *buddy);
+extern purple_buddy_get_account_wrapped_fnc purple_buddy_get_account_wrapped;
+
+typedef const char * (_cdecl * purple_buddy_get_name_wrapped_fnc)(const PurpleBuddy *buddy);
+extern purple_buddy_get_name_wrapped_fnc purple_buddy_get_name_wrapped;
+
+typedef GSList * (_cdecl * purple_find_buddies_wrapped_fnc)(PurpleAccount *account, const char *name);
+extern purple_find_buddies_wrapped_fnc purple_find_buddies_wrapped;
+
+typedef const char * (_cdecl * purple_group_get_name_wrapped_fnc)(PurpleGroup *group);
+extern purple_group_get_name_wrapped_fnc purple_group_get_name_wrapped;
+
+typedef void  (_cdecl * purple_blist_set_ui_ops_wrapped_fnc)(PurpleBlistUiOps *ops);
+extern purple_blist_set_ui_ops_wrapped_fnc purple_blist_set_ui_ops_wrapped;
+
+typedef void  (_cdecl * purple_set_blist_wrapped_fnc)(PurpleBuddyList *blist);
+extern purple_set_blist_wrapped_fnc purple_set_blist_wrapped;
+
+typedef PurpleBuddyList * (_cdecl * purple_blist_new_wrapped_fnc)(void);
+extern purple_blist_new_wrapped_fnc purple_blist_new_wrapped;
+
+typedef void  (_cdecl * purple_blist_load_wrapped_fnc)(void);
+extern purple_blist_load_wrapped_fnc purple_blist_load_wrapped;
+
+typedef void * (_cdecl * purple_blist_get_handle_wrapped_fnc)(void);
+extern purple_blist_get_handle_wrapped_fnc purple_blist_get_handle_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 gulong  (_cdecl * purple_signal_connect_wrapped_fnc)(void *instance, const char *signal, void *handle, PurpleCallback func, void *data);
+extern purple_signal_connect_wrapped_fnc purple_signal_connect_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 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 PurpleStoredImage * (_cdecl * purple_buddy_icons_set_account_icon_wrapped_fnc)(PurpleAccount *account, guchar *icon_data, size_t icon_len);
+extern purple_buddy_icons_set_account_icon_wrapped_fnc purple_buddy_icons_set_account_icon_wrapped;
+
+typedef PurpleBuddyIcon * (_cdecl * purple_buddy_icons_find_wrapped_fnc)(PurpleAccount *account, const char *username);
+extern purple_buddy_icons_find_wrapped_fnc purple_buddy_icons_find_wrapped;
+
+typedef char * (_cdecl * purple_buddy_icon_get_full_path_wrapped_fnc)(PurpleBuddyIcon *icon);
+extern purple_buddy_icon_get_full_path_wrapped_fnc purple_buddy_icon_get_full_path_wrapped;
+
+typedef PurpleBuddyIcon * (_cdecl * purple_buddy_icon_unref_wrapped_fnc)(PurpleBuddyIcon *icon);
+extern purple_buddy_icon_unref_wrapped_fnc purple_buddy_icon_unref_wrapped;
+
+typedef PurpleStoredImage * (_cdecl * purple_buddy_icons_find_account_icon_wrapped_fnc)(PurpleAccount *account);
+extern purple_buddy_icons_find_account_icon_wrapped_fnc purple_buddy_icons_find_account_icon_wrapped;
+
+typedef gconstpointer  (_cdecl * purple_buddy_icon_get_data_wrapped_fnc)(const PurpleBuddyIcon *icon, size_t *len);
+extern purple_buddy_icon_get_data_wrapped_fnc purple_buddy_icon_get_data_wrapped;
+
+typedef void  (_cdecl * purple_account_set_bool_wrapped_fnc)(PurpleAccount *account, const char *name, gboolean value);
+extern purple_account_set_bool_wrapped_fnc purple_account_set_bool_wrapped;
+
+typedef const char * (_cdecl * purple_account_get_protocol_id_wrapped_fnc)(const PurpleAccount *account);
+extern purple_account_get_protocol_id_wrapped_fnc purple_account_get_protocol_id_wrapped;
+
+typedef void  (_cdecl * purple_account_set_int_wrapped_fnc)(PurpleAccount *account, const char *name, int value);
+extern purple_account_set_int_wrapped_fnc purple_account_set_int_wrapped;
+
+typedef void  (_cdecl * purple_account_set_string_wrapped_fnc)(PurpleAccount *account, const char *name, const char *value);
+extern purple_account_set_string_wrapped_fnc purple_account_set_string_wrapped;
+
+typedef const char * (_cdecl * purple_account_get_username_wrapped_fnc)(const PurpleAccount *account);
+extern purple_account_get_username_wrapped_fnc purple_account_get_username_wrapped;
+
+typedef void  (_cdecl * purple_account_set_username_wrapped_fnc)(PurpleAccount *account, const char *username);
+extern purple_account_set_username_wrapped_fnc purple_account_set_username_wrapped;
+
+typedef PurpleAccount * (_cdecl * purple_accounts_find_wrapped_fnc)(const char *name, const char *protocol);
+extern purple_accounts_find_wrapped_fnc purple_accounts_find_wrapped;
+
+typedef PurpleAccount * (_cdecl * purple_account_new_wrapped_fnc)(const char *username, const char *protocol_id);
+extern purple_account_new_wrapped_fnc purple_account_new_wrapped;
+
+typedef void  (_cdecl * purple_accounts_add_wrapped_fnc)(PurpleAccount *account);
+extern purple_accounts_add_wrapped_fnc purple_accounts_add_wrapped;
+
+typedef void  (_cdecl * purple_account_set_password_wrapped_fnc)(PurpleAccount *account, const char *password);
+extern purple_account_set_password_wrapped_fnc purple_account_set_password_wrapped;
+
+typedef void  (_cdecl * purple_account_set_enabled_wrapped_fnc)(PurpleAccount *account, const char *ui, gboolean value);
+extern purple_account_set_enabled_wrapped_fnc purple_account_set_enabled_wrapped;
+
+typedef void  (_cdecl * purple_account_set_privacy_type_wrapped_fnc)(PurpleAccount *account, PurplePrivacyType privacy_type);
+extern purple_account_set_privacy_type_wrapped_fnc purple_account_set_privacy_type_wrapped;
+
+typedef PurpleStatusType * (_cdecl * purple_account_get_status_type_with_primitive_wrapped_fnc)( const PurpleAccount *account, PurpleStatusPrimitive primitive);
+extern purple_account_get_status_type_with_primitive_wrapped_fnc purple_account_get_status_type_with_primitive_wrapped;
+
+typedef void  (_cdecl * purple_account_set_status_wrapped_fnc)(PurpleAccount *account, const char *status_id, gboolean active, ...) );
+extern purple_account_set_status_wrapped_fnc purple_account_set_status_wrapped;
+
+typedef int  (_cdecl * purple_account_get_int_wrapped_fnc)(const PurpleAccount *account, const char *name, int default_value);
+extern purple_account_get_int_wrapped_fnc purple_account_get_int_wrapped;
+
+typedef void  (_cdecl * purple_account_disconnect_wrapped_fnc)(PurpleAccount *account);
+extern purple_account_disconnect_wrapped_fnc purple_account_disconnect_wrapped;
+
+typedef void  (_cdecl * purple_accounts_delete_wrapped_fnc)(PurpleAccount *account);
+extern purple_accounts_delete_wrapped_fnc purple_accounts_delete_wrapped;
+
+typedef PurpleConnection * (_cdecl * purple_account_get_connection_wrapped_fnc)(const PurpleAccount *account);
+extern purple_account_get_connection_wrapped_fnc purple_account_get_connection_wrapped;
+
+typedef void  (_cdecl * purple_account_set_alias_wrapped_fnc)(PurpleAccount *account, const char *alias);
+extern purple_account_set_alias_wrapped_fnc purple_account_set_alias_wrapped;
+
+typedef void  (_cdecl * purple_account_set_public_alias_wrapped_fnc)(PurpleAccount *account, const char *alias, PurpleSetPublicAliasSuccessCallback success_cb, PurpleSetPublicAliasFailureCallback failure_cb);
+extern purple_account_set_public_alias_wrapped_fnc purple_account_set_public_alias_wrapped;
+
+typedef void  (_cdecl * purple_account_remove_buddy_wrapped_fnc)(PurpleAccount *account, PurpleBuddy *buddy, PurpleGroup *group);
+extern purple_account_remove_buddy_wrapped_fnc purple_account_remove_buddy_wrapped;
+
+typedef void  (_cdecl * purple_account_add_buddy_wrapped_fnc)(PurpleAccount *account, PurpleBuddy *buddy);
+extern purple_account_add_buddy_wrapped_fnc purple_account_add_buddy_wrapped;
+
+typedef const gchar * (_cdecl * purple_account_get_name_for_display_wrapped_fnc)(const PurpleAccount *account);
+extern purple_account_get_name_for_display_wrapped_fnc purple_account_get_name_for_display_wrapped;
+
+typedef void  (_cdecl * purple_accounts_set_ui_ops_wrapped_fnc)(PurpleAccountUiOps *ops);
+extern purple_accounts_set_ui_ops_wrapped_fnc purple_accounts_set_ui_ops_wrapped;
+
+typedef const char * (_cdecl * purple_status_type_get_id_wrapped_fnc)(const PurpleStatusType *status_type);
+extern purple_status_type_get_id_wrapped_fnc purple_status_type_get_id_wrapped;
+
+typedef PurpleStatus * (_cdecl * purple_presence_get_active_status_wrapped_fnc)(const PurplePresence *presence);
+extern purple_presence_get_active_status_wrapped_fnc purple_presence_get_active_status_wrapped;
+
+typedef PurpleStatusPrimitive  (_cdecl * purple_status_type_get_primitive_wrapped_fnc)( const PurpleStatusType *status_type);
+extern purple_status_type_get_primitive_wrapped_fnc purple_status_type_get_primitive_wrapped;
+
+typedef PurpleStatusType * (_cdecl * purple_status_get_type_wrapped_fnc)(const PurpleStatus *status);
+extern purple_status_get_type_wrapped_fnc purple_status_get_type_wrapped;
+
+typedef const char * (_cdecl * purple_status_get_attr_string_wrapped_fnc)(const PurpleStatus *status, const char *id);
+extern purple_status_get_attr_string_wrapped_fnc purple_status_get_attr_string_wrapped;
+
+typedef void  (_cdecl * serv_get_info_wrapped_fnc)(PurpleConnection *, const char *);
+extern serv_get_info_wrapped_fnc serv_get_info_wrapped;
+
+typedef void  (_cdecl * serv_alias_buddy_wrapped_fnc)(PurpleBuddy *);
+extern serv_alias_buddy_wrapped_fnc serv_alias_buddy_wrapped;
+
+typedef unsigned int  (_cdecl * serv_send_typing_wrapped_fnc)(PurpleConnection *gc, const char *name, PurpleTypingState state);
+extern serv_send_typing_wrapped_fnc serv_send_typing_wrapped;
+
+typedef void  (_cdecl * serv_join_chat_wrapped_fnc)(PurpleConnection *, GHashTable *data);
+extern serv_join_chat_wrapped_fnc serv_join_chat_wrapped;
+
+typedef void  (_cdecl * purple_dnsquery_set_ui_ops_wrapped_fnc)(PurpleDnsQueryUiOps *ops);
+extern purple_dnsquery_set_ui_ops_wrapped_fnc purple_dnsquery_set_ui_ops_wrapped;
+
+typedef PurpleConvIm * (_cdecl * purple_conversation_get_im_data_wrapped_fnc)(const PurpleConversation *conv);
+extern purple_conversation_get_im_data_wrapped_fnc purple_conversation_get_im_data_wrapped;
+
+typedef PurpleConvChat * (_cdecl * purple_conversation_get_chat_data_wrapped_fnc)(const PurpleConversation *conv);
+extern purple_conversation_get_chat_data_wrapped_fnc purple_conversation_get_chat_data_wrapped;
+
+typedef PurpleConversation * (_cdecl * purple_find_conversation_with_account_wrapped_fnc)( PurpleConversationType type, const char *name, const PurpleAccount *account);
+extern purple_find_conversation_with_account_wrapped_fnc purple_find_conversation_with_account_wrapped;
+
+typedef PurpleConversation * (_cdecl * purple_conversation_new_wrapped_fnc)(PurpleConversationType type, PurpleAccount *account, const char *name);
+extern purple_conversation_new_wrapped_fnc purple_conversation_new_wrapped;
+
+typedef PurpleConversationType  (_cdecl * purple_conversation_get_type_wrapped_fnc)(const PurpleConversation *conv);
+extern purple_conversation_get_type_wrapped_fnc purple_conversation_get_type_wrapped;
+
+typedef void  (_cdecl * purple_conv_im_send_wrapped_fnc)(PurpleConvIm *im, const char *message);
+extern purple_conv_im_send_wrapped_fnc purple_conv_im_send_wrapped;
+
+typedef void  (_cdecl * purple_conv_chat_send_wrapped_fnc)(PurpleConvChat *chat, const char *message);
+extern purple_conv_chat_send_wrapped_fnc purple_conv_chat_send_wrapped;
+
+typedef void  (_cdecl * purple_conversation_destroy_wrapped_fnc)(PurpleConversation *conv);
+extern purple_conversation_destroy_wrapped_fnc purple_conversation_destroy_wrapped;
+
+typedef PurpleAccount * (_cdecl * purple_conversation_get_account_wrapped_fnc)(const PurpleConversation *conv);
+extern purple_conversation_get_account_wrapped_fnc purple_conversation_get_account_wrapped;
+
+typedef const char * (_cdecl * purple_conversation_get_name_wrapped_fnc)(const PurpleConversation *conv);
+extern purple_conversation_get_name_wrapped_fnc purple_conversation_get_name_wrapped;
+
+typedef void  (_cdecl * purple_conversations_set_ui_ops_wrapped_fnc)(PurpleConversationUiOps *ops);
+extern purple_conversations_set_ui_ops_wrapped_fnc purple_conversations_set_ui_ops_wrapped;
+
+typedef void * (_cdecl * purple_conversations_get_handle_wrapped_fnc)(void);
+extern purple_conversations_get_handle_wrapped_fnc purple_conversations_get_handle_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 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 PurpleConnectionState  (_cdecl * purple_connection_get_state_wrapped_fnc)(const PurpleConnection *gc);
+extern purple_connection_get_state_wrapped_fnc purple_connection_get_state_wrapped;
+
+typedef PurpleAccount * (_cdecl * purple_connection_get_account_wrapped_fnc)(const PurpleConnection *gc);
+extern purple_connection_get_account_wrapped_fnc purple_connection_get_account_wrapped;
+
+typedef const char * (_cdecl * purple_connection_get_display_name_wrapped_fnc)(const PurpleConnection *gc);
+extern purple_connection_get_display_name_wrapped_fnc purple_connection_get_display_name_wrapped;
+
+typedef void  (_cdecl * purple_connections_set_ui_ops_wrapped_fnc)(PurpleConnectionUiOps *ops);
+extern purple_connections_set_ui_ops_wrapped_fnc purple_connections_set_ui_ops_wrapped;
+
+typedef void * (_cdecl * purple_connections_get_handle_wrapped_fnc)(void);
+extern purple_connections_get_handle_wrapped_fnc purple_connections_get_handle_wrapped;
+
+typedef void  (_cdecl * purple_core_set_ui_ops_wrapped_fnc)(PurpleCoreUiOps *ops);
+extern purple_core_set_ui_ops_wrapped_fnc purple_core_set_ui_ops_wrapped;
+
+typedef gboolean  (_cdecl * purple_core_init_wrapped_fnc)(const char *ui);
+extern purple_core_init_wrapped_fnc purple_core_init_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 gboolean  (_cdecl * purple_timeout_remove_wrapped_fnc)(guint handle);
+extern purple_timeout_remove_wrapped_fnc purple_timeout_remove_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_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;
+
+typedef gboolean  (_cdecl * purple_privacy_check_wrapped_fnc)(PurpleAccount *account, const char *who);
+extern purple_privacy_check_wrapped_fnc purple_privacy_check_wrapped;
+
+typedef PurplePlugin * (_cdecl * purple_find_prpl_wrapped_fnc)(const char *id);
+extern purple_find_prpl_wrapped_fnc purple_find_prpl_wrapped;
+
+typedef void  (_cdecl * purple_prpl_send_attention_wrapped_fnc)(PurpleConnection *gc, const char *who, guint type_code);
+extern purple_prpl_send_attention_wrapped_fnc purple_prpl_send_attention_wrapped;
+
+typedef PurplePrefType  (_cdecl * purple_account_option_get_type_wrapped_fnc)(const PurpleAccountOption *option);
+extern purple_account_option_get_type_wrapped_fnc purple_account_option_get_type_wrapped;
+
+typedef const char * (_cdecl * purple_account_option_get_setting_wrapped_fnc)(const PurpleAccountOption *option);
+extern purple_account_option_get_setting_wrapped_fnc purple_account_option_get_setting_wrapped;
+
+typedef GIOChannel * (_cdecl * wpurple_g_io_channel_win32_new_socket_wrapped_fnc)(int socket);
+extern wpurple_g_io_channel_win32_new_socket_wrapped_fnc wpurple_g_io_channel_win32_new_socket_wrapped;
+
+
+#else
+
+
+#define PURPLE_BLIST_NODE_IS_CHAT_WRAPPED PURPLE_BLIST_NODE_IS_CHAT
+#define PURPLE_BLIST_NODE_IS_BUDDY_WRAPPED PURPLE_BLIST_NODE_IS_BUDDY
+#define PURPLE_BLIST_NODE_IS_CONTACT_WRAPPED PURPLE_BLIST_NODE_IS_CONTACT
+#define PURPLE_BLIST_NODE_IS_GROUP_WRAPPED PURPLE_BLIST_NODE_IS_GROUP
+
+#define PURPLE_CONV_IM_WRAPPED PURPLE_CONV_IM
+#define PURPLE_CONV_CHAT_WRAPPED PURPLE_CONV_CHAT
+
+#define PURPLE_CONNECTION_IS_CONNECTED_WRAPPED PURPLE_CONNECTION_IS_CONNECTED	
+
+#define purple_debug_set_ui_ops_wrapped purple_debug_set_ui_ops
+#define purple_debug_set_verbose_wrapped purple_debug_set_verbose
+#define purple_request_set_ui_ops_wrapped purple_request_set_ui_ops
+#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_markup_escape_text_wrapped purple_markup_escape_text
+#define purple_markup_strip_html_wrapped purple_markup_strip_html
+#define purple_normalize_wrapped purple_normalize
+#define purple_strdup_withhtml_wrapped purple_strdup_withhtml
+#define purple_markup_html_to_xhtml_wrapped purple_markup_html_to_xhtml
+#define purple_utf8_try_convert_wrapped purple_utf8_try_convert
+#define purple_util_set_user_dir_wrapped purple_util_set_user_dir
+#define purple_blist_node_get_type_wrapped purple_blist_node_get_type
+#define purple_buddy_get_alias_wrapped purple_buddy_get_alias
+#define purple_buddy_get_server_alias_wrapped purple_buddy_get_server_alias
+#define purple_find_buddy_wrapped purple_find_buddy
+#define purple_buddy_get_group_wrapped purple_buddy_get_group
+#define purple_blist_remove_buddy_wrapped purple_blist_remove_buddy
+#define purple_blist_alias_buddy_wrapped purple_blist_alias_buddy
+#define purple_blist_server_alias_buddy_wrapped purple_blist_server_alias_buddy
+#define purple_find_group_wrapped purple_find_group
+#define purple_group_new_wrapped purple_group_new
+#define purple_blist_add_contact_wrapped purple_blist_add_contact
+#define purple_buddy_get_contact_wrapped purple_buddy_get_contact
+#define purple_buddy_new_wrapped purple_buddy_new
+#define purple_blist_add_buddy_wrapped purple_blist_add_buddy
+#define purple_blist_find_chat_wrapped purple_blist_find_chat
+#define purple_chat_get_components_wrapped purple_chat_get_components
+#define purple_buddy_get_presence_wrapped purple_buddy_get_presence
+#define purple_buddy_get_account_wrapped purple_buddy_get_account
+#define purple_buddy_get_name_wrapped purple_buddy_get_name
+#define purple_find_buddies_wrapped purple_find_buddies
+#define purple_group_get_name_wrapped purple_group_get_name
+#define purple_blist_set_ui_ops_wrapped purple_blist_set_ui_ops
+#define purple_set_blist_wrapped purple_set_blist
+#define purple_blist_new_wrapped purple_blist_new
+#define purple_blist_load_wrapped purple_blist_load
+#define purple_blist_get_handle_wrapped purple_blist_get_handle
+#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_signal_connect_wrapped purple_signal_connect
+#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_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_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_account_set_bool_wrapped purple_account_set_bool
+#define purple_account_get_protocol_id_wrapped purple_account_get_protocol_id
+#define purple_account_set_int_wrapped purple_account_set_int
+#define purple_account_set_string_wrapped purple_account_set_string
+#define purple_account_get_username_wrapped purple_account_get_username
+#define purple_account_set_username_wrapped purple_account_set_username
+#define purple_accounts_find_wrapped purple_accounts_find
+#define purple_account_new_wrapped purple_account_new
+#define purple_accounts_add_wrapped purple_accounts_add
+#define purple_account_set_password_wrapped purple_account_set_password
+#define purple_account_set_enabled_wrapped purple_account_set_enabled
+#define purple_account_set_privacy_type_wrapped purple_account_set_privacy_type
+#define purple_account_get_status_type_with_primitive_wrapped purple_account_get_status_type_with_primitive
+#define purple_account_set_status_wrapped purple_account_set_status
+#define purple_account_get_int_wrapped purple_account_get_int
+#define purple_account_disconnect_wrapped purple_account_disconnect
+#define purple_accounts_delete_wrapped purple_accounts_delete
+#define purple_account_get_connection_wrapped purple_account_get_connection
+#define purple_account_set_alias_wrapped purple_account_set_alias
+#define purple_account_set_public_alias_wrapped purple_account_set_public_alias
+#define purple_account_remove_buddy_wrapped purple_account_remove_buddy
+#define purple_account_add_buddy_wrapped purple_account_add_buddy
+#define purple_account_get_name_for_display_wrapped purple_account_get_name_for_display
+#define purple_accounts_set_ui_ops_wrapped purple_accounts_set_ui_ops
+#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 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_dnsquery_set_ui_ops_wrapped purple_dnsquery_set_ui_ops
+#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_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_plugin_action_free_wrapped purple_plugin_action_free
+#define purple_plugins_add_search_path_wrapped purple_plugins_add_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_core_set_ui_ops_wrapped purple_core_set_ui_ops
+#define purple_core_init_wrapped purple_core_init
+#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_timeout_remove_wrapped purple_timeout_remove
+#define purple_eventloop_set_ui_ops_wrapped purple_eventloop_set_ui_ops
+#define purple_input_remove_wrapped purple_input_remove
+#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_find_prpl_wrapped purple_find_prpl
+#define purple_prpl_send_attention_wrapped purple_prpl_send_attention
+#define purple_account_option_get_type_wrapped purple_account_option_get_type
+#define purple_account_option_get_setting_wrapped purple_account_option_get_setting
+#define wpurple_g_io_channel_win32_new_socket_wrapped wpurple_g_io_channel_win32_new_socket
+#endif
 
 bool resolvePurpleFunctions();
+
diff --git a/backends/libpurple/utils.cpp b/backends/libpurple/utils.cpp
index de76e642..9965ccf6 100644
--- a/backends/libpurple/utils.cpp
+++ b/backends/libpurple/utils.cpp
@@ -52,7 +52,7 @@
 static GHashTable *ui_info = NULL;
 
 void execute_purple_plugin_action(PurpleConnection *gc, const std::string &name) {
-	PurplePlugin *plugin = gc && PURPLE_CONNECTION_IS_CONNECTED(gc) ? gc->prpl : NULL;
+	PurplePlugin *plugin = gc && PURPLE_CONNECTION_IS_CONNECTED_WRAPPED(gc) ? gc->prpl : NULL;
 	if (plugin && PURPLE_PLUGIN_HAS_ACTIONS(plugin)) {
 		PurplePluginAction *action = NULL;
 		GList *actions, *l;
@@ -67,7 +67,7 @@ void execute_purple_plugin_action(PurpleConnection *gc, const std::string &name)
 				if ((std::string) action->label == name) {
 					action->callback(action);
 				}
-				purple_plugin_action_free(action);
+				purple_plugin_action_free_wrapped(action);
 			}
 		}
 	}
diff --git a/spectrum/src/main.cpp b/spectrum/src/main.cpp
index 7de5ce73..6acbe7fc 100644
--- a/spectrum/src/main.cpp
+++ b/spectrum/src/main.cpp
@@ -35,6 +35,7 @@
 #include <sys/stat.h>
 
 using namespace Transport;
+using namespace Transport::Util;
 
 DEFINE_LOGGER(logger, "Spectrum");
 
@@ -271,6 +272,10 @@ int main(int argc, char **argv)
 		return 1;
 	}
 
+#ifdef WIN32
+	SetCurrentDirectory( utf8ToUtf16(CONFIG_STRING(&config, "service.working_dir")).c_str() );
+#endif
+
 #ifndef WIN32
 	if (!CONFIG_STRING(&config, "service.group").empty() ||!CONFIG_STRING(&config, "service.user").empty() ) {
 		struct group *gr;