-/*

- * Copyright (c) 2010 Remko Tronçon

- * Licensed under the GNU General Public License v3.

- * See Documentation/Licenses/GPLv3.txt for more information.

- */

-

-#include <Swiften/Avatars/AvatarFileStorage.h>

-

-#include <iostream>

-#include <boost/filesystem/fstream.hpp>

-#include <boost/filesystem.hpp>

-

-#include <Swiften/Base/foreach.h>

-#include <Swiften/Base/String.h>

-#include <Swiften/StringCodecs/SHA1.h>

-#include <Swiften/StringCodecs/Hexify.h>

-

-namespace Swift {

-

-AvatarFileStorage::AvatarFileStorage(const boost::filesystem::path& avatarsDir, const boost::filesystem::path& avatarsFile) : avatarsDir(avatarsDir), avatarsFile(avatarsFile) {

- if (boost::filesystem::exists(avatarsFile)) {

- try {

- boost::filesystem::ifstream file(avatarsFile);

- std::string line;

- if (file.is_open()) {

- while (!file.eof()) {

- getline(file, line);

- std::pair<std::string, std::string> r = String::getSplittedAtFirst(line, ' ');

- JID jid(r.second);

- if (jid.isValid()) {

- jidAvatars.insert(std::make_pair(jid, r.first));

- }

- else if (!r.first.empty() || !r.second.empty()) {

- std::cerr << "Invalid entry in avatars file: " << r.second << std::endl;

- }

- }

- }

- }

- catch (...) {

- std::cerr << "Error reading avatars file" << std::endl;

- }

- }

-}

-

-bool AvatarFileStorage::hasAvatar(const std::string& hash) const {

- return boost::filesystem::exists(getAvatarPath(hash));

-}

-

-void AvatarFileStorage::addAvatar(const std::string& hash, const ByteArray& avatar) {

- assert(Hexify::hexify(SHA1::getHash(avatar)) == hash);

-

- boost::filesystem::path avatarPath = getAvatarPath(hash);

- if (!boost::filesystem::exists(avatarPath.parent_path())) {

- try {

- boost::filesystem::create_directories(avatarPath.parent_path());

- }

- catch (const boost::filesystem::filesystem_error& e) {

- std::cerr << "ERROR: " << e.what() << std::endl;

- }

- }

- boost::filesystem::ofstream file(avatarPath, boost::filesystem::ofstream::binary|boost::filesystem::ofstream::out);

- file.write(reinterpret_cast<const char*>(avatar.getData()), static_cast<std::streamsize>(avatar.getSize()));

- file.close();

-}

-

-boost::filesystem::path AvatarFileStorage::getAvatarPath(const std::string& hash) const {

- return avatarsDir / hash;

-}

-

-ByteArray AvatarFileStorage::getAvatar(const std::string& hash) const {

- ByteArray data;

- data.readFromFile(getAvatarPath(hash).string());

- return data;

-}

-

-void AvatarFileStorage::setAvatarForJID(const JID& jid, const std::string& hash) {

- std::pair<JIDAvatarMap::iterator, bool> r = jidAvatars.insert(std::make_pair(jid, hash));

- if (r.second) {

- saveJIDAvatars();

- }

- else if (r.first->second != hash) {

- r.first->second = hash;

- saveJIDAvatars();

- }

-}

-

-std::string AvatarFileStorage::getAvatarForJID(const JID& jid) const {

- JIDAvatarMap::const_iterator i = jidAvatars.find(jid);

- return i == jidAvatars.end() ? "" : i->second;

-}

-

-void AvatarFileStorage::saveJIDAvatars() {

- try {

- boost::filesystem::ofstream file(avatarsFile);

- for (JIDAvatarMap::const_iterator i = jidAvatars.begin(); i != jidAvatars.end(); ++i) {

- file << i->second << " " << i->first.toString() << std::endl;

- }

- file.close();

- }

- catch (...) {

- std::cerr << "Error writing avatars file" << std::endl;

- }

-}

-

-}

-/*

- * Copyright (c) 2010 Remko Tronçon

- * Licensed under the GNU General Public License v3.

- * See Documentation/Licenses/GPLv3.txt for more information.

- */

-

-#pragma once

-

-#include <map>

-#include <string>

-#include <boost/filesystem/path.hpp>

-

-#include <Swiften/JID/JID.h>

-#include "Swiften/Base/ByteArray.h"

-#include "Swiften/Avatars/AvatarStorage.h"

-

-namespace Swift {

- class AvatarFileStorage : public AvatarStorage {

- public:

- AvatarFileStorage(const boost::filesystem::path& avatarsDir, const boost::filesystem::path& avatarsFile);

-

- virtual bool hasAvatar(const std::string& hash) const;

- virtual void addAvatar(const std::string& hash, const ByteArray& avatar);

- virtual ByteArray getAvatar(const std::string& hash) const;

-

- virtual boost::filesystem::path getAvatarPath(const std::string& hash) const;

-

- virtual void setAvatarForJID(const JID& jid, const std::string& hash);

- virtual std::string getAvatarForJID(const JID& jid) const;

-

- private:

- void saveJIDAvatars();

-

- private:

- boost::filesystem::path avatarsDir;

- boost::filesystem::path avatarsFile;

- typedef std::map<JID, std::string> JIDAvatarMap;

- JIDAvatarMap jidAvatars;

- };

-

-}

- "AvatarFileStorage.cpp",

-/*

- * Copyright (c) 2010 Remko Tronçon

- * Licensed under the GNU General Public License v3.

- * See Documentation/Licenses/GPLv3.txt for more information.

- */

-

-#include "Swiften/Client/FileStorages.h"

-#include "Swiften/VCards/VCardFileStorage.h"

-#include "Swiften/Avatars/AvatarFileStorage.h"

-#include "Swiften/Disco/CapsFileStorage.h"

-#include "Swiften/Roster/RosterFileStorage.h"

-

-namespace Swift {

-

-FileStorages::FileStorages(const boost::filesystem::path& baseDir, const JID& jid) {

- std::string profile = jid.toBare();

- vcardStorage = new VCardFileStorage(baseDir / profile / "vcards");

- capsStorage = new CapsFileStorage(baseDir / "caps");

- avatarStorage = new AvatarFileStorage(baseDir / "avatars", baseDir / profile / "avatars");

- rosterStorage = new RosterFileStorage(baseDir / profile / "roster.xml");

-}

-

-FileStorages::~FileStorages() {

- delete rosterStorage;

- delete avatarStorage;

- delete capsStorage;

- delete vcardStorage;

-}

-

-VCardStorage* FileStorages::getVCardStorage() const {

- return vcardStorage;

-}

-

-CapsStorage* FileStorages::getCapsStorage() const {

- return capsStorage;

-}

-

-AvatarStorage* FileStorages::getAvatarStorage() const {

- return avatarStorage;

-}

-

-RosterStorage* FileStorages::getRosterStorage() const {

- return rosterStorage;

-}

-

-}

-/*

- * Copyright (c) 2010 Remko Tronçon

- * Licensed under the GNU General Public License v3.

- * See Documentation/Licenses/GPLv3.txt for more information.

- */

-

-#pragma once

-

-#include <boost/filesystem/path.hpp>

-

-#include "Swiften/Client/Storages.h"

-

-namespace Swift {

- class VCardFileStorage;

- class AvatarFileStorage;

- class CapsFileStorage;

- class RosterFileStorage;

- class JID;

-

- /**

- * A storages implementation that stores all controller data on disk.

- */

- class FileStorages : public Storages {

- public:

- /**

- * Creates the storages interface.

- *

- * All data will be stored relative to a base directory, and

- * for some controllers, in a subdirectory for the given profile.

- * The data is stored in the following places:

- * - Avatars: <basedir>/avatars

- * - VCards: <basedir>/<profile>/vcards

- * - Entity capabilities: <basedir>/caps

- *

- * \param baseDir the base dir to store data relative to

- * \param jid the subdir in which profile-specific data will be stored.

- * The bare JID will be used as the subdir name.

- */

- FileStorages(const boost::filesystem::path& baseDir, const JID& jid);

- ~FileStorages();

-

- virtual VCardStorage* getVCardStorage() const;

- virtual AvatarStorage* getAvatarStorage() const;

- virtual CapsStorage* getCapsStorage() const;

- virtual RosterStorage* getRosterStorage() const;

-

- private:

- VCardFileStorage* vcardStorage;

- AvatarFileStorage* avatarStorage;

- CapsFileStorage* capsStorage;

- RosterFileStorage* rosterStorage;

- };

-}

-/*

- * Copyright (c) 2010 Remko Tronçon

- * Licensed under the GNU General Public License v3.

- * See Documentation/Licenses/GPLv3.txt for more information.

- */

-

-#include "Swiften/Disco/CapsFileStorage.h"

-

-#include <Swiften/Entity/GenericPayloadPersister.h>

-#include "Swiften/Serializer/PayloadSerializers/DiscoInfoSerializer.h"

-#include "Swiften/Parser/PayloadParsers/DiscoInfoParser.h"

-#include "Swiften/StringCodecs/Hexify.h"

-#include "Swiften/StringCodecs/Base64.h"

-

-using namespace Swift;

-

-typedef GenericPayloadPersister<DiscoInfo, DiscoInfoParser, DiscoInfoSerializer> DiscoInfoPersister;

-

-CapsFileStorage::CapsFileStorage(const boost::filesystem::path& path) : path(path) {

-}

-

-DiscoInfo::ref CapsFileStorage::getDiscoInfo(const std::string& hash) const {

- return DiscoInfoPersister().loadPayloadGeneric(getCapsPath(hash));

-}

-

-void CapsFileStorage::setDiscoInfo(const std::string& hash, DiscoInfo::ref discoInfo) {

- DiscoInfo::ref bareDiscoInfo(new DiscoInfo(*discoInfo.get()));

- bareDiscoInfo->setNode("");

- DiscoInfoPersister().savePayload(bareDiscoInfo, getCapsPath(hash));

-}

-

-boost::filesystem::path CapsFileStorage::getCapsPath(const std::string& hash) const {

- return path / (Hexify::hexify(Base64::decode(hash)) + ".xml");

-}

-/*

- * Copyright (c) 2010 Remko Tronçon

- * Licensed under the GNU General Public License v3.

- * See Documentation/Licenses/GPLv3.txt for more information.

- */

-

-#pragma once

-

-#include <boost/filesystem/path.hpp>

-

-#include "Swiften/Disco/CapsStorage.h"

-#include <string>

-

-namespace Swift {

- class CapsFileStorage : public CapsStorage {

- public:

- CapsFileStorage(const boost::filesystem::path& path);

-

- virtual DiscoInfo::ref getDiscoInfo(const std::string& hash) const;

- virtual void setDiscoInfo(const std::string& hash, DiscoInfo::ref discoInfo);

-

- private:

- boost::filesystem::path getCapsPath(const std::string& hash) const;

-

- private:

- boost::filesystem::path path;

- };

-}

- "CapsFileStorage.cpp",

-/*

- * Copyright (c) 2011 Remko Tronçon

- * Licensed under the GNU General Public License v3.

- * See Documentation/Licenses/GPLv3.txt for more information.

- */

-

-#include <Swiften/Roster/RosterFileStorage.h>

-

-#include <Swiften/Entity/GenericPayloadPersister.h>

-#include <Swiften/Serializer/PayloadSerializers/RosterSerializer.h>

-#include <Swiften/Parser/PayloadParsers/RosterParser.h>

-

-using namespace Swift;

-

-typedef GenericPayloadPersister<RosterPayload, RosterParser, RosterSerializer> RosterPersister;

-

-RosterFileStorage::RosterFileStorage(const boost::filesystem::path& path) : path(path) {

-}

-

-boost::shared_ptr<RosterPayload> RosterFileStorage::getRoster() const {

- return RosterPersister().loadPayloadGeneric(path);

-}

-

-void RosterFileStorage::setRoster(boost::shared_ptr<RosterPayload> roster) {

- RosterPersister().savePayload(roster, path);

-}

-/*

- * Copyright (c) 2011 Remko Tronçon

- * Licensed under the GNU General Public License v3.

- * See Documentation/Licenses/GPLv3.txt for more information.

- */

-

-#pragma once

-

-#include <boost/filesystem/path.hpp>

-

-#include <Swiften/Roster/RosterStorage.h>

-

-namespace Swift {

- class RosterFileStorage : public RosterStorage {

- public:

- RosterFileStorage(const boost::filesystem::path& path);

-

- virtual boost::shared_ptr<RosterPayload> getRoster() const;

- virtual void setRoster(boost::shared_ptr<RosterPayload>);

-

- private:

- boost::filesystem::path path;

- };

-}

- "Client/FileStorages.cpp",

- "Roster/RosterFileStorage.cpp",

- "VCardFileStorage.cpp",

-/*

- * Copyright (c) 2010 Remko Tronçon

- * Licensed under the GNU General Public License v3.

- * See Documentation/Licenses/GPLv3.txt for more information.

- */

-

-#include "Swiften/VCards/VCardFileStorage.h"

-

-#include <boost/filesystem/fstream.hpp>

-#include <boost/filesystem.hpp>

-#include <iostream>

-

-#include <Swiften/Entity/GenericPayloadPersister.h>

-#include <Swiften/Base/String.h>

-#include <Swiften/StringCodecs/Hexify.h>

-#include <Swiften/StringCodecs/SHA1.h>

-#include <Swiften/Base/foreach.h>

-#include "Swiften/JID/JID.h"

-#include "Swiften/Elements/VCard.h"

-#include "Swiften/Serializer/PayloadSerializers/VCardSerializer.h"

-#include "Swiften/Parser/PayloadParsers/UnitTest/PayloadParserTester.h"

-#include "Swiften/Parser/PayloadParsers/VCardParser.h"

-

-using namespace Swift;

-

-typedef GenericPayloadPersister<VCard, VCardParser, VCardSerializer> VCardPersister;

-

-VCardFileStorage::VCardFileStorage(boost::filesystem::path dir) : vcardsPath(dir) {

- cacheFile = vcardsPath / "phashes";

- if (boost::filesystem::exists(cacheFile)) {

- try {

- boost::filesystem::ifstream file(cacheFile);

- std::string line;

- if (file.is_open()) {

- while (!file.eof()) {

- getline(file, line);

- std::pair<std::string, std::string> r = String::getSplittedAtFirst(line, ' ');

- JID jid(r.second);

- if (jid.isValid()) {

- photoHashes.insert(std::make_pair(jid, r.first));

- }

- else if (!r.first.empty() || !r.second.empty()) {

- std::cerr << "Invalid entry in phashes file" << std::endl;

- }

- }

- }

- }

- catch (...) {

- std::cerr << "Error reading phashes file" << std::endl;

- }

- }

-}

-

-boost::shared_ptr<VCard> VCardFileStorage::getVCard(const JID& jid) const {

- return VCardPersister().loadPayloadGeneric(getVCardPath(jid));

-}

-

-void VCardFileStorage::setVCard(const JID& jid, VCard::ref v) {

- VCardPersister().savePayload(v, getVCardPath(jid));

- getAndUpdatePhotoHash(jid, v);

-}

-

-boost::filesystem::path VCardFileStorage::getVCardPath(const JID& jid) const {

- std::string file(jid.toString());

- String::replaceAll(file, '/', "%2f");

- return boost::filesystem::path(vcardsPath / (file + ".xml"));

-}

-

-std::string VCardFileStorage::getPhotoHash(const JID& jid) const {

- PhotoHashMap::const_iterator i = photoHashes.find(jid);

- if (i != photoHashes.end()) {

- return i->second;

- }

- else {

- VCard::ref vCard = getVCard(jid);

- return getAndUpdatePhotoHash(jid, vCard);

- }

-}

-

-std::string VCardFileStorage::getAndUpdatePhotoHash(const JID& jid, VCard::ref vCard) const {

- std::string hash;

- if (vCard && !vCard->getPhoto().isEmpty()) {

- hash = Hexify::hexify(SHA1::getHash(vCard->getPhoto()));

- }

- std::pair<PhotoHashMap::iterator, bool> r = photoHashes.insert(std::make_pair(jid, hash));

- if (r.second) {

- savePhotoHashes();

- }

- else if (r.first->second != hash) {

- r.first->second = hash;

- savePhotoHashes();

- }

- return hash;

-}

-

-void VCardFileStorage::savePhotoHashes() const {

- try {

- boost::filesystem::ofstream file(cacheFile);

- for (PhotoHashMap::const_iterator i = photoHashes.begin(); i != photoHashes.end(); ++i) {

- file << i->second << " " << i->first.toString() << std::endl;

- }

- file.close();

- }

- catch (...) {

- std::cerr << "Error writing vcards file" << std::endl;

- }

-}

-/*

- * Copyright (c) 2010 Remko Tronçon

- * Licensed under the GNU General Public License v3.

- * See Documentation/Licenses/GPLv3.txt for more information.

- */

-

-#pragma once

-

-#include <boost/shared_ptr.hpp>

-#include <boost/filesystem/path.hpp>

-#include <string>

-#include <map>

-

-#include "Swiften/VCards/VCardStorage.h"

-

-namespace Swift {

- class VCardFileStorage : public VCardStorage {

- public:

- VCardFileStorage(boost::filesystem::path dir);

-

- virtual VCard::ref getVCard(const JID& jid) const;

- virtual void setVCard(const JID& jid, VCard::ref v);

-

- virtual std::string getPhotoHash(const JID&) const;

-

- private:

- boost::filesystem::path getVCardPath(const JID&) const;

-

- std::string getAndUpdatePhotoHash(const JID& jid, VCard::ref vcard) const;

- void savePhotoHashes() const;

-

- private:

- boost::filesystem::path vcardsPath;

- boost::filesystem::path cacheFile;

- typedef std::map<JID, std::string> PhotoHashMap;

- mutable PhotoHashMap photoHashes;

- };

-}