PurplePlugin *plugin = purple_find_prpl(purple_account_get_protocol_id(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));

					if (key != key2) {

						continue;

					}

					found = true;

					switch (type) {

						case PURPLE_PREF_BOOLEAN:

							purple_account_set_bool(account, key.c_str(), fromString<bool>(KEYFILE_STRING("purple", key)));

							break;

						case PURPLE_PREF_INT:

							purple_account_set_int(account, key.c_str(), fromString<int>(KEYFILE_STRING("purple", key)));

							break;

						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()) {

				np->handleDisconnected(user, 0, "Empty password.");

				return;

			}

			if (!purple_find_prpl(protocol.c_str())) {

				np->handleDisconnected(user, 0, "Invalid protocol " + protocol);

				return;

			}

			LOG4CXX_INFO(logger,  "Creating account with name '" << name.c_str() << "' and protocol '" << protocol << "'");

			if (purple_accounts_find(name.c_str(), protocol.c_str()) != NULL){

				account = purple_accounts_find(name.c_str(), protocol.c_str());

			}

			else {

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

	return ret;

}

#ifndef WIN32

static void spectrum_sigchld_handler(int sig)

{

	int status;

	pid_t pid;

	do {

		pid = waitpid(-1, &status, WNOHANG);

	} while (pid != 0 && pid != (pid_t)-1);

	if ((pid == (pid_t) - 1) && (errno != ECHILD)) {

		char errmsg[BUFSIZ];

		snprintf(errmsg, BUFSIZ, "Warning: waitpid() returned %d", pid);

		perror(errmsg);

	}

}

#endif

static int create_socket(char *host, int portno) {

	struct sockaddr_in serv_addr;

	int m_sock = socket(AF_INET, SOCK_STREAM, 0);

	memset((char *) &serv_addr, 0, sizeof(serv_addr));

	serv_addr.sin_family = AF_INET;

	serv_addr.sin_port = htons(portno);

	hostent *hos;  // Resolve name

	if ((hos = gethostbyname(host)) == NULL) {

		// strerror() will not work for gethostbyname() and hstrerror() 

		// is supposedly obsolete

		exit(1);

	}

	serv_addr.sin_addr.s_addr = *((unsigned long *) hos->h_addr_list[0]);

	if (connect(m_sock, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {

		close(m_sock);

		m_sock = 0;

	}

	int flags = fcntl(m_sock, F_GETFL);

	flags |= O_NONBLOCK;

	fcntl(m_sock, F_SETFL, flags);

	return m_sock;

}

static void transportDataReceived(gpointer data, gint source, PurpleInputCondition cond) {

	if (cond & PURPLE_INPUT_READ) {

		char buffer[65535];

		char *ptr = buffer;

		ssize_t n = read(source, ptr, sizeof(buffer));

		if (n <= 0) {

			LOG4CXX_INFO(logger, "Diconnecting from spectrum2 server");

			exit(errno);

		}

		std::string d = std::string(buffer, n);

		np->handleDataRead(d);

	}

	else {

		if (writeInput != 0) {

			purple_input_remove(writeInput);

			writeInput = 0;

		}

		np->readyForData();

	}

}

int main(int argc, char **argv) {

	GError *error = NULL;

	GOptionContext *context;

	context = g_option_context_new("config_file_name or profile name");

	g_option_context_add_main_entries(context, options_entries, "");

	if (!g_option_context_parse (context, &argc, &argv, &error)) {

		std::cout << "option parsing failed: " << error->message << "\n";

		return -1;

	}

	if (ver) {

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

		std::cout << "verze\n";

		g_option_context_free(context);

		return 0;

	}

	if (argc != 2) {

#ifdef WIN32

		std::cout << "Usage: spectrum.exe <configuration_file.cfg>\n";

#else

#if GLIB_CHECK_VERSION(2,14,0)

	std::cout << g_option_context_get_help(context, FALSE, NULL);

#else

	std::cout << "Usage: spectrum <configuration_file.cfg>\n";

	std::cout << "See \"man spectrum\" for more info.\n";

#endif

				"KEY `user_id` (`user_id`)"

			") ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin;");

		exec("CREATE TABLE IF NOT EXISTS `" + m_prefix + "users` ("

				"`id` int(10) unsigned NOT NULL auto_increment,"

				"`jid` varchar(255) collate utf8_bin NOT NULL,"

				"`uin` varchar(4095) collate utf8_bin NOT NULL,"

				"`password` varchar(255) collate utf8_bin NOT NULL,"

				"`language` varchar(25) collate utf8_bin NOT NULL,"

				"`encoding` varchar(50) collate utf8_bin NOT NULL default 'utf8',"

				"`last_login` datetime,"

				"`vip` tinyint(1) NOT NULL  default '0',"

				"`online` tinyint(1) NOT NULL  default '0',"

				"PRIMARY KEY (`id`),"

				"UNIQUE KEY `jid` (`jid`)"

			") ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin;");

		exec("CREATE TABLE IF NOT EXISTS `" + m_prefix + "users_settings` ("

				"`user_id` int(10) unsigned NOT NULL,"

				"`var` varchar(50) collate utf8_bin NOT NULL,"

				"`type` smallint(4) unsigned NOT NULL,"

				"`value` varchar(255) collate utf8_bin NOT NULL,"

				"PRIMARY KEY (`user_id`,`var`),"

				"KEY `user_id` (`user_id`)"

			") ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin;");

		exec("CREATE TABLE IF NOT EXISTS `" + m_prefix + "db_version` ("

				"`ver` int(10) unsigned NOT NULL default '1',"

				"UNIQUE KEY `ver` (`ver`)"

			") ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin;");

		exec("INSERT IGNORE INTO db_version (ver) VALUES ('2');");

	}

	return true;

}

bool MySQLBackend::exec(const std::string &query) {

	if (mysql_query(&m_conn, query.c_str())) {

		LOG4CXX_ERROR(logger, query << " " << mysql_error(&m_conn));

		return false;

	}

	return true;

}

void MySQLBackend::setUser(const UserInfo &user) {

	std::string encrypted = user.password;

	if (!CONFIG_STRING(m_config, "database.encryption_key").empty()) {

	}

	*m_setUser << user.jid << user.uin << encrypted << user.language << user.encoding << user.vip << user.password;

	EXEC(m_setUser, setUser(user));

}

bool MySQLBackend::getUser(const std::string &barejid, UserInfo &user) {

	*m_getUser << barejid;

	EXEC(m_getUser, getUser(barejid, user));

	if (!exec_ok)

		return false;

	int ret = false;

	while (m_getUser->fetch() == 0) {

		ret = true;

		*m_getUser >> user.id >> user.jid >> user.uin >> user.password >> user.encoding >> user.language >> user.vip;

		if (!CONFIG_STRING(m_config, "database.encryption_key").empty()) {

			user.password = Util::decryptPassword(user.password, CONFIG_STRING(m_config, "database.encryption_key"));

		}

	}

	return ret;

}

void MySQLBackend::setUserOnline(long id, bool online) {

	*m_setUserOnline << online << id;

	EXEC(m_setUserOnline, setUserOnline(id, online));

}

long MySQLBackend::addBuddy(long userId, const BuddyInfo &buddyInfo) {

// 	"INSERT INTO " + m_prefix + "buddies (user_id, uin, subscription, groups, nickname, flags) VALUES (?, ?, ?, ?, ?, ?)"

	*m_addBuddy << userId << buddyInfo.legacyName << buddyInfo.subscription;

	*m_addBuddy << (buddyInfo.groups.size() == 0 ? "" : buddyInfo.groups[0]);

	*m_addBuddy << buddyInfo.alias << buddyInfo.flags;

	EXEC(m_addBuddy, addBuddy(userId, buddyInfo));

	long id = (long) mysql_insert_id(&m_conn);

// 	INSERT OR REPLACE INTO " + m_prefix + "buddies_settings (user_id, buddy_id, var, type, value) VALUES (?, ?, ?, ?, ?)

	if (!buddyInfo.settings.find("icon_hash")->second.s.empty()) {

		*m_updateBuddySetting << userId << id << buddyInfo.settings.find("icon_hash")->first << (int) TYPE_STRING << buddyInfo.settings.find("icon_hash")->second.s << buddyInfo.settings.find("icon_hash")->second.s;

		EXEC(m_updateBuddySetting, addBuddy(userId, buddyInfo));

	}

	return id;

}