return skype->loadSkypeBuddies();

}

bool Skype::createDBusProxy() {

	if (m_proxy == NULL) {

		LOG4CXX_INFO(logger, "Creating DBus proxy for com.Skype.Api.");

		m_counter++;

		GError *error = NULL;

		m_proxy = dbus_g_proxy_new_for_name_owner (m_connection, "com.Skype.API", "/com/Skype", "com.Skype.API", &error);

		if (m_proxy == NULL && error != NULL) {

			LOG4CXX_INFO(logger,  m_username << ":" << error->message);

			if (m_counter == 15) {

				np->handleDisconnected(m_user, 0, error->message);

				logout();

				g_error_free(error);

				return FALSE;

			}

			g_error_free(error);

		}

		if (m_proxy) {

			LOG4CXX_INFO(logger, "Proxy created.");

			DBusObjectPathVTable vtable;

			vtable.message_function = &skype_notify_handler;

			dbus_connection_register_object_path(dbus_g_connection_get_connection(m_connection), "/com/Skype/Client", &vtable, this);

			m_counter = 0;

			m_timer = g_timeout_add_seconds(1, load_skype_buddies, this);

			return FALSE;

		}

		return TRUE;

	}

	return FALSE;

}

static gboolean create_dbus_proxy(gpointer data) {

	Skype *skype = (Skype *) data;

	return skype->createDBusProxy();

}

void Skype::login() {

	boost::filesystem::path	path(std::string("/tmp/skype/") + m_username);

	if (!boost::filesystem::exists(path)) {

		boost::filesystem::create_directories(path);

		boost::filesystem::path	path2(std::string("/tmp/skype/") + m_username + "/" + m_username );

		boost::filesystem::create_directories(path2);

	}

	std::string shared_xml = "<?xml version=\"1.0\"?>\n"

							"<config version=\"1.0\" serial=\"28\" timestamp=\"" + boost::lexical_cast<std::string>(time(NULL)) + ".0\">\n"

							"<UI>\n"

								"<Installed>2</Installed>\n"

								"<Language>en</Language>\n"

							"</UI>\n"

							"</config>\n";

	g_file_set_contents(std::string(std::string("/tmp/skype/") + m_username + "/shared.xml").c_str(), shared_xml.c_str(), -1, NULL);

	std::string config_xml = "<?xml version=\"1.0\"?>\n"

							"<config version=\"1.0\" serial=\"7\" timestamp=\"" + boost::lexical_cast<std::string>(time(NULL)) + ".0\">\n"

								"<Lib>\n"

									"<Account>\n"

									"<IdleTimeForAway>30000000</IdleTimeForAway>\n"

									"<IdleTimeForNA>300000000</IdleTimeForNA>\n"

									"<LastUsed>" + boost::lexical_cast<std::string>(time(NULL)) + "</LastUsed>\n"

									"</Account>\n"

								"</Lib>\n"

								"<UI>\n"

									"<API>\n"

									"<Authorizations>Spectrum</Authorizations>\n"

									"<BlockedPrograms></BlockedPrograms>\n"

									"</API>\n"

								"</UI>\n"

							"</config>\n";

	g_file_set_contents(std::string(std::string("/tmp/skype/") + m_username + "/" + m_username +"/config.xml").c_str(), config_xml.c_str(), -1, NULL);

	std::string db_path = std::string("/tmp/skype/") + m_username;

	char *db = (char *) malloc(db_path.size() + 1);

	strcpy(db, db_path.c_str());

	LOG4CXX_INFO(logger,  m_username << ": Spawning new Skype instance dbpath=" << db);

	gchar* argv[6] = {"skype", "--disable-cleanlooks", "--pipelogin", "--dbpath", db, 0};

	int fd;

	g_spawn_async_with_pipes(NULL,

		argv,

		NULL /*envp*/,

		G_SPAWN_SEARCH_PATH,

		NULL /*child_setup*/,

		NULL /*user_data*/,

		&m_pid /*child_pid*/,

		&fd,

		NULL,

		&fd_output,

		NULL /*error*/);

	std::string login_data = std::string(m_username + " " + m_password + "\n");

	LOG4CXX_INFO(logger,  m_username << ": Login data=" << login_data);

	write(fd, login_data.c_str(), login_data.size());

	close(fd);

	fcntl (fd_output, F_SETFL, O_NONBLOCK);

	free(db);

	//Initialise threading

	dbus_threads_init_default();

	if (m_connection == NULL)

	{

		LOG4CXX_INFO(logger, "Creating DBus connection.");

		GError *error = NULL;

		m_connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);

		if (m_connection == NULL && error != NULL)

		{

			LOG4CXX_INFO(logger,  m_username << ": DBUS Error: " << error->message);

			g_error_free(error);

			return;

		}

	}

	m_timer = g_timeout_add_seconds(1, create_dbus_proxy, this);

}

bool Skype::loadSkypeBuddies() {

//	std::string re = "CONNSTATUS OFFLINE";

//	while (re == "CONNSTATUS OFFLINE" || re.empty()) {

//		sleep(1);

	gchar buffer[1024];

	int bytes_read = read(fd_output, buffer, 1023);

	if (bytes_read > 0) {

		buffer[bytes_read] = 0;

		np->handleDisconnected(m_user, 0, buffer);

		close(fd_output);

		logout();

		return FALSE;

	}

	std::string re = send_command("NAME Spectrum");

	if (m_counter++ > 15) {

		np->handleDisconnected(m_user, 0, "");

		close(fd_output);

		logout();

		return FALSE;

	}

	if (re.empty() || re == "CONNSTATUS OFFLINE") {

		return TRUE;

	}

	close(fd_output);

	if (send_command("PROTOCOL 7") != "PROTOCOL 7") {

		np->handleDisconnected(m_user, 0, "Skype is not ready");

		logout();

		return FALSE;

	}

	np->handleConnected(m_user);

	std::map<std::string, std::string> group_map;

	std::string groups = send_command("SEARCH GROUPS CUSTOM");

	groups = groups.substr(groups.find(' ') + 1);

	std::vector<std::string> grps;

	boost::split(grps, groups, boost::is_any_of(","));

	BOOST_FOREACH(std::string grp, grps) {

		std::vector<std::string> data;

		std::string name = send_command("GET GROUP " + grp + " DISPLAYNAME");

		boost::split(data, name, boost::is_any_of(" "));

		name = name.substr(name.find("DISPLAYNAME") + 12);

		std::string users = send_command("GET GROUP " + data[1] + " USERS");

		users = name.substr(name.find("USERS") + 6);

		boost::split(data, users, boost::is_any_of(","));

		BOOST_FOREACH(std::string u, data) {

			group_map[u] = grp;

		}

	}

	std::string friends = send_command("GET AUTH_CONTACTS_PROFILES");

	char **full_friends_list = g_strsplit((strchr(friends.c_str(), ' ')+1), ";", 0);

	if (full_friends_list && full_friends_list[0])

	{

		//in the format of: username;full name;phone;office phone;mobile phone;

		//                  online status;friendly name;voicemail;mood

		// (comma-seperated lines, usernames can have comma's)

		for (int i=0; full_friends_list[i] && *full_friends_list[i] != '\0'; i+=8)

		{

			std::string buddy = full_friends_list[i];

			if (buddy[0] == ',') {

				buddy.erase(buddy.begin());

			}

			LOG4CXX_INFO(logger, "Got buddy " << buddy);

			std::string st = full_friends_list[i + 5];

			pbnetwork::StatusType status = getStatus(st);

			std::string alias = full_friends_list[i + 6];

			std::string mood_text = "";

			if (full_friends_list[i + 8] && *full_friends_list[i + 8] != '\0' && *full_friends_list[i + 8] != ',') {

				mood_text = full_friends_list[i + 8];

			}

			std::vector<std::string> groups;

			groups.push_back(group_map[buddy]);

			np->handleBuddyChanged(m_user, buddy, alias, groups, status, mood_text);

		}

	}

	g_strfreev(full_friends_list);

	send_command("SET AUTOAWAY OFF");

	return FALSE;

}

void Skype::logout() {

	if (m_pid != 0) {

		send_command("SET USERSTATUS INVISIBLE");

		send_command("SET USERSTATUS OFFLINE");

		sleep(2);

		g_object_unref(m_proxy);

		LOG4CXX_INFO(logger,  m_username << ": Killing Skype instance");

		kill((int) m_pid, SIGTERM);

		m_pid = 0;

	}

}

std::string Skype::send_command(const std::string &message) {

	GError *error = NULL;

	gchar *str = NULL;

// 			int message_num;

// 			gchar error_return[30];

	if (!dbus_g_proxy_call (m_proxy, "Invoke", &error, G_TYPE_STRING, message.c_str(), G_TYPE_INVALID,

						G_TYPE_STRING, &str, G_TYPE_INVALID))

	{

			if (error && error->message)

			{

			LOG4CXX_INFO(logger,  m_username << ": DBUS Error: " << error->message);

			g_error_free(error);

		} else {

			LOG4CXX_INFO(logger,  m_username << ": DBUS no response");

		}

	}

	if (str != NULL)

	{

		LOG4CXX_INFO(logger,  m_username << ": DBUS:" << str);

	}

	return str ? std::string(str) : std::string();

}

static void handle_skype_message(std::string &message, Skype *sk) {

	std::vector<std::string> cmd;

	boost::split(cmd, message, boost::is_any_of(" "));

	if (cmd[0] == "USER") {

		if (cmd[1] == sk->getUsername()) {

			return;

		}

		if (cmd[2] == "ONLINESTATUS") {

			if (cmd[3] == "SKYPEOUT" || cmd[3] == "UNKNOWN") {

				return;

			}

			else {

				pbnetwork::StatusType status = getStatus(cmd[3]);

				std::string mood_text = sk->send_command("GET USER " + cmd[1] + " MOOD_TEXT");

				mood_text = mood_text.substr(mood_text.find("MOOD_TEXT") + 10);

				std::string alias = sk->send_command("GET USER " + cmd[1] + " FULLNAME");

				alias = alias.substr(alias.find("FULLNAME") + 9);

				std::vector<std::string> groups;

				np->handleBuddyChanged(sk->getUser(), cmd[1], alias, groups, status, mood_text);

			}

		}

		else if (cmd[2] == "MOOD_TEXT") {

			std::string st = sk->send_command("GET USER " + cmd[1] + " ONLINESTATUS");

			st = st.substr(st.find("ONLINESTATUS") + 13);

			pbnetwork::StatusType status = getStatus(st);

			std::string mood_text = message.substr(message.find("MOOD_TEXT") + 10);

			std::vector<std::string> groups;

			np->handleBuddyChanged(sk->getUser(), cmd[1], "", groups, status, mood_text);

		}

		else if (cmd[2] == "BUDDYSTATUS" && cmd[3] == "3") {

			std::string st = sk->send_command("GET USER " + cmd[1] + " ONLINESTATUS");

			st = st.substr(st.find("ONLINESTATUS") + 13);

			pbnetwork::StatusType status = getStatus(st);

			std::string mood_text = message.substr(message.find("MOOD_TEXT") + 10);

			std::vector<std::string> groups;

			np->handleBuddyChanged(sk->getUser(), cmd[1], "", groups, status, mood_text);

		}

	}

	else if (cmd[0] == "CHATMESSAGE") {

		if (cmd[3] == "RECEIVED") {

			std::string body = sk->send_command("GET CHATMESSAGE " + cmd[1] + " BODY");

			body = body.substr(body.find("BODY") + 5);

			std::string chatname = sk->send_command("GET CHATMESSAGE " + cmd[1] + " CHATNAME");

			size_t start = chatname.find("$") + 1;

			size_t len = chatname.find(";") - start;

			std::string from = chatname.substr(start, len);

			std::string from_handle = sk->send_command("GET CHATMESSAGE " + cmd[1] + " FROM_HANDLE");

			from_handle = from_handle.substr(from_handle.find("FROM_HANDLE") + 12);

// 			if (from_handle != sk->getUsername()) {

				from = from_handle;

// 			}

			if (from_handle == sk->getUsername())

				return;

			np->handleMessage(sk->getUser(), from, body);

		}

	}

}

DBusHandlerResult skype_notify_handler(DBusConnection *connection, DBusMessage *message, gpointer user_data) {

	DBusMessageIter iterator;

	gchar *message_temp;

	DBusMessage *temp_message;

	temp_message = dbus_message_ref(message);

	dbus_message_iter_init(temp_message, &iterator);

	if (dbus_message_iter_get_arg_type(&iterator) != DBUS_TYPE_STRING)

	{

		dbus_message_unref(message);

		return (DBusHandlerResult) FALSE;

	}

	do {

		dbus_message_iter_get_basic(&iterator, &message_temp);

		std::string m(message_temp);

		LOG4CXX_INFO(logger,"DBUS message: " << m);

		handle_skype_message(m, (Skype *) user_data);

	} while(dbus_message_iter_has_next(&iterator) && dbus_message_iter_next(&iterator));

	dbus_message_unref(message);

	return DBUS_HANDLER_RESULT_HANDLED;

}

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

	}

}

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;

	}