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

+ assert(Hexify::hexify(crypto->getSHA1Hash(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*>(vecptr(avatar)), static_cast<std::streamsize>(avatar.size()));

+ file.close();

+ return avatarsDir / hash;

+ ByteArray data;

+ readByteArrayFromFile(data, getAvatarPath(hash));

+ return data;

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

+ }

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

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

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

+ }

+ class CryptoProvider;

+ class AvatarFileStorage : public AvatarStorage {

+ public:

+ AvatarFileStorage(const boost::filesystem::path& avatarsDir, const boost::filesystem::path& avatarsFile, CryptoProvider* crypto);

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

+ CryptoProvider* crypto;

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

+ JIDAvatarMap jidAvatars;

+ };

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

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

+ bareDiscoInfo->setNode("");

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

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

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

+ };

+ boost::filesystem::path certificatePath = getCertificatePath(certificate);

+ if (boost::filesystem::exists(certificatePath)) {

+ ByteArray data;

+ readByteArrayFromFile(data, certificatePath);

+ Certificate::ref storedCertificate(certificateFactory->createCertificateFromDER(data));

+ if (storedCertificate && storedCertificate->toDER() == certificate->toDER()) {

+ return true;

+ }

+ else {

+ SWIFT_LOG(warning) << "Stored certificate does not match received certificate" << std::endl;

+ return false;

+ }

+ }

+ else {

+ return false;

+ }

+ boost::filesystem::path certificatePath = getCertificatePath(certificate);

+ if (!boost::filesystem::exists(certificatePath.parent_path())) {

+ try {

+ boost::filesystem::create_directories(certificatePath.parent_path());

+ }

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

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

+ }

+ }

+ boost::filesystem::ofstream file(certificatePath, boost::filesystem::ofstream::binary|boost::filesystem::ofstream::out);

+ ByteArray data = certificate->toDER();

+ file.write(reinterpret_cast<const char*>(vecptr(data)), boost::numeric_cast<std::streamsize>(data.size()));

+ file.close();

+ return path / Hexify::hexify(crypto->getSHA1Hash(certificate->toDER()));

+ class CertificateFactory;

+ class CryptoProvider;

+ class CertificateFileStorage : public CertificateStorage {

+ public:

+ CertificateFileStorage(const boost::filesystem::path& path, CertificateFactory* certificateFactory, CryptoProvider* crypto);

+ virtual bool hasCertificate(Certificate::ref certificate) const;

+ virtual void addCertificate(Certificate::ref certificate);

+ private:

+ boost::filesystem::path getCertificatePath(Certificate::ref certificate) const;

+ private:

+ boost::filesystem::path path;

+ CertificateFactory* certificateFactory;

+ CryptoProvider* crypto;

+ };

+ class CertificateFactory;

+ class CryptoProvider;

+ class CertificateFileStorageFactory : public CertificateStorageFactory {

+ public:

+ CertificateFileStorageFactory(const boost::filesystem::path& basePath, CertificateFactory* certificateFactory, CryptoProvider* crypto) : basePath(basePath), certificateFactory(certificateFactory), crypto(crypto) {}

+ virtual CertificateStorage* createCertificateStorage(const JID& profile) const {

+ boost::filesystem::path profilePath = basePath / profile.toString();

+ return new CertificateFileStorage(profilePath / "certificates", certificateFactory, crypto);

+ }

+ private:

+ boost::filesystem::path basePath;

+ CertificateFactory* certificateFactory;

+ CryptoProvider* crypto;

+ };

+ foreach(Certificate::ref storedCert, certificates) {

+ if (storedCert->toDER() == certificate->toDER()) {

+ return true;

+ }

+ }

+ return false;

+ certificates.push_back(certificate);

+ class CertificateMemoryStorage : public CertificateStorage {

+ public:

+ CertificateMemoryStorage();

+ virtual bool hasCertificate(Certificate::ref certificate) const;

+ virtual void addCertificate(Certificate::ref certificate);

+ private:

+ std::vector<Certificate::ref> certificates;

+ };

+ class CertificateStorage {

+ public:

+ virtual ~CertificateStorage();

+ virtual bool hasCertificate(Certificate::ref certificate) const = 0;

+ virtual void addCertificate(Certificate::ref certificate) = 0;

+ };

+ class CertificateStorage;

+ class JID;

+ class CertificateStorageFactory {

+ public:

+ virtual ~CertificateStorageFactory();

+ virtual CertificateStorage* createCertificateStorage(const JID& profile) const = 0;

+ };

+ /**

+ * A certificate trust checker that trusts certificates in a certificate storage.

+ */

+ class CertificateStorageTrustChecker : public CertificateTrustChecker {

+ public:

+ CertificateStorageTrustChecker(CertificateStorage* storage) : storage(storage) {

+ }

+ virtual bool isCertificateTrusted(const std::vector<Certificate::ref>& certificateChain) {

+ lastCertificateChain = std::vector<Certificate::ref>(certificateChain.begin(), certificateChain.end());

+ return certificateChain.empty() ? false : storage->hasCertificate(certificateChain[0]);

+ }

+ const std::vector<Certificate::ref>& getLastCertificateChain() const {

+ return lastCertificateChain;

+ }

+ private:

+ CertificateStorage* storage;

+ std::vector<Certificate::ref> lastCertificateChain;

+ };

+ boost::filesystem::path profile = stringToPath(jid.toBare());

+ vcardStorage = new VCardFileStorage(baseDir / profile / "vcards", crypto);

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

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

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

+ historyStorage = new SQLiteHistoryStorage(baseDir / "history.db");

+ historyStorage = NULL;

+ delete rosterStorage;

+ delete avatarStorage;

+ delete capsStorage;

+ delete vcardStorage;

+ delete historyStorage;

+ return vcardStorage;

+ return capsStorage;

+ return avatarStorage;

+ return rosterStorage;

+ return historyStorage;

+ return NULL;

+ class VCardFileStorage;

+ class AvatarFileStorage;

+ class CapsFileStorage;

+ class RosterFileStorage;

+ class HistoryStorage;

+ class JID;

+ class CryptoProvider;

+ /**

+ * 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, CryptoProvider*);

+ ~FileStorages();

+ virtual VCardStorage* getVCardStorage() const;

+ virtual AvatarStorage* getAvatarStorage() const;

+ virtual CapsStorage* getCapsStorage() const;

+ virtual RosterStorage* getRosterStorage() const;

+ virtual HistoryStorage* getHistoryStorage() const;

+ private:

+ VCardFileStorage* vcardStorage;

+ AvatarFileStorage* avatarStorage;

+ CapsFileStorage* capsStorage;

+ RosterFileStorage* rosterStorage;

+ HistoryStorage* historyStorage;

+ };

+ class CryptoProvider;

+ class FileStoragesFactory : public StoragesFactory {

+ public:

+ FileStoragesFactory(const boost::filesystem::path& basePath, CryptoProvider* crypto) : basePath(basePath), crypto(crypto) {}

+ virtual Storages* createStorages(const JID& profile) const {

+ return new FileStorages(basePath, profile, crypto);

+ }

+ private:

+ boost::filesystem::path basePath;

+ CryptoProvider* crypto;

+ };

+ class JID;

+ class CryptoProvider;

+ class MemoryStoragesFactory : public StoragesFactory {

+ public:

+ MemoryStoragesFactory(CryptoProvider* cryptoProvider) : cryptoProvider_(cryptoProvider) {}

+ virtual Storages* createStorages(const JID& /*profile*/) const {

+ return new MemoryStorages(cryptoProvider_);

+ }

+ private:

+ CryptoProvider* cryptoProvider_;

+ };

+ return RosterPersister().loadPayloadGeneric(path);

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

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

+ };

+ class Storages;

+ class JID;

+ class StoragesFactory {

+ public:

+ virtual ~StoragesFactory() {}

+ virtual Storages* createStorages(const JID& profile) const = 0;

+ };

+ 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> result = VCardPersister().loadPayloadGeneric(getVCardPath(jid));

+ getAndUpdatePhotoHash(jid, result);

+ return result;

+ if (vcardWriteTimes.find(jid) == vcardWriteTimes.end()) {

+ return boost::posix_time::ptime();

+ }

+ else {

+ return vcardWriteTimes.at(jid);

+ }

+ vcardWriteTimes[jid] = boost::posix_time::second_clock::universal_time();

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

+ getAndUpdatePhotoHash(jid, v);

+ try {

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

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

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

+ }

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

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

+ return boost::filesystem::path();

+ }

+ 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 hash;

+ if (vCard && !vCard->getPhoto().empty()) {

+ hash = Hexify::hexify(crypto->getSHA1Hash(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;

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

+ }

+ class CryptoProvider;

+ class VCardFileStorage : public VCardStorage {

+ public:

+ VCardFileStorage(boost::filesystem::path dir, CryptoProvider* crypto);

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

+ virtual boost::posix_time::ptime getVCardWriteTime(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;

+ CryptoProvider* crypto;

+ boost::filesystem::path cacheFile;

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

+ mutable PhotoHashMap photoHashes;

+ std::map<JID, boost::posix_time::ptime> vcardWriteTimes;

+ };