libtransport.git Changeset - 87a0a2f49a23

Changeset - 87a0a2f49a23

Parent rev.

Child rev.

[Not reviewed]

0 2 0

HanzZ - 14 years ago 2012-03-07 18:59:21
hanzz.k@gmail.com

Working MUC messages for XMPP

2 files changed with 29 insertions and 7 deletions:

CMakeLists.txt

backends/libpurple/main.cpp

0 comments (0 inline, 0 general)

CMakeLists.txt

➞

Show inline comments

@@ @@ -29,209 +29,210 @@ find_package(event) @@
 set(Swiften_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(Swiften REQUIRED)
 set(openssl_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(openssl REQUIRED)
 set(Boost_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 if (WIN32)
 set(Boost_USE_STATIC_LIBS        ON)
 set(Boost_USE_MULTITHREADED      ON)
 set(Boost_USE_STATIC_RUNTIME    OFF)
 endif()
 find_package(Boost COMPONENTS program_options date_time system filesystem regex  signals REQUIRED)
 message( STATUS "Found Boost: ${Boost_LIBRARIES}, ${Boost_INCLUDE_DIR}")
 set(Protobuf_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(Protobuf REQUIRED)
 set(Communi_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(Communi)
 set(log4cxx_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(log4cxx)
 set(event_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(event)
 set(pqxx_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(pqxx)
 set(dbus_DIR "${CMAKE_SOURCE_DIR}/cmake_modules")
 find_package(dbus)
 find_package(Doxygen)
 INCLUDE(FindQt4)
 FIND_PACKAGE(Qt4 COMPONENTS QtCore QtNetwork)
 # ADD_DEFINITIONS(${SWIFTEN_CFLAGS})
 ADD_DEFINITIONS(-DSUPPORT_LEGACY_CAPS)
 ADD_DEFINITIONS(-DBOOST_FILESYSTEM_VERSION=2)
 message("  Supported features")
 message("-----------------------")
 if (SPECTRUM_VERSION)
 	ADD_DEFINITIONS(-DSPECTRUM_VERSION="${SPECTRUM_VERSION}")
 else (SPECTRUM_VERSION)
 	if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
 		execute_process(COMMAND git "--git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git" rev-parse --short HEAD
 						OUTPUT_VARIABLE GIT_REVISION
 						OUTPUT_STRIP_TRAILING_WHITESPACE
+		)
 		set(SPECTRUM_VERSION 2.0.0-beta-git-${GIT_REVISION})
 		ADD_DEFINITIONS(-DSPECTRUM_VERSION="${SPECTRUM_VERSION}")
 	else (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
 		set(SPECTRUM_VERSION 2.0.0-alpha)
 		ADD_DEFINITIONS(-DSPECTRUM_VERSION="${SPECTRUM_VERSION}")
 	endif (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/.git)
 endif (SPECTRUM_VERSION)
 message("Version           : " ${SPECTRUM_VERSION})
 if (SQLITE3_FOUND)
 	ADD_DEFINITIONS(-DWITH_SQLITE)
 	include_directories(${SQLITE3_INCLUDE_DIR})
 	message("SQLite3           : yes")
 else (SQLITE3_FOUND)
 	set(SQLITE3_LIBRARIES "")
 	message("SQLite3           : no")
 endif (SQLITE3_FOUND)
 if (MYSQL_FOUND)
 	ADD_DEFINITIONS(-DWITH_MYSQL)
 	include_directories(${MYSQL_INCLUDE_DIR})
 	message("MySQL             : yes")
 else (MYSQL_FOUND)
 	set(MYSQL_LIBRARIES "")
 	message("MySQL             : no (install mysql-devel)")
 endif (MYSQL_FOUND)
 if (PQXX_FOUND)
 	ADD_DEFINITIONS(-DWITH_PQXX)
 	include_directories(${PQXX_INCLUDE_DIR})
 	message("PostgreSQL        : yes")
 else (PQXX_FOUND)
 	set(PQXX_LIBRARY "")
 	set(PQ_LIBRARY "")
 	message("PostgreSQL        : no (install libpqxx-devel)")
 endif (PQXX_FOUND)
 if (PROTOBUF_FOUND)
 	ADD_DEFINITIONS(-DWITH_PROTOBUF)
 	include_directories(${PROTOBUF_INCLUDE_DIRS})
 	message("Network plugins   : yes")
 	if(PURPLE_LIBRARY AND PURPLE_INCLUDE_DIR)
 		message("Libpurple plugin  : yes")
 		include_directories(${PURPLE_INCLUDE_DIR})
 		include_directories(${GLIB2_INCLUDE_DIR})
 	else()
 		message("Libpurple plugin  : no (install libpurple)")
 	endif()
 	if (HAVE_EVENT)
 		ADD_DEFINITIONS(-DWITH_LIBEVENT)
 		include_directories(${EVENT_INCLUDE_DIRS})
 		message("  libev eventloop : yes")
 	else()
 		message("  libev eventloop : no (install libev-devel)")
 	endif()
 	if(IRC_FOUND)
 		ADD_DEFINITIONS(-DCOMMUNI_SHARED)
 		message("IRC plugin        : yes")
 		include_directories(${QT_QTNETWORK_INCLUDE_DIR})
 		include_directories(${IRC_INCLUDE_DIR})
 		include(${QT_USE_FILE})
 	else()
 		message("IRC plugin        : no (install libCommuni and libprotobuf-dev)")
 	endif()
 	message("Frotz plugin      : yes")
 	message("SMSTools3 plugin  : yes")
 	if(${LIBDBUSGLIB_FOUND})
 		message("Skype plugin      : yes")
 		include_directories(${LIBDBUSGLIB_INCLUDE_DIRS})
 	else()
 		message("Skype plugin      : no (install dbus-glib-devel)")
 	endif()
 else()
 	message("Network plugins   : no (install libprotobuf-dev)")
 	message("Libpurple plugin  : no (install libpurple and libprotobuf-dev)")
 	message("IRC plugin        : no (install libircclient-qt and libprotobuf-dev)")
 	message("Frotz plugin      : no (install libprotobuf-dev)")
 	message("SMSTools3 plugin  : no (install libprotobuf-dev)")
 endif()
 if (LOG4CXX_FOUND)
 	message("Logging           : yes")
 	include_directories(${LOG4CXX_INCLUDE_DIR})
 else()
 	message(FATAL_ERROR "Logging           : no (install log4cxx-devel)")
 endif()
 if (WIN32)
 ADD_DEFINITIONS(-D_WIN32_WINNT=0x501)
 ADD_DEFINITIONS(-DWIN32_LEAN_AND_MEAN)
 endif()
 if(CMAKE_BUILD_TYPE MATCHES Debug)
 if (CMAKE_COMPILER_IS_GNUCXX)
 	ADD_DEFINITIONS(-O3)
 	ADD_DEFINITIONS(-ggdb)
 	ADD_DEFINITIONS(-Wall)
 	ADD_DEFINITIONS(-W)
 	ADD_DEFINITIONS(-Wcast-align)
 	ADD_DEFINITIONS(-Wextra -Wno-sign-compare -Wno-unused-parameter)
 	ADD_DEFINITIONS(-Winit-self)
 	ADD_DEFINITIONS(-Wmissing-declarations)
 	ADD_DEFINITIONS(-Wpointer-arith)
 	ADD_DEFINITIONS(-Wreorder)
 	ADD_DEFINITIONS(-Woverloaded-virtual)
 	ADD_DEFINITIONS(-Wsign-promo)
 	ADD_DEFINITIONS(-Wundef -Wunused)
 endif()
 	ADD_DEFINITIONS(-DDEBUG)
 	message("Debug             : yes")
 else(CMAKE_BUILD_TYPE MATCHES Debug)
 	message("Debug             : no (run \"cmake . -DCMAKE_BUILD_TYPE=Debug\")")
 endif(CMAKE_BUILD_TYPE MATCHES Debug)
 SET(TRANSPORT_VERSION 2.0)
 SET(PROJECT_VERSION 2.0)
 include_directories(include)
 include_directories(${EVENT_INCLUDE_DIRS})
 include_directories(${SWIFTEN_INCLUDE_DIR})
 include_directories(${Boost_INCLUDE_DIRS})
 include_directories(${OPENSSL_INCLUDE_DIR})
 ADD_SUBDIRECTORY(src)
 ADD_SUBDIRECTORY(plugin)
 ADD_SUBDIRECTORY(include)
 ADD_SUBDIRECTORY(spectrum)
 ADD_SUBDIRECTORY(backends)
 if (NOT WIN32)
 	ADD_SUBDIRECTORY(spectrum_manager)
 	ADD_SUBDIRECTORY(spectrum2_send_message)
 endif()
 if (CPPUNIT_FOUND)
 	message("tests             : yes")
 	include_directories(${CPPUNIT_INCLUDE_DIR})
 else()
 	message("tests             : no (install CPPUnit)")
 endif()
 if(DOXYGEN_FOUND)
 	message("Docs              : yes")
 	ADD_SUBDIRECTORY(docs)
 else(DOXYGEN_FOUND)
 	message("Docs              : no (install doxygen)")
 endif(DOXYGEN_FOUND)
 message("----------------------")

backends/libpurple/main.cpp

➞

Show inline comments

@@ @@ -579,395 +579,408 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
 						case PURPLE_PREF_STRING:
 						case PURPLE_PREF_STRING_LIST:
 							purple_account_set_string(account, key.c_str(), KEYFILE_STRING("purple", key).c_str());
 							break;
 						default:
 							continue;
+					}
 					break;
+				}
 				if (!found) {
 					purple_account_set_string(account, key.c_str(), KEYFILE_STRING("purple", key).c_str());
+				}
 				i++;
+			}
 			g_strfreev (keys);
+		}
 		void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {
 			PurpleAccount *account = NULL;
 			std::string name;
 			std::string protocol;
 			getProtocolAndName(legacyName, name, protocol);
 			if (password.empty()) {
 				LOG4CXX_INFO(logger,  name.c_str() << ": Empty password");
 				np->handleDisconnected(user, 0, "Empty password.");
 				return;
+			}
 			if (!purple_find_prpl(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) {
 				LOG4CXX_INFO(logger, "Using previously created account with name '" << name.c_str() << "' and protocol '" << protocol << "'");
 				account = purple_accounts_find(name.c_str(), protocol.c_str());
+			}
 			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);
+			}
 			m_sessions[user] = account;
 			m_accounts[account] = user;
 			// 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);
 			setDefaultAccountOptions(account);
 			purple_account_set_enabled(account, "spectrum", TRUE);
 			if (KEYFILE_BOOL("service", "enable_privacy_lists")) {
 				purple_account_set_privacy_type(account, PURPLE_PRIVACY_DENY_USERS);
+			}
 			const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_AVAILABLE);
 			if (status_type != NULL) {
 				purple_account_set_status(account, purple_status_type_get_id(status_type), TRUE, NULL);
+			}
+		}
 		void handleLogoutRequest(const std::string &user, const std::string &legacyName) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 // 				VALGRIND_DO_LEAK_CHECK;
 				m_sessions.erase(user);
 				purple_account_disconnect(account);
 				purple_account_set_enabled(account, "spectrum", FALSE);
 				g_free(account->ui_data);
 				account->ui_data = NULL;
 				m_accounts.erase(account);
 				purple_accounts_delete(account);
 //
 // 				// Remove conversations.
 // 				// This has to be called before m_account->ui_data = NULL;, because it uses
 // 				// ui_data to call SpectrumMessageHandler::purpleConversationDestroyed() callback.
 // 				GList *iter;
 // 				for (iter = purple_get_conversations(); iter; ) {
 // 					PurpleConversation *conv = (PurpleConversation*) iter->data;
 // 					iter = iter->next;
 // 					if (purple_conversation_get_account(conv) == account)
 // 						purple_conversation_destroy(conv);
 // 				}
 //
 // 				g_free(account->ui_data);
 // 				account->ui_data = NULL;
 // 				m_accounts.erase(account);
 //
 // 				purple_notify_close_with_handle(account);
 // 				purple_request_close_with_handle(account);
 //
 // 				purple_accounts_remove(account);
 //
 // 				GSList *buddies = purple_find_buddies(account, NULL);
 // 				while(buddies) {
 // 					PurpleBuddy *b = (PurpleBuddy *) buddies->data;
 // 					purple_blist_remove_buddy(b);
 // 					buddies = g_slist_delete_link(buddies, buddies);
 // 				}
 //
 // 				/* Remove any open conversation for this account */
 // 				for (GList *it = purple_get_conversations(); it; ) {
 // 					PurpleConversation *conv = (PurpleConversation *) it->data;
 // 					it = it->next;
 // 					if (purple_conversation_get_account(conv) == account)
 // 						purple_conversation_destroy(conv);
 // 				}
 //
 // 				/* Remove this account's pounces */
 // 					// purple_pounce_destroy_all_by_account(account);
 //
 // 				/* This will cause the deletion of an old buddy icon. */
 // 				purple_buddy_icons_set_account_icon(account, NULL, 0);
 //
 // 				purple_account_destroy(account);
 				// force returning of memory chunks allocated by libxml2 to kernel
 #ifndef WIN32
 				malloc_trim(0);
 #endif
 // 				VALGRIND_DO_LEAK_CHECK;
+			}
+		}
 		void handleStatusChangeRequest(const std::string &user, int status, const std::string &statusMessage) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				int st;
 				switch(status) {
 					case pbnetwork::STATUS_AWAY: {
 						st = PURPLE_STATUS_AWAY;
 						if (!purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_AWAY))
 							st = PURPLE_STATUS_EXTENDED_AWAY;
 						else
 							st = PURPLE_STATUS_AWAY;
 						break;
+					}
 					case pbnetwork::STATUS_DND: {
 						st = PURPLE_STATUS_UNAVAILABLE;
 						break;
+					}
 					case pbnetwork::STATUS_XA: {
 						if (!purple_account_get_status_type_with_primitive(account, PURPLE_STATUS_EXTENDED_AWAY))
 							st = PURPLE_STATUS_AWAY;
 						else
 							st = PURPLE_STATUS_EXTENDED_AWAY;
 						break;
+					}
 					case pbnetwork::STATUS_NONE: {
 						st = PURPLE_STATUS_OFFLINE;
 						break;
+					}
 					case pbnetwork::STATUS_INVISIBLE:
 						st = PURPLE_STATUS_INVISIBLE;
 						break;
 					default:
 						st = PURPLE_STATUS_AVAILABLE;
 						break;
+				}
 				gchar *_markup = purple_markup_escape_text(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);
 				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);
+					}
 					else {
 						purple_account_set_status(account, purple_status_type_get_id(status_type), TRUE, NULL);
+					}
+				}
+			}
+		}
 		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_IM, legacyName.c_str(), account);
+				PurpleConversation *conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, legacyName.c_str(), account);
 				if (!conv) {
 					conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, legacyName.c_str());
 					PurpleConversation *conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, legacyName.c_str(), account);
 					if (!conv) {
 						conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, legacyName.c_str());
+					}
+				}
 				if (xhtml.empty()) {
 					gchar *_markup = purple_markup_escape_text(message.c_str(), -1);
 					purple_conv_im_send(PURPLE_CONV_IM(conv), _markup);
 					if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM) {
 						purple_conv_im_send(PURPLE_CONV_IM(conv), _markup);
+					}
 					else if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT) {
 						purple_conv_chat_send(PURPLE_CONV_CHAT(conv), _markup);
+					}
 					g_free(_markup);
+				}
 				else {
 					purple_conv_im_send(PURPLE_CONV_IM(conv), xhtml.c_str());
 					if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM) {
 						purple_conv_im_send(PURPLE_CONV_IM(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());
+					}
+				}
+			}
+		}
 		void handleVCardRequest(const std::string &user, const std::string &legacyName, unsigned int id) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				std::string name = legacyName;
 				if (KEYFILE_STRING("service", "protocol") == "any" && legacyName.find("prpl-") == 0) {
 					name = name.substr(name.find(".") + 1);
+				}
 				m_vcards[user + name] = id;
 				if (KEYFILE_BOOL("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);
+				}
 				else {
 					serv_get_info(purple_account_get_connection(account), name.c_str());
+				}
+			}
+		}
 		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);
 				gssize size = image.size();
 				// this will be freed by libpurple
 				guchar *photo = (guchar *) g_malloc(size * sizeof(guchar));
 				memcpy(photo, image.c_str(), size);
 				if (!photo)
 					return;
 				purple_buddy_icons_set_account_icon(account, photo, size);
+			}
+		}
 		void handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<std::string> &groups) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				if (m_authRequests.find(user + buddyName) != m_authRequests.end()) {
 					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());
 				if (buddy) {
 					purple_account_remove_buddy(account, buddy, purple_buddy_get_group(buddy));
 					purple_blist_remove_buddy(buddy);
+				}
+			}
+		}
 		void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups_) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				std::string groups = groups_.empty() ? "" : groups_[0];
 				if (m_authRequests.find(user + buddyName) != m_authRequests.end()) {
 					m_authRequests[user + buddyName]->authorize_cb(m_authRequests[user + buddyName]->user_data);
 					m_authRequests.erase(user + buddyName);
+				}
 				PurpleBuddy *buddy = purple_find_buddy(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);
+					}
 					PurpleGroup *group = purple_find_group(groups.c_str());
 					if (!group) {
 						group = purple_group_new(groups.c_str());
+					}
 					purple_blist_add_contact(purple_buddy_get_contact(buddy), group ,NULL);
+				}
 				else {
 					PurpleBuddy *buddy = purple_buddy_new(account, buddyName.c_str(), alias.c_str());
 					// Add newly created buddy to legacy network roster.
 					PurpleGroup *group = purple_find_group(groups.c_str());
 					if (!group) {
 						group = purple_group_new(groups.c_str());
+					}
 					purple_blist_add_buddy(buddy, NULL, group ,NULL);
 					purple_account_add_buddy(account, buddy);
+				}
+			}
+		}
 		void handleBuddyBlockToggled(const std::string &user, const std::string &buddyName, bool blocked) {
 			if (KEYFILE_BOOL("service", "enable_privacy_lists")) {
 				PurpleAccount *account = m_sessions[user];
 				if (account) {
 					if (blocked) {
 						purple_privacy_deny(account, buddyName.c_str(), FALSE, FALSE);
+					}
 					else {
 						purple_privacy_allow(account, buddyName.c_str(), FALSE, FALSE);
+					}
+				}
+			}
+		}
 		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);
+			}
+		}
 		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);
+			}
+		}
 		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);
+			}
+		}
 		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);
+			}
+		}
 		void handleJoinRoomRequest(const std::string &user, const std::string &room, const std::string &nickname, const std::string &pasword) {
 			PurpleAccount *account = m_sessions[user];
 			if (!account) {
 				return;
+			}
 			PurpleConnection *gc = purple_account_get_connection(account);
 			GHashTable *comps = NULL;
 			// Check if the PurpleChat is not stored in buddy list
 			PurpleChat *chat = purple_blist_find_chat(account, room.c_str());
 			if (chat) {
 				comps = purple_chat_get_components(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());
+			}
 			LOG4CXX_INFO(logger, user << ": Joining the room " << room);
 			if (comps) {
 				serv_join_chat(gc, comps);
 				g_hash_table_destroy(comps);
+			}
+		}
 		void handleLeaveRoomRequest(const std::string &user, const std::string &room) {
 			PurpleAccount *account = m_sessions[user];
 			if (!account) {
 				return;
+			}
 			PurpleConversation *conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, room.c_str(), account);
 			purple_conversation_destroy(conv);
+		}
 		void handleFTStartRequest(const std::string &user, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long ftID) {
 			PurpleXfer *xfer = m_unhandledXfers[user + fileName + buddyName];
 			if (xfer) {
 				m_unhandledXfers.erase(user + fileName + buddyName);
 				FTData *ftData = (FTData *) xfer->ui_data;
 				ftData->id = ftID;
 				m_xfers[ftID] = xfer;
 				purple_xfer_request_accepted(xfer, fileName.c_str());
 				purple_xfer_ui_ready(xfer);
+			}
+		}
 		void handleFTFinishRequest(const std::string &user, const std::string &buddyName, const std::string &fileName, unsigned long size, unsigned long ftID) {
 			PurpleXfer *xfer = m_unhandledXfers[user + fileName + buddyName];
 			if (xfer) {
 				m_unhandledXfers.erase(user + fileName + buddyName);
 				purple_xfer_request_denied(xfer);
+			}
+		}
 		return false;
 	PurpleStatus *stat = purple_presence_get_active_status(pres);
 	if (stat == NULL)
 		return false;
 	int st = purple_status_type_get_primitive(purple_status_get_type(stat));
 	switch(st) {
 		case PURPLE_STATUS_AVAILABLE: {
 			status = pbnetwork::STATUS_ONLINE;
 			break;
+		}
 		case PURPLE_STATUS_AWAY: {
 			status = pbnetwork::STATUS_AWAY;
 			break;
+		}
 		case PURPLE_STATUS_UNAVAILABLE: {
 			status = pbnetwork::STATUS_DND;
 			break;
+		}
 		case PURPLE_STATUS_EXTENDED_AWAY: {
 			status = pbnetwork::STATUS_XA;
 			break;
+		}
 		case PURPLE_STATUS_OFFLINE: {
 			status = pbnetwork::STATUS_NONE;
 			break;
+		}
 		default:
 			status = pbnetwork::STATUS_ONLINE;
 			break;
+	}
 	const char *message = purple_status_get_attr_string(stat, "message");
 	if (message != NULL) {
 		char *stripped = purple_markup_strip_html(message);
 		statusMessage = std::string(stripped);
 		g_free(stripped);
+	}
 	else
 		statusMessage = "";
 	return true;
+}
 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));
 	if (icon) {
 		avatarHash = purple_buddy_icon_get_full_path(icon);
 		purple_buddy_icon_unref(icon);
+	}
 	if (avatarHash) {
 		// Check if it's patched libpurple which saves icons to directories
 		char *hash = strrchr(avatarHash,'/');
 		std::string h;
 		if (hash) {
 			char *dot;
 			hash++;
 			dot = strchr(hash, '.');
 			if (dot)
 				*dot = '\0';
 			std::string ret(hash);
 			g_free(avatarHash);
 			return ret;
+		}
 		else {
 			std::string ret(avatarHash);
 			g_free(avatarHash);
 			return ret;
+		}
+	}
 	return "";
+}
 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));
 		while(buddies) {
 			PurpleGroup *g = purple_buddy_get_group((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 (groups.empty()) {
 		groups.push_back("Buddies");
+	}
 	return groups;
+}
 static void buddyListNewNode(PurpleBlistNode *node) {
 	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
 		return;
 	PurpleBuddy *buddy = (PurpleBuddy *) node;
 	PurpleAccount *account = purple_buddy_get_account(buddy);
 	LOG4CXX_INFO(logger, "Buddy updated " << np->m_accounts[account] << " " << purple_buddy_get_name(buddy) << " " << getAlias(buddy));
 	// Status
 	pbnetwork::StatusType status = pbnetwork::STATUS_NONE;
 	std::string message;
 	getStatus(buddy, status, message);
 	// Tooltip
 	PurplePlugin *prpl = purple_find_prpl(purple_account_get_protocol_id(account));
 	PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
 	bool blocked = false;
 	if (KEYFILE_BOOL("service", "enable_privacy_lists")) {
 		if (prpl_info && prpl_info->tooltip_text) {
 			PurpleNotifyUserInfo *user_info = purple_notify_user_info_new();
 			prpl_info->tooltip_text(buddy, user_info, true);
 			GList *entries = purple_notify_user_info_get_entries(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 (label == "Blocked" ) {
 						if (std::string(purple_notify_user_info_entry_get_value(entry)) == "Yes") {
 							blocked = true;
 							break;
+						}
+					}
+				}
 				entries = entries->next;
+			}
 			purple_notify_user_info_destroy(user_info);
+		}
 		if (!blocked) {
 			blocked = purple_privacy_check(account, purple_buddy_get_name(buddy)) == false;
+		}
 		else {
 			bool purpleBlocked = purple_privacy_check(account, purple_buddy_get_name(buddy)) == false;
 			if (blocked != purpleBlocked) {
 				purple_privacy_deny(account, purple_buddy_get_name(buddy), FALSE, FALSE);
+			}
+		}
+	}
 	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy), status, message, getIconHash(buddy),
 		blocked
 	);
+}
 static void buddyListUpdate(PurpleBuddyList *list, PurpleBlistNode *node) {
 	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
 		return;
 	buddyListNewNode(node);
+}
 static void buddyPrivacyChanged(PurpleBlistNode *node, void *data) {
 	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
 		return;
 	buddyListUpdate(NULL, node);
+}
 static void NodeRemoved(PurpleBlistNode *node, void *data) {
 	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
 		return;
 // 	PurpleBuddy *buddy = (PurpleBuddy *) node;
+}
 static PurpleBlistUiOps blistUiOps =
+{
 	NULL,
 	buddyListNewNode,
 	NULL,
 	buddyListUpdate,
 	NULL, //NodeRemoved,
 	NULL,
 	NULL,
 	NULL, // buddyListAddBuddy,
 	NULL,
 	NULL,
 	NULL, //buddyListSaveNode,
 	NULL, //buddyListRemoveNode,
 	NULL, //buddyListSaveAccount,
 	NULL
 };
 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 (flags & PURPLE_MESSAGE_SEND || flags & PURPLE_MESSAGE_SYSTEM)
 	if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM && flags & PURPLE_MESSAGE_SEND || flags & PURPLE_MESSAGE_SYSTEM) {
 		LOG4CXX_INFO(logger, "MSG");
 		return;
+	}
 	PurpleAccount *account = purple_conversation_get_account(conv);
 // 	char *striped = purple_markup_strip_html(message);
 // 	std::string msg = striped;
 // 	g_free(striped);
 	std::string w = purple_normalize(account, who);
 	size_t pos = w.find("/");
 	if (pos != std::string::npos)
 		w.erase((int) pos, w.length() - (int) pos);
 	// Escape HTML characters.
 	char *newline = purple_strdup_withhtml(msg);
 	char *strip, *xhtml;
 	purple_markup_html_to_xhtml(newline, &xhtml, &strip);
 // 	xhtml_linkified = spectrum_markup_linkify(xhtml);
 	std::string message_(strip);
 	std::string xhtml_(xhtml);
 	g_free(newline);
 	g_free(xhtml);
 // 	g_free(xhtml_linkified);
 	g_free(strip);
 	// AIM and XMPP adds <body>...</body> here...
 	if (xhtml_.find("<body>") == 0) {
 		xhtml_ = xhtml_.substr(6);
 		if (xhtml_.find("</body>") != std::string::npos) {
 			xhtml_ = xhtml_.substr(0, xhtml_.find("</body>"));
+		}
+	}
 	if (xhtml_ == message_) {
 		xhtml_ = "";
+	}
 // 	LOG4CXX_INFO(logger, "Received message body='" << message_ << "' xhtml='" << xhtml_ << "'");
 	np->handleMessage(np->m_accounts[account], w, message_, "", xhtml_);
 	if (purple_conversation_get_type(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_);
+	}
+}
 static void conv_chat_add_users(PurpleConversation *conv, GList *cbuddies, gboolean new_arrivals) {
 	PurpleAccount *account = purple_conversation_get_account(conv);
 	GList *l = cbuddies;
 	while (l != NULL) {
 		PurpleConvChatBuddy *cb = (PurpleConvChatBuddy *)l->data;
 		std::string name(cb->name);
 		int flags = GPOINTER_TO_INT(cb->flags);
 		if (flags & PURPLE_CBFLAGS_OP || flags & PURPLE_CBFLAGS_HALFOP) {
 // 			item->addAttribute("affiliation", "admin");
 // 			item->addAttribute("role", "moderator");
 			flags = 1;
+		}
 		else if (flags & PURPLE_CBFLAGS_FOUNDER) {
 // 			item->addAttribute("affiliation", "owner");
 // 			item->addAttribute("role", "moderator");
 			flags = 1;
+		}
 		else {
 			flags = 0;
 // 			item->addAttribute("affiliation", "member");
 // 			item->addAttribute("role", "participant");
+		}
 		np->handleParticipantChanged(np->m_accounts[account], name, purple_conversation_get_name(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);
 	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);
 		l = l->next;
+	}
+}
 static PurpleConversationUiOps conversation_ui_ops =
+{
 	NULL,
 	NULL,
-	NULL,//conv_write_chat,                              /* write_chat           */
+	conv_write_im,//conv_write_chat,                              /* write_chat           */
 	conv_write_im,             /* write_im             */
 	NULL,//conv_write_conv,           /* write_conv           */
 	conv_chat_add_users,       /* chat_add_users       */
 	NULL,//conv_chat_rename_user,     /* chat_rename_user     */
 	conv_chat_remove_users,    /* chat_remove_users    */
 	NULL,//pidgin_conv_chat_update_user,     /* chat_update_user     */
 	NULL,//pidgin_conv_present_conversation, /* present              */
 	NULL,//pidgin_conv_has_focus,            /* has_focus            */
 	NULL,//pidgin_conv_custom_smiley_add,    /* custom_smiley_add    */
 	NULL,//pidgin_conv_custom_smiley_write,  /* custom_smiley_write  */
 	NULL,//pidgin_conv_custom_smiley_close,  /* custom_smiley_close  */
 	NULL,//pidgin_conv_send_confirm,         /* send_confirm         */
 	NULL,
 	NULL,
 	NULL,
 	NULL
 };
 struct Dis {
 	std::string name;
 	std::string protocol;
 };
 static gboolean disconnectMe(void *data) {
 	Dis *d = (Dis *) data;
 	PurpleAccount *account = purple_accounts_find(d->name.c_str(), d->protocol.c_str());
 	delete d;
 	if (account) {
 		np->handleLogoutRequest(np->m_accounts[account], purple_account_get_username(account));
+	}
 	return FALSE;
+}
 static gboolean pingTimeout(void *data) {
 	np->checkPing();
 	return TRUE;
+}
 static void connection_report_disconnect(PurpleConnection *gc, PurpleConnectionError reason, const char *text){
 	PurpleAccount *account = purple_connection_get_account(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);
+}
 static PurpleConnectionUiOps conn_ui_ops =
+{
 	NULL,
 	NULL,
 	NULL,//connection_disconnected,
 	NULL,
 	NULL,
 	NULL,
 	NULL,
 	connection_report_disconnect,
 	NULL,
 	NULL,
 	NULL
 };
 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));
 	std::transform(name.begin(), name.end(), name.begin(), ::tolower);
 	size_t pos = name.find("/");
 	if (pos != std::string::npos)
 		name.erase((int) pos, name.length() - (int) pos);
 	GList *vcardEntries = purple_notify_user_info_get_entries(user_info);
 	PurpleNotifyUserInfoEntry *vcardEntry;
 	std::string firstName;
 	std::string lastName;
 	std::string fullName;
 	std::string nickname;
 	std::string header;
 	std::string label;
 	std::string photo;
 	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 (label == "Given Name" || label == "First Name") {
 				firstName = purple_notify_user_info_entry_get_value(vcardEntry);
+			}
 			else if (label == "Family Name" || label == "Last Name") {
 				lastName = purple_notify_user_info_entry_get_value(vcardEntry);
+			}
 			else if (label=="Nickname" || label == "Nick") {
 				nickname = purple_notify_user_info_entry_get_value(vcardEntry);
+			}
 			else if (label=="Full Name") {
 				fullName = purple_notify_user_info_entry_get_value(vcardEntry);
+			}
 			else {
 				LOG4CXX_WARN(logger, "Unhandled VCard Label '" << purple_notify_user_info_entry_get_label(vcardEntry) << "' " << purple_notify_user_info_entry_get_value(vcardEntry));
+			}
+		}
 		vcardEntries = vcardEntries->next;
+	}
 	if ((!firstName.empty() || !lastName.empty()) && fullName.empty())
 		fullName = firstName + " " + lastName;
 	if (nickname.empty() && !fullName.empty()) {
 		nickname = fullName;
+	}
 	bool ownInfo = name == purple_account_get_username(account);
 	if (ownInfo) {
 		const gchar *displayname = purple_connection_get_display_name(gc);
 		if (!displayname) {
 			displayname = purple_account_get_name_for_display(account);
+		}
 		if (displayname && nickname.empty()) {
 			nickname = displayname;
+		}
 		// avatar
 		PurpleStoredImage *avatar = purple_buddy_icons_find_account_icon(account);
 		if (avatar) {
 			const gchar * data = (const gchar *) purple_imgstore_get_data(avatar);
 			size_t len = purple_imgstore_get_size(avatar);
 			if (len < 300000 && data) {
 				photo = std::string(data, len);
+			}
 			purple_imgstore_unref(avatar);
+		}
+	}
 	PurpleBuddy *buddy = purple_find_buddy(purple_connection_get_account(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());
 		if (icon) {
 			if (true) {
 				gchar *data;
 				gchar *path = purple_buddy_icon_get_full_path(icon);
 				if (path) {
 					if (g_file_get_contents(path, &data, &len, NULL)) {
 						photo = std::string(data, len);
 						g_free(data);
+					}
 					g_free(path);
+				}
+			}
 			else {
 				const gchar * data = (gchar*)purple_buddy_icon_get_data(icon, &len);
 				if (len < 300000 && data) {
 					photo = std::string(data, len);
+				}
+			}
 			purple_buddy_icon_unref(icon);
+		}
+	}
 	np->handleVCard(np->m_accounts[account], np->m_vcards[np->m_accounts[account] + name], name, fullName, nickname, photo);
 	np->m_vcards.erase(np->m_accounts[account] + name);
 	return NULL;
+}
 static PurpleNotifyUiOps notifyUiOps =
+{
 		NULL,
 		NULL,
 		NULL,
 		NULL,
 		NULL,
 		NULL,
 		notify_user_info,
 		NULL,
 		NULL,
 		NULL,
 		NULL,
 		NULL,
 		NULL
 };
 static PurpleRequestUiOps requestUiOps =
+{
 	requestInput,
 	NULL,
 	requestAction,

0 comments (0 inline, 0 general)