if (xfer) {

				m_unhandledXfers.erase(user + fileName + buddyName);

				purple_xfer_request_denied(xfer);

			}

		}

		void handleFTPauseRequest(unsigned long ftID) {

			PurpleXfer *xfer = m_xfers[ftID];

			if (!xfer)

				return;

			FTData *ftData = (FTData *) xfer->ui_data;

			ftData->paused = true;

		}

		void handleFTContinueRequest(unsigned long ftID) {

			PurpleXfer *xfer = m_xfers[ftID];

			if (!xfer)

				return;

			FTData *ftData = (FTData *) xfer->ui_data;

			ftData->paused = false;

			purple_xfer_ui_ready(xfer);

		}

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

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

			if (writeInput == 0)

				writeInput = purple_input_add(main_socket, PURPLE_INPUT_WRITE, &transportDataReceived, NULL);

		}

		void readyForData() {

			if (m_waitingXfers.empty())

				return;

			std::vector<PurpleXfer *> tmp;

			tmp.swap(m_waitingXfers);

			for (std::vector<PurpleXfer *>::const_iterator it = tmp.begin(); it != tmp.end(); it++) {

				FTData *ftData = (FTData *) (*it)->ui_data;

				if (ftData->timer == 0) {

					ftData->timer = purple_timeout_add(1, ft_ui_ready, *it);

				}

// 				purple_xfer_ui_ready(xfer);

			}

		}

		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;

		std::map<unsigned long, PurpleXfer *> m_xfers;

static void buddyTypingStopped(PurpleAccount *account, const char *who, gpointer null){

	std::string w = purple_normalize(account, who);

	size_t pos = w.find("/");

	if (pos != std::string::npos)

		w.erase((int) pos, w.length() - (int) pos);

	np->handleBuddyStoppedTyping(np->m_accounts[account], w);

}

static void gotAttention(PurpleAccount *account, const char *who, PurpleConversation *conv, guint type) {

	std::string w = purple_normalize(account, who);

	size_t pos = w.find("/");

	if (pos != std::string::npos)

		w.erase((int) pos, w.length() - (int) pos);

	np->handleAttention(np->m_accounts[account], w, "");

}

static bool initPurple() {

	bool ret;

	if (!resolvePurpleFunctions()) {

		LOG4CXX_ERROR(logger, "Unable to load libpurple.dll or some of the needed methods");

		return false;

	}

	purple_util_set_user_dir("./");

	remove("./accounts.xml");

	remove("./blist.xml");

	purple_debug_set_ui_ops(&debugUiOps);

	purple_debug_set_verbose(true);

	purple_core_set_ui_ops(&coreUiOps);

	if (KEYFILE_STRING("service", "eventloop") == "libev") {

		LOG4CXX_INFO(logger, "Will use libev based event loop");

	}

	else {

		LOG4CXX_INFO(logger, "Will use glib based event loop");

	}

	purple_eventloop_set_ui_ops(getEventLoopUiOps(KEYFILE_STRING("service", "eventloop") == "libev"));

	ret = purple_core_init("spectrum");

	if (ret) {

		static int blist_handle;

		static int conversation_handle;

		purple_set_blist(purple_blist_new());

		purple_blist_load();

// 		purple_signal_connect(purple_blist_get_handle(), "buddy-removed", &blist_handle,PURPLE_CALLBACK(buddyRemoved), NULL);

// 		purple_signal_connect(purple_blist_get_handle(), "buddy-signed-on", &blist_handle,PURPLE_CALLBACK(buddySignedOn), NULL);

// 		purple_signal_connect(purple_blist_get_handle(), "buddy-signed-off", &blist_handle,PURPLE_CALLBACK(buddySignedOff), NULL);

// 		purple_signal_connect(purple_blist_get_handle(), "buddy-status-changed", &blist_handle,PURPLE_CALLBACK(buddyStatusChanged), NULL);

		purple_signal_connect(purple_blist_get_handle(), "blist-node-removed", &blist_handle,PURPLE_CALLBACK(NodeRemoved), NULL);

// 		purple_signal_connect(purple_conversations_get_handle(), "chat-topic-changed", &conversation_handle, PURPLE_CALLBACK(conv_chat_topic_changed), NULL);

		static int xfer_handle;

		purple_signal_connect(purple_xfers_get_handle(), "file-send-start", &xfer_handle, PURPLE_CALLBACK(fileSendStart), NULL);

		purple_signal_connect(purple_xfers_get_handle(), "file-recv-start", &xfer_handle, PURPLE_CALLBACK(fileRecvStart), NULL);

		purple_signal_connect(purple_xfers_get_handle(), "file-recv-request", &xfer_handle, PURPLE_CALLBACK(newXfer), NULL);

		purple_signal_connect(purple_xfers_get_handle(), "file-recv-complete", &xfer_handle, PURPLE_CALLBACK(XferReceiveComplete), NULL);

		purple_signal_connect(purple_xfers_get_handle(), "file-send-complete", &xfer_handle, PURPLE_CALLBACK(XferSendComplete), NULL);

// 

// 		purple_commands_init();

	}

	return ret;

}

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::cerr << "option parsing failed: " << error->message << "\n";

		return -1;

}

#endif

int create_socket(char *host, int portno) {

	struct sockaddr_in serv_addr;

	int main_socket = 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(main_socket, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {

		close(main_socket);

		main_socket = 0;

	}

	return main_socket;

}