1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
/*
* 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/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/Base/ByteArray.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"
namespace Swift {
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 {
boost::filesystem::path vcardPath(getVCardPath(jid));
if (boost::filesystem::exists(vcardPath)) {
ByteArray data;
data.readFromFile(vcardPath.string());
VCardParser parser;
PayloadParserTester tester(&parser);
tester.parse(data.toString());
return boost::dynamic_pointer_cast<VCard>(parser.getPayload());
}
else {
return boost::shared_ptr<VCard>();
}
}
void VCardFileStorage::setVCard(const JID& jid, VCard::ref v) {
boost::filesystem::path vcardPath(getVCardPath(jid));
if (!boost::filesystem::exists(vcardPath.parent_path())) {
try {
boost::filesystem::create_directories(vcardPath.parent_path());
}
catch (const boost::filesystem::filesystem_error& e) {
std::cerr << "ERROR: " << e.what() << std::endl;
}
}
boost::filesystem::ofstream file(getVCardPath(jid));
file << VCardSerializer().serializePayload(v);
file.close();
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;
}
}
}
|
Swift