libtransport.git Changeset - 2836f390b953

Changeset - 2836f390b953

Parent rev.

Child rev.

[Not reviewed]

0 2 0

HanzZ - 14 years ago 2011-06-19 20:40:27
hanzz.k@gmail.com

Receive VCard from PurpleAccount and fixed crash on disconnect

2 files changed with 14 insertions and 2 deletions:

backends/libpurple/main.cpp

include/Swiften/Server/Server.cpp

0 comments (0 inline, 0 general)

backends/libpurple/main.cpp

➞

Show inline comments

 	std::string w = who;
 	size_t pos = w.find("/");
 	if (pos != std::string::npos)
 		w.erase((int) pos, w.length() - (int) pos);
 	np->handleMessage(np->m_accounts[account], w, msg);
+}
 static PurpleConversationUiOps conversation_ui_ops =
+{
 	NULL,
 	NULL,
 	NULL,//conv_write_chat,                              /* write_chat           */
 	conv_write_im,             /* write_im             */
 	NULL,//conv_write_conv,           /* write_conv           */
 	NULL,//conv_chat_add_users,       /* chat_add_users       */
 	NULL,//conv_chat_rename_user,     /* chat_rename_user     */
 	NULL,//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
 };
 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], purple_account_get_username(account), (int) reason, text ? text : "");
+}
 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) {
 	std::string name(who);
 	PurpleAccount *account = purple_connection_get_account(gc);
 	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;
 	Swift::ByteArray 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 {
 				std::cout << "UNHANDLED VCARD LABEL '" << purple_notify_user_info_entry_get_label(vcardEntry) << "' " << purple_notify_user_info_entry_get_value(vcardEntry) << "\n";
+			}
+		}
 		vcardEntries = vcardEntries->next;
+	}
 	if (name == purple_account_get_username(account)) {
 		const gchar *displayname = purple_connection_get_display_name(gc);
 		if (!displayname) {
 			displayname = purple_account_get_name_for_display(account);
+		}
 		if (displayname) {
 			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 = Swift::createByteArray(data, len);
+			}
+		}
+	}
 	if ((!firstName.empty() || !lastName.empty()) && fullName.empty())
 		fullName = firstName + " " + lastName;
 	PurpleBuddy *buddy = purple_find_buddy(purple_connection_get_account(gc), who);
 	if (buddy) {
+	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) {
 			const gchar * data = (gchar*)purple_buddy_icon_get_data(icon, &len);
 			// Sometimes libpurple returns really broken pointers here
 			// They weren't able to do anything with that and I don't know what to do too,
 			// so it's better to hack through it by not trying to forward really broken things...
 			if (len < 300000 && data) {
 				photo = Swift::createByteArray(data, len);
 // 				const gchar *ext = (gchar*)purple_buddy_icon_get_extension(icon);
 // 				if (ext) {
 // 					std::string extension(ext);
 // 					if (extension != "icon") {
 // 						if (extension == "jpg") {
 // 							extension = "jpeg";
 // 						}
 // 						photo->addChild( new Tag("TYPE", "image/" + extension) );
 // 					}
 // 				}
+			}
+		}
+	}
 	np->handleVCard(np->m_accounts[account], np->m_vcards[np->m_accounts[account] + name], name, fullName, nickname, Swift::byteArrayToString(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,
 	NULL,
 	NULL,
 	NULL, //requestClose,
 	NULL,
 	NULL,
 	NULL,
 	NULL,
 	NULL
 };
 static void * accountRequestAuth(PurpleAccount *account, const char *remote_user, const char *id, const char *alias, const char *message, gboolean on_list, PurpleAccountRequestAuthorizationCb authorize_cb, PurpleAccountRequestAuthorizationCb deny_cb, void *user_data) {
 	authRequest *req = new authRequest;
 	req->authorize_cb = authorize_cb;
 	req->deny_cb = deny_cb;
 	req->user_data = user_data;
 	req->account = account;
 	req->who = remote_user;
 	req->mainJID = np->m_accounts[account];
 	np->m_authRequests[req->mainJID + req->who] = req;
 	np->handleAuthorization(req->mainJID, req->who);
 	return req;
+}
 static void accountRequestClose(void *data){
 	authRequest *req = (authRequest *) data;
 	np->m_authRequests.erase(req->mainJID + req->who);
+}
 static PurpleAccountUiOps accountUiOps =
+{
 	NULL,
 	NULL,
 	NULL,
 	accountRequestAuth,
 	accountRequestClose,
 	NULL,
 	NULL,
 	NULL,
 	NULL
 };

include/Swiften/Server/Server.cpp

➞

Show inline comments

 /*
  * Copyright (c) 2010 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 #include "Swiften/Server/Server.h"
 #include <string>
 #include <boost/bind.hpp>
 #include "Swiften/Base/String.h"
 #include "Swiften/Base/foreach.h"
 #include "Swiften/Network/Connection.h"
 #include "Swiften/Network/ConnectionServer.h"
 #include "Swiften/Network/ConnectionServerFactory.h"
 #include "Swiften/Elements/Element.h"
 #include "Swiften/Elements/Presence.h"
 #include "Swiften/Elements/RosterPayload.h"
 #include "Swiften/Network/NetworkFactories.h"
 #include "Swiften/Session/SessionTracer.h"
 #include "Swiften/Elements/IQ.h"
 #include "Swiften/Elements/VCard.h"
 #include "Swiften/Server/UserRegistry.h"
 #include <string>
 #include "Swiften/Network/ConnectionServer.h"
 #include "Swiften/Network/ConnectionFactory.h"
 #include "Swiften/Server/ServerFromClientSession.h"
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Queries/IQRouter.h"
 namespace Swift {
 Server::Server(
 		EventLoop* eventLoop,
 		NetworkFactories* networkFactories,
 		UserRegistry *userRegistry,
 		const JID& jid,
 		int port) :
 			userRegistry_(userRegistry),
 			port_(port),
 			eventLoop(eventLoop),
 			networkFactories_(networkFactories),
 			stopping(false),
 			selfJID(jid),
 			stanzaChannel_(){
 	stanzaChannel_ = new ServerStanzaChannel();
 	iqRouter_ = new IQRouter(stanzaChannel_);
 	tlsFactory = NULL;
+}
 Server::~Server() {
 	stop();
 	delete iqRouter_;
 	delete stanzaChannel_;
+}
 void Server::start() {
 	assert(!serverFromClientConnectionServer);
 	if (serverFromClientConnectionServer) {
 		return;
+	}
 	serverFromClientConnectionServer = networkFactories_->getConnectionServerFactory()->createConnectionServer(port_);
 	serverFromClientConnectionServerSignalConnections.push_back(
 		serverFromClientConnectionServer->onNewConnection.connect(
 				boost::bind(&Server::handleNewClientConnection, this, _1)));
 // 	serverFromClientConnectionServerSignalConnections.push_back(
 // 		serverFromClientConnectionServer->onStopped.connect(
 // 				boost::bind(&Server::handleClientConnectionServerStopped, this, _1)));
 	serverFromClientConnectionServer->start();
+}
 void Server::stop() {
 	if (stopping) {
 		return;
+	}
 	stopping = true;
 	foreach(boost::shared_ptr<ServerFromClientSession> session, serverFromClientSessions) {
 		session->finishSession();
+	}
 	serverFromClientSessions.clear();
 	if (serverFromClientConnectionServer) {
 		serverFromClientConnectionServer->stop();
 		foreach(boost::bsignals::connection& connection, serverFromClientConnectionServerSignalConnections) {
 			connection.disconnect();
+		}
 		serverFromClientConnectionServerSignalConnections.clear();
 		serverFromClientConnectionServer.reset();
+	}
 	stopping = false;
 // 	onStopped(e);
+}
 void Server::handleNewClientConnection(boost::shared_ptr<Connection> connection) {
 	boost::shared_ptr<ServerFromClientSession> serverFromClientSession = boost::shared_ptr<ServerFromClientSession>(
 			new ServerFromClientSession(idGenerator.generateID(), connection,
 					&payloadParserFactories, &payloadSerializers, userRegistry_));
 	//serverFromClientSession->setAllowSASLEXTERNAL();
 	serverFromClientSession->onSessionStarted.connect(
 			boost::bind(&Server::handleSessionStarted, this, serverFromClientSession));
 	serverFromClientSession->onSessionFinished.connect(
 			boost::bind(&Server::handleSessionFinished, this,
 			serverFromClientSession));
 	serverFromClientSession->onDataRead.connect(boost::bind(&Server::handleDataRead, this, _1));
 	serverFromClientSession->onDataWritten.connect(boost::bind(&Server::handleDataWritten, this, _1));
 	dynamic_cast<ServerStanzaChannel *>(stanzaChannel_)->addSession(serverFromClientSession);
 	if (tlsFactory) {
 		serverFromClientSession->addTLSEncryption(tlsFactory, cert);
+	}
 	serverFromClientSession->startSession();
 	serverFromClientSessions.push_back(serverFromClientSession);
+}
 void Server::handleDataRead(const SafeByteArray& data) {
 	onDataRead(data);
+}
 void Server::handleDataWritten(const SafeByteArray& data) {
 	onDataWritten(data);
+}
 void Server::handleSessionStarted(boost::shared_ptr<ServerFromClientSession>) {
 // 	onSelfConnected(true);
+}
 void Server::handleSessionFinished(boost::shared_ptr<ServerFromClientSession> session) {
 	serverFromClientSessions.erase(std::remove(serverFromClientSessions.begin(), serverFromClientSessions.end(), session), serverFromClientSessions.end());
+}
 void Server::addTLSEncryption(TLSServerContextFactory* tlsContextFactory, const PKCS12Certificate& cert) {
 	tlsFactory = tlsContextFactory;
 	this->cert = cert;
+}
+}

0 comments (0 inline, 0 general)