//look for start of JPEG block

								img_start = (char *)memmem(start, end-start, "\xFF\xD8", 2);

								if (img_start)

								{

									//look for end of JPEG block

									char *img_end = (char *)memmem(img_start, end-img_start, "\xFF\xD9", 2);

									if (img_end)

									{

										image_data_len = img_end - img_start + 2;

										photo = std::string(img_start, image_data_len);

									}

								}

							}

						}

						g_free(image_data);

					}

					g_free(filename);

				}

				g_free(username);

				std::string alias = "";

				std::cout << skype->getUsername() << " " << name << "\n";

				if (skype->getUsername() == name) {

					alias = skype->send_command("GET PROFILE FULLNAME");

					alias = GET_RESPONSE_DATA(alias, "FULLNAME")

				}

				handleVCard(user, id, legacyName, "", alias, photo);

			}

		}

		void sendData(const std::string &string) {

			write(m_sock, string.c_str(), string.size());

// 			if (writeInput == 0)

// 				writeInput = purple_input_add(m_sock, PURPLE_INPUT_WRITE, &transportDataReceived, NULL);

		}

		void handleVCardUpdatedRequest(const std::string &user, const std::string &p, const std::string &nickname) {

		}

		void handleBuddyBlockToggled(const std::string &user, const std::string &buddyName, bool blocked) {

		}

		void handleTypingRequest(const std::string &user, const std::string &buddyName) {

		}

		void handleTypedRequest(const std::string &user, const std::string &buddyName) {

		}

		void handleStoppedTypingRequest(const std::string &user, const std::string &buddyName) {

		}

		void handleAttentionRequest(const std::string &user, const std::string &buddyName, const std::string &message) {

		}

		std::map<std::string, Skype *> m_sessions;

		std::map<Skype *, std::string> m_accounts;

		std::map<std::string, unsigned int> m_vcards;

		Config *config;

};

Skype::Skype(const std::string &user, const std::string &username, const std::string &password) {

	m_username = username;

	m_user = user;

	m_password = password;

	m_pid = 0;

	m_connection = 0;

	m_proxy = 0;

	m_timer = -1;

	m_counter = 0;

}

static gboolean load_skype_buddies(gpointer data) {

	Skype *skype = (Skype *) data;

	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, pbnetwork::CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE, 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() {

	if (m_username.find("..") == 0 || m_username.find("/") != std::string::npos) {

		np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE, "Invalid username");

		return;

	}

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

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

	sleep(1);

	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;

		argv,

		NULL /*envp*/,

		G_SPAWN_SEARCH_PATH,

		NULL /*child_setup*/,

		NULL /*user_data*/,

		&m_pid /*child_pid*/,

		&fd,

		NULL,

		&fd_output,

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

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

	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)

	{

		GError *error = NULL;

		m_connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);

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

		{

			g_error_free(error);

			return;

		}

	}

	sleep(1);

	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;

		std::string b(buffer);

		LOG4CXX_WARN(logger, "Skype wrote this on stdout '" << b << "'");

		if (b.find("Incorrect Password") != std::string::npos) {

			LOG4CXX_INFO(logger, "Incorrect password, logging out")

			np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_AUTHENTICATION_FAILED, "Incorrect password");

			close(fd_output);

			logout();

			return FALSE;

		}

	}

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

	if (m_counter++ > 15) {

		LOG4CXX_ERROR(logger, "Logging out, because we tried to connect the Skype over DBUS 15 times without success");

		np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE, "Skype is not ready. This issue have been logged and admins will check it and try to fix it soon.");

		close(fd_output);

		logout();

		return FALSE;

	}

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

		return TRUE;

	}

	close(fd_output);

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

		LOG4CXX_ERROR(logger, "PROTOCOL 7 failed, logging out");

		np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE, "Skype is not ready. This issue have been logged and admins will check it and try to fix it soon.");

		logout();

		return FALSE;

	}

	np->handleConnected(m_user);

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

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

	if (groups.find(' ') != std::string::npos) {

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

			if (name.find("ERROR") == 0) {

				continue;

			}

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

			name = GET_RESPONSE_DATA(name, "DISPLAYNAME");

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

			try {

				users = GET_RESPONSE_DATA(users, "USERS");

			}

			catch (std::out_of_range& oor) {

				continue;

			}

			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+1] && *full_friends_list[i] != '\0'; i+=8)

		{

			std::string buddy = full_friends_list[i];