libtransport.git Changeset - be6e854f3795

Changeset - be6e854f3795

Parent rev.

Child rev.

[Not reviewed]

0 2 0

HanzZ - 14 years ago 2011-07-31 19:10:48
hanzz.k@gmail.com

fixed vcards with prpl-any

2 files changed with 9 insertions and 5 deletions:

backends/libpurple/main.cpp

spectrum/src/sample.cfg

0 comments (0 inline, 0 general)

backends/libpurple/main.cpp

➞

Show inline comments

@@ @@ -259,192 +259,196 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
 					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
 				malloc_trim(0);
 // 				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 Swift::StatusShow::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 Swift::StatusShow::DND: {
 						st = PURPLE_STATUS_UNAVAILABLE;
 						break;
+					}
 					case Swift::StatusShow::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 Swift::StatusShow::None: {
 						st = PURPLE_STATUS_OFFLINE;
 						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);
 				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);
 					g_free(_markup);
+				}
 				else {
 					purple_conv_im_send(PURPLE_CONV_IM(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 (CONFIG_STRING(config, "service.protocol") == "any") {
 					name = name.substr(name.find(".") + 1);
+				}
 				serv_get_info(purple_account_get_connection(account), legacyName.c_str());
 				m_vcards[user + legacyName] = id;
+			}
+		}
 		void handleVCardUpdatedRequest(const std::string &user, const std::string &p) {
 			PurpleAccount *account = m_sessions[user];
 			if (account) {
 				gssize size = p.size();
 				// this will be freed by libpurple
 				guchar *photo = (guchar *) g_malloc(size * sizeof(guchar));
 				memcpy(photo, p.c_str(), size);
 #ifdef WITH_IMAGEMAGICK
 				if (size != 0) {
 					PurplePlugin *plugin = purple_find_prpl(Transport::instance()->protocol()->protocol().c_str());
 					PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(plugin);
 					if (prpl_info->icon_spec.format == NULL) {
 						g_free(photo);
 						return;
+					}
 					try {
 						Magick::Blob blob(photo, size);
 						g_free(photo);
 						photo = NULL;
 						Magick::Image img(blob);
 						std::string format;
 						gchar **strlist = g_strsplit(prpl_info->icon_spec.format, ",", 10);
 						for (gchar **f = strlist; *f != NULL; f++) {
 							// jpeg is the best
 							if (strcmp(*f, "jpeg") == 0 || strcmp(*f, "jpg") == 0) {
 								format = "jpg";
+							}
 							// png is number two
 							else if (strcmp(*f, "png") == 0 && format != "jpg") {
 								format = *f;
+							}
 							// gif is alright if there's not jpeg or png
 							else if (strcmp(*f, "gif") == 0 && format != "jpg" && format != "png") {
 								format = *f;
+							}
 							else if (format.empty()) {
 								format = *f;
+							}
+						}
 						g_strfreev(strlist);
 						img.magick(format);
 						int width, height;
 						if (CONFIG().protocol == "icq") {
 							width = 48;
 							height = 48;
+						}
 						else {
 							purple_buddy_icon_get_scale_size(&prpl_info->icon_spec, &width, &height);
+						}
 						if (img.size().width() != width || img.size().height() != height) {
 							Magick::Geometry g = Magick::Geometry(width,height);
 							g.aspect(CONFIG().protocol == "icq");
 							img.scale(g);
+						}
 						Magick::Blob output;
 						img.write(&output);
 						size = output.length();
 						// this will be freed by libpurple
 						photo = (guchar *) g_malloc(size * sizeof(guchar));
 						memcpy(photo, output.data(), size);
+					}
 					catch ( Magick::Exception & error) {
 						Log("handleVCard","Caught Magick++ exception: " << error.what());
 					} catch(...) {   // catch all other exceptions
+					}
+				}
 #endif /* WITH_IMAGEMAGICK */
 				if (!photo)
 					return;
 				purple_buddy_icons_set_account_icon(account, photo, size);
+			}
+		}
 		void handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const 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);
+				}
@@ @@ -491,193 +495,193 @@ class SpectrumNetworkPlugin : public NetworkPlugin { @@
 		void handleBuddyBlockToggled(const std::string &user, const std::string &buddyName, bool blocked) {
 			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);
+			}
+		}
 		std::map<std::string, PurpleAccount *> m_sessions;
 		std::map<PurpleAccount *, std::string> m_accounts;
 		std::map<std::string, unsigned int> m_vcards;
 		std::map<std::string, authRequest *> m_authRequests;
 	private:
 		Config *config;
 };
 static bool getStatus(PurpleBuddy *m_buddy, Swift::StatusShow &status, std::string &statusMessage) {
 	PurplePresence *pres = purple_buddy_get_presence(m_buddy);
 	if (pres == NULL)
 		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: {
 			break;
+		}
 		case PURPLE_STATUS_AWAY: {
 			status = Swift::StatusShow::Away;
 			break;
+		}
 		case PURPLE_STATUS_UNAVAILABLE: {
 			status = Swift::StatusShow::DND;
 			break;
+		}
 		case PURPLE_STATUS_EXTENDED_AWAY: {
 			status = Swift::StatusShow::XA;
 			break;
+		}
 		case PURPLE_STATUS_OFFLINE: {
 			status = Swift::StatusShow::None;
 			break;
+		}
 		default:
 			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);
 		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;
 	groups.push_back((purple_buddy_get_group(m_buddy) && purple_group_get_name(purple_buddy_get_group(m_buddy))) ? std::string(purple_group_get_name(purple_buddy_get_group(m_buddy))) : std::string("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);
 	Swift::StatusShow status;
 	std::string message;
 	getStatus(buddy, status, message);
 	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy)[0], (int) status.getType(), message, getIconHash(buddy));
+}
 // static void buddyStatusChanged(PurpleBuddy *buddy, PurpleStatus *status_, PurpleStatus *old_status) {
 // 	PurpleAccount *account = purple_buddy_get_account(buddy);
 //
 // 	Swift::StatusShow status;
 // 	std::string message;
 // 	getStatus(buddy, status, message);
 //
 // 	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy)[0], (int) status.getType(), message, getIconHash(buddy));
 // }
 //
 // static void buddySignedOn(PurpleBuddy *buddy) {
 // 	PurpleAccount *account = purple_buddy_get_account(buddy);
 //
 // 	Swift::StatusShow status;
 // 	std::string message;
 // 	getStatus(buddy, status, message);
 //
 // 	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy)[0], (int) status.getType(), message, getIconHash(buddy));
 // }
 //
 // static void buddySignedOff(PurpleBuddy *buddy) {
 // 	PurpleAccount *account = purple_buddy_get_account(buddy);
 //
 // 	Swift::StatusShow status;
 // 	std::string message;
 // 	getStatus(buddy, status, message);
 //
 // 	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy)[0], (int) status.getType(), message, getIconHash(buddy));
 // }
 static void buddyListUpdate(PurpleBuddyList *list, PurpleBlistNode *node) {
 	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
 		return;
 	PurpleBuddy *buddy = (PurpleBuddy *) node;
 	PurpleAccount *account = purple_buddy_get_account(buddy);
 	Swift::StatusShow status;
 	std::string message;
 	getStatus(buddy, status, message);
 	np->handleBuddyChanged(np->m_accounts[account], purple_buddy_get_name(buddy), getAlias(buddy), getGroups(buddy)[0], (int) status.getType(), message, getIconHash(buddy),
 		purple_privacy_check(account, purple_buddy_get_name(buddy)) == false);
+}
 static void NodeRemoved(PurpleBlistNode *node, void *data) {
 	if (!PURPLE_BLIST_NODE_IS_BUDDY(node))
 		return;
 // 	PurpleBuddy *buddy = (PurpleBuddy *) node;
+}
 static PurpleBlistUiOps blistUiOps =
@@ @@ -739,223 +743,223 @@ 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 {
 				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 (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);
+			}
-// 			purple_imgstore_unref(avatar);
 			purple_imgstore_unref(avatar);
+		}
+	}
 	if ((!firstName.empty() || !lastName.empty()) && fullName.empty())
 		fullName = firstName + " " + lastName;
 	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) {
 			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) );
 // 					}
 // 				}
+			}
-// 			purple_buddy_icon_unref(icon);
 			purple_buddy_icon_unref(icon);
+		}
+	}
 	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
 };
 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(getXferUiOps());
 	purple_connections_set_ui_ops(&conn_ui_ops);
 	purple_conversations_set_ui_ops(&conversation_ui_ops);
 // #ifndef WIN32
 // 	purple_dnsquery_set_ui_ops(getDNSUiOps());
 // #endif
+}
 static PurpleCoreUiOps coreUiOps =
+{
 	NULL,
 // 	debug_init,
 	NULL,
 	transport_core_ui_init,

spectrum/src/sample.cfg

➞

Show inline comments

 [service]
 jid = localhost
 password = secret
 server = 127.0.0.1
 port = 5222
 server_mode = 1
 backend_host=localhost # < this option doesn't work yet
 backend_port=10001
 admin_username=admin
 admin_password=test
 #cert= #patch to PKCS#12 certificate
 #cert_password= #password to that certificate if any
 users_per_backend=10
 backend=../../backends/libpurple/spectrum_libpurple_backend
 #backend=../../backends/libircclient-qt/spectrum_libircclient-qt_backend
 protocol=prpl-msn
 #protocol=any
 #protocol=prpl-msn
 protocol=any
 #protocol=prpl-icq
 [backend]
 default_avatar=catmelonhead.jpg
 [logging]
 #config=logging.cfg # log4cxx/log4j logging configuration file
 #backend_config=backend_logging.cfg # log4cxx/log4j logging configuration file for backends
 [database]
 type = none # or "none" without database backend
 database = test.sql
 prefix=icq

0 comments (0 inline, 0 general)