summaryrefslogtreecommitdiffabout
authorulf69 <ulf69>2004-10-06 00:35:59 (UTC)
committer ulf69 <ulf69>2004-10-06 00:35:59 (UTC)
commit904cbf4f2a418d3cadc74a6168a4565ae6ebc3c5 (patch) (unidiff)
tree22bb491b5886234a0ed21b882df73732ea99bf84
parent07fa092b413b7cde1bd4fc797ce0b30adcb8668d (diff)
downloadkdepimpi-904cbf4f2a418d3cadc74a6168a4565ae6ebc3c5.zip
kdepimpi-904cbf4f2a418d3cadc74a6168a4565ae6ebc3c5.tar.gz
kdepimpi-904cbf4f2a418d3cadc74a6168a4565ae6ebc3c5.tar.bz2
*** empty log message ***
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--pwmanager/pwmanager/pwmanagerE.pro2
-rw-r--r--pwmanager/pwmanager/pwmdoc.cpp568
-rw-r--r--pwmanager/pwmanager/pwmdoc.h70
-rw-r--r--pwmanager/pwmanager/pwmdocui.cpp2
-rw-r--r--pwmanager/pwmanager/pwmexception.h1
-rw-r--r--pwmanager/pwmanager/pwmview.cpp64
-rw-r--r--pwmanager/pwmanager/pwmview.h22
-rw-r--r--pwmanager/pwmanager/serializer.cpp109
-rw-r--r--pwmanager/pwmanager/serializer.h17
9 files changed, 746 insertions, 109 deletions
diff --git a/pwmanager/pwmanager/pwmanagerE.pro b/pwmanager/pwmanager/pwmanagerE.pro
index 2558aca..95f5bf3 100644
--- a/pwmanager/pwmanager/pwmanagerE.pro
+++ b/pwmanager/pwmanager/pwmanagerE.pro
@@ -1,34 +1,34 @@
1 TEMPLATE= app 1 TEMPLATE= app
2 CONFIG += qt warn_on 2 CONFIG += qt warn_on
3 3
4 4
5 TARGET = pwmpi 5 TARGET = pwmpi
6OBJECTS_DIR = obj/$(PLATFORM) 6OBJECTS_DIR = obj/$(PLATFORM)
7MOC_DIR = moc/$(PLATFORM) 7MOC_DIR = moc/$(PLATFORM)
8DESTDIR=$(QPEDIR)/bin 8DESTDIR=$(QPEDIR)/bin
9 9
10INCLUDEPATH += . ../../qtcompat ../../qtcompat/xml ../../libkdepim ../../microkde ../../microkde/kdecore ../../microkde/kdeui ../../microkde/kutils $(QPEDIR)/include 10INCLUDEPATH += . ../../ ../../qtcompat ../../qtcompat/xml ../../libkdepim ../../microkde ../../microkde/kdecore ../../microkde/kdeui ../../microkde/kutils $(QPEDIR)/include
11DEFINES += PWM_EMBEDDED 11DEFINES += PWM_EMBEDDED
12#enable this setting if you want debugoutput for pwmanager 12#enable this setting if you want debugoutput for pwmanager
13#DEFINES += CONFIG_DEBUG 13#DEFINES += CONFIG_DEBUG
14 14
15LIBS += -lmicrokde 15LIBS += -lmicrokde
16LIBS += -lmicroqtcompat 16LIBS += -lmicroqtcompat
17LIBS += -lmicrokdepim 17LIBS += -lmicrokdepim
18LIBS += -L$(QPEDIR)/lib 18LIBS += -L$(QPEDIR)/lib
19LIBS += -lqpe 19LIBS += -lqpe
20LIBS += -lbz2 20LIBS += -lbz2
21LIBS += $(QTOPIALIB) 21LIBS += $(QTOPIALIB)
22 22
23#INTERFACES = \ 23#INTERFACES = \
24#addentrywnd.ui \ 24#addentrywnd.ui \
25#configwnd.ui \ 25#configwnd.ui \
26#findwnd.ui \ 26#findwnd.ui \
27#getmasterpwwnd.ui \ 27#getmasterpwwnd.ui \
28#pwgenwnd.ui \ 28#pwgenwnd.ui \
29#setmasterpwwnd.ui \ 29#setmasterpwwnd.ui \
30#subtbledit.ui 30#subtbledit.ui
31 31
32#INTERFACES = \ 32#INTERFACES = \
33#subtbledit.ui \ 33#subtbledit.ui \
34 34
diff --git a/pwmanager/pwmanager/pwmdoc.cpp b/pwmanager/pwmanager/pwmdoc.cpp
index 82fc746..4e8a603 100644
--- a/pwmanager/pwmanager/pwmdoc.cpp
+++ b/pwmanager/pwmanager/pwmdoc.cpp
@@ -14,48 +14,52 @@
14 * This file is originaly based on version 2.0 of pwmanager 14 * This file is originaly based on version 2.0 of pwmanager
15 * and was modified to run on embedded devices that run microkde 15 * and was modified to run on embedded devices that run microkde
16 * 16 *
17 * $Id$ 17 * $Id$
18 **************************************************************************/ 18 **************************************************************************/
19 19
20#include "pwmdoc.h" 20#include "pwmdoc.h"
21#include "pwmview.h" 21#include "pwmview.h"
22#include "blowfish.h" 22#include "blowfish.h"
23#include "sha1.h" 23#include "sha1.h"
24#include "globalstuff.h" 24#include "globalstuff.h"
25#include "gpasmanfile.h" 25#include "gpasmanfile.h"
26#include "serializer.h" 26#include "serializer.h"
27#include "compressgzip.h" 27#include "compressgzip.h"
28#include "compressbzip2.h" 28#include "compressbzip2.h"
29#include "randomizer.h" 29#include "randomizer.h"
30#include "pwminit.h" 30#include "pwminit.h"
31#ifndef PWM_EMBEDDED 31#ifndef PWM_EMBEDDED
32//US #include "libgryptif.h" 32//US #include "libgryptif.h"
33#else 33#else
34#include "pwmprefs.h" 34#include "pwmprefs.h"
35#include "kglobal.h" 35#include "kglobal.h"
36#endif 36#endif
37 37
38#include <kmessagebox.h>
39#include <libkcal/syncdefines.h>
40
41
38#ifdef CONFIG_KWALLETIF 42#ifdef CONFIG_KWALLETIF
39# include "kwalletemu.h" 43# include "kwalletemu.h"
40#endif // CONFIG_KWALLETIF 44#endif // CONFIG_KWALLETIF
41 45
42#include <qdatetime.h> 46#include <qdatetime.h>
43#include <qsize.h> 47#include <qsize.h>
44#include <qfileinfo.h> 48#include <qfileinfo.h>
45#include <qfile.h> 49#include <qfile.h>
46 50
47#include <stdio.h> 51#include <stdio.h>
48#include <stdlib.h> 52#include <stdlib.h>
49#include <errno.h> 53#include <errno.h>
50#include <string.h> 54#include <string.h>
51//US#include <iostream> 55//US#include <iostream>
52#include <algorithm> 56#include <algorithm>
53#include <sys/types.h> 57#include <sys/types.h>
54#include <sys/stat.h> 58#include <sys/stat.h>
55#include <unistd.h> 59#include <unistd.h>
56#include <stdint.h> 60#include <stdint.h>
57 61
58//TODO: reset to its normal value. 62//TODO: reset to its normal value.
59 #define META_CHECK_TIMER_INTERVAL10/*300*/ /* sek */ 63 #define META_CHECK_TIMER_INTERVAL10/*300*/ /* sek */
60 64
61using namespace std; 65using namespace std;
@@ -986,271 +990,271 @@ PwMerror PwMDoc::addEntry(const QString &category, PwMDataItem *d,
986 return e_maxAllowedEntr; 990 return e_maxAllowedEntr;
987 991
988 vector<unsigned int> foundPositions; 992 vector<unsigned int> foundPositions;
989 /* historically this was: 993 /* historically this was:
990 *const int searchIn = SEARCH_IN_DESC | SEARCH_IN_NAME | 994 *const int searchIn = SEARCH_IN_DESC | SEARCH_IN_NAME |
991 * SEARCH_IN_URL | SEARCH_IN_LAUNCHER; 995 * SEARCH_IN_URL | SEARCH_IN_LAUNCHER;
992 * But for now we only search in desc. 996 * But for now we only search in desc.
993 * That's a tweak to be KWallet compatible. But it should not add 997 * That's a tweak to be KWallet compatible. But it should not add
994 * usability-drop onto PwManager, does it? 998 * usability-drop onto PwManager, does it?
995 * (And yes, "int" was a bug. Correct is "unsigned int") 999 * (And yes, "int" was a bug. Correct is "unsigned int")
996 */ 1000 */
997 const unsigned int searchIn = SEARCH_IN_DESC; 1001 const unsigned int searchIn = SEARCH_IN_DESC;
998 findEntry(cat, *d, searchIn, &foundPositions, true); 1002 findEntry(cat, *d, searchIn, &foundPositions, true);
999 if (foundPositions.size()) { 1003 if (foundPositions.size()) {
1000 // DOH! We found this entry. 1004 // DOH! We found this entry.
1001 return e_entryExists; 1005 return e_entryExists;
1002 } 1006 }
1003 1007
1004 d->listViewPos = -1; 1008 d->listViewPos = -1;
1005 d->lockStat = conf()->confGlobNewEntrLockStat(); 1009 d->lockStat = conf()->confGlobNewEntrLockStat();
1006 if (updateMeta) { 1010 if (updateMeta) {
1007 d->meta.create = QDateTime::currentDateTime(); 1011 d->meta.create = QDateTime::currentDateTime();
1008 d->meta.update = d->meta.create; 1012 d->meta.update = d->meta.create;
1009 } 1013 }
1010 dta[cat].d.push_back(*d); 1014 dti.dta[cat].d.push_back(*d);
1011 1015
1012 delAllEmptyCat(true); 1016 delAllEmptyCat(true);
1013 1017
1014 if (!dontFlagDirty) 1018 if (!dontFlagDirty)
1015 flagDirty(); 1019 flagDirty();
1016 return e_success; 1020 return e_success;
1017} 1021}
1018 1022
1019PwMerror PwMDoc::addCategory(const QString &category, unsigned int *categoryIndex, 1023PwMerror PwMDoc::addCategory(const QString &category, unsigned int *categoryIndex,
1020 bool checkIfExist) 1024 bool checkIfExist)
1021{ 1025{
1022 if (isDeepLocked()) { 1026 if (isDeepLocked()) {
1023 PwMerror ret; 1027 PwMerror ret;
1024 ret = deepLock(false); 1028 ret = deepLock(false);
1025 if (ret != e_success) 1029 if (ret != e_success)
1026 return e_lock; 1030 return e_lock;
1027 } 1031 }
1028 if (checkIfExist) { 1032 if (checkIfExist) {
1029 if (findCategory(category, categoryIndex)) 1033 if (findCategory(category, categoryIndex))
1030 return e_categoryExists; 1034 return e_categoryExists;
1031 } 1035 }
1032 PwMCategoryItem item; 1036 PwMCategoryItem item;
1033 item.name = category.latin1(); 1037 item.name = category.latin1();
1034 dta.push_back(item); 1038 dti.dta.push_back(item);
1035 if (categoryIndex) 1039 if (categoryIndex)
1036 *categoryIndex = dta.size() - 1; 1040 *categoryIndex = dti.dta.size() - 1;
1037 return e_success; 1041 return e_success;
1038} 1042}
1039 1043
1040bool PwMDoc::delEntry(const QString &category, unsigned int index, bool dontFlagDirty) 1044bool PwMDoc::delEntry(const QString &category, unsigned int index, bool dontFlagDirty)
1041{ 1045{
1042 unsigned int cat = 0; 1046 unsigned int cat = 0;
1043 1047
1044 if (!findCategory(category, &cat)) { 1048 if (!findCategory(category, &cat)) {
1045 BUG(); 1049 BUG();
1046 return false; 1050 return false;
1047 } 1051 }
1048 1052
1049 return delEntry(cat, index, dontFlagDirty); 1053 return delEntry(cat, index, dontFlagDirty);
1050} 1054}
1051 1055
1052bool PwMDoc::delEntry(unsigned int category, unsigned int index, bool dontFlagDirty) 1056bool PwMDoc::delEntry(unsigned int category, unsigned int index, bool dontFlagDirty)
1053{ 1057{
1054 if (isDeepLocked()) 1058 if (isDeepLocked())
1055 return false; 1059 return false;
1056 if (index > dta[category].d.size() - 1) 1060 if (index > dti.dta[category].d.size() - 1)
1057 return false; 1061 return false;
1058 getDataChangedLock(); 1062 getDataChangedLock();
1059 if (!lockAt(category, index, false)) { 1063 if (!lockAt(category, index, false)) {
1060 putDataChangedLock(); 1064 putDataChangedLock();
1061 return false; 1065 return false;
1062 } 1066 }
1063 putDataChangedLock(); 1067 putDataChangedLock();
1064 int lvPos = dta[category].d[index].listViewPos; 1068 int lvPos = dti.dta[category].d[index].listViewPos;
1065 1069
1066 // delete entry 1070 // delete entry
1067 dta[category].d.erase(dta[category].d.begin() + index); 1071 dti.dta[category].d.erase(dti.dta[category].d.begin() + index);
1068 1072
1069 unsigned int i, entries = numEntries(category); 1073 unsigned int i, entries = numEntries(category);
1070 if (!entries) { 1074 if (!entries) {
1071 // no more entries in this category, so 1075 // no more entries in this category, so
1072 // we can delete it, too. 1076 // we can delete it, too.
1073 BUG_ON(!delCategory(category)); 1077 BUG_ON(!delCategory(category));
1074 // delCategory() flags it dirty, so we need not to do so. 1078 // delCategory() flags it dirty, so we need not to do so.
1075 return true; 1079 return true;
1076 } 1080 }
1077 for (i = 0; i < entries; ++i) { 1081 for (i = 0; i < entries; ++i) {
1078 // decrement all listViewPositions that are greater than the deleted. 1082 // decrement all listViewPositions that are greater than the deleted.
1079 if (dta[category].d[i].listViewPos > lvPos) 1083 if (dti.dta[category].d[i].listViewPos > lvPos)
1080 --dta[category].d[i].listViewPos; 1084 --dti.dta[category].d[i].listViewPos;
1081 } 1085 }
1082 1086
1083 if (!dontFlagDirty) 1087 if (!dontFlagDirty)
1084 flagDirty(); 1088 flagDirty();
1085 return true; 1089 return true;
1086} 1090}
1087 1091
1088bool PwMDoc::editEntry(const QString &oldCategory, const QString &newCategory, 1092bool PwMDoc::editEntry(const QString &oldCategory, const QString &newCategory,
1089 unsigned int index, PwMDataItem *d, bool updateMeta) 1093 unsigned int index, PwMDataItem *d, bool updateMeta)
1090{ 1094{
1091 PWM_ASSERT(d); 1095 PWM_ASSERT(d);
1092 unsigned int oldCat = 0; 1096 unsigned int oldCat = 0;
1093 1097
1094 if (!findCategory(oldCategory, &oldCat)) { 1098 if (!findCategory(oldCategory, &oldCat)) {
1095 BUG(); 1099 BUG();
1096 return false; 1100 return false;
1097 } 1101 }
1098 1102
1099 return editEntry(oldCat, newCategory, index, d, updateMeta); 1103 return editEntry(oldCat, newCategory, index, d, updateMeta);
1100} 1104}
1101 1105
1102bool PwMDoc::editEntry(unsigned int oldCategory, const QString &newCategory, 1106bool PwMDoc::editEntry(unsigned int oldCategory, const QString &newCategory,
1103 unsigned int index, PwMDataItem *d, bool updateMeta) 1107 unsigned int index, PwMDataItem *d, bool updateMeta)
1104{ 1108{
1105 if (isDeepLocked()) 1109 if (isDeepLocked())
1106 return false; 1110 return false;
1107 if (updateMeta) { 1111 if (updateMeta) {
1108 d->meta.update = QDateTime::currentDateTime(); 1112 d->meta.update = QDateTime::currentDateTime();
1109 if (d->meta.create.isNull()) { 1113 if (d->meta.create.isNull()) {
1110 d->meta.create = d->meta.update; 1114 d->meta.create = d->meta.update;
1111 } 1115 }
1112 } 1116 }
1113 if (dta[oldCategory].name != newCategory.latin1()) { 1117 if (dti.dta[oldCategory].name != newCategory.latin1()) {
1114 // the user changed the category. 1118 // the user changed the category.
1115 PwMerror ret; 1119 PwMerror ret;
1116 d->rev = 0; 1120 d->rev = 0;
1117 ret = addEntry(newCategory, d, true, false); 1121 ret = addEntry(newCategory, d, true, false);
1118 if (ret != e_success) 1122 if (ret != e_success)
1119 return false; 1123 return false;
1120 if (!delEntry(oldCategory, index, true)) 1124 if (!delEntry(oldCategory, index, true))
1121 return false; 1125 return false;
1122 } else { 1126 } else {
1123 d->rev = dta[oldCategory].d[index].rev + 1; // increment revision counter. 1127 d->rev = dti.dta[oldCategory].d[index].rev + 1; // increment revision counter.
1124 dta[oldCategory].d[index] = *d; 1128 dti.dta[oldCategory].d[index] = *d;
1125 } 1129 }
1126 flagDirty(); 1130 flagDirty();
1127 return true; 1131 return true;
1128} 1132}
1129 1133
1130unsigned int PwMDoc::numEntries(const QString &category) 1134unsigned int PwMDoc::numEntries(const QString &category)
1131{ 1135{
1132 unsigned int cat = 0; 1136 unsigned int cat = 0;
1133 1137
1134 if (!findCategory(category, &cat)) { 1138 if (!findCategory(category, &cat)) {
1135 BUG(); 1139 BUG();
1136 return 0; 1140 return 0;
1137 } 1141 }
1138 1142
1139 return numEntries(cat); 1143 return numEntries(cat);
1140} 1144}
1141 1145
1142bool PwMDoc::serializeDta(string *d) 1146bool PwMDoc::serializeDta(string *d)
1143{ 1147{
1144 PWM_ASSERT(d); 1148 PWM_ASSERT(d);
1145 Serializer ser; 1149 Serializer ser;
1146 if (!ser.serialize(dta)) 1150 if (!ser.serialize(dti))
1147 return false; 1151 return false;
1148 d->assign(ser.getXml()); 1152 d->assign(ser.getXml());
1149 if (!d->size()) 1153 if (!d->size())
1150 return false; 1154 return false;
1151 return true; 1155 return true;
1152} 1156}
1153 1157
1154bool PwMDoc::deSerializeDta(const string *d, bool entriesLocked) 1158bool PwMDoc::deSerializeDta(const string *d, bool entriesLocked)
1155{ 1159{
1156 PWM_ASSERT(d); 1160 PWM_ASSERT(d);
1157#ifndef PWM_EMBEDDED 1161#ifndef PWM_EMBEDDED
1158 try { 1162 try {
1159 1163
1160 Serializer ser(d->c_str()); 1164 Serializer ser(d->c_str());
1161 ser.setDefaultLockStat(entriesLocked); 1165 ser.setDefaultLockStat(entriesLocked);
1162 if (!ser.deSerialize(&dta)) 1166 if (!ser.deSerialize(&dti))
1163 return false; 1167 return false;
1164 } catch (PwMException) { 1168 } catch (PwMException) {
1165 return false; 1169 return false;
1166 } 1170 }
1167#else 1171#else
1168 Serializer ser(d->c_str()); 1172 Serializer ser(d->c_str());
1169 ser.setDefaultLockStat(entriesLocked); 1173 ser.setDefaultLockStat(entriesLocked);
1170 if (!ser.deSerialize(&dta)) 1174 if (!ser.deSerialize(&dti))
1171 return false; 1175 return false;
1172#endif 1176#endif
1173 1177
1174 emitDataChanged(this); 1178 emitDataChanged(this);
1175 return true; 1179 return true;
1176} 1180}
1177 1181
1178bool PwMDoc::getEntry(const QString &category, unsigned int index, 1182bool PwMDoc::getEntry(const QString &category, unsigned int index,
1179 PwMDataItem * d, bool unlockIfLocked) 1183 PwMDataItem * d, bool unlockIfLocked)
1180{ 1184{
1181 PWM_ASSERT(d); 1185 PWM_ASSERT(d);
1182 unsigned int cat = 0; 1186 unsigned int cat = 0;
1183 1187
1184 if (!findCategory(category, &cat)) { 1188 if (!findCategory(category, &cat)) {
1185 BUG(); 1189 BUG();
1186 return false; 1190 return false;
1187 } 1191 }
1188 1192
1189 return getEntry(cat, index, d, unlockIfLocked); 1193 return getEntry(cat, index, d, unlockIfLocked);
1190} 1194}
1191 1195
1192bool PwMDoc::getEntry(unsigned int category, unsigned int index, 1196bool PwMDoc::getEntry(unsigned int category, unsigned int index,
1193 PwMDataItem *d, bool unlockIfLocked) 1197 PwMDataItem *d, bool unlockIfLocked)
1194{ 1198{
1195 if (index > dta[category].d.size() - 1) 1199 if (index > dti.dta[category].d.size() - 1)
1196 return false; 1200 return false;
1197 1201
1198 bool locked = isLocked(category, index); 1202 bool locked = isLocked(category, index);
1199 if (locked) { 1203 if (locked) {
1200 /* this entry is locked. We don't return a password, 1204 /* this entry is locked. We don't return a password,
1201 * until it's unlocked by the user by inserting 1205 * until it's unlocked by the user by inserting
1202 * chipcard or entering the mpw 1206 * chipcard or entering the mpw
1203 */ 1207 */
1204 if (unlockIfLocked) { 1208 if (unlockIfLocked) {
1205 if (!lockAt(category, index, false)) { 1209 if (!lockAt(category, index, false)) {
1206 return false; 1210 return false;
1207 } 1211 }
1208 locked = false; 1212 locked = false;
1209 } 1213 }
1210 } 1214 }
1211 1215
1212 *d = dta[category].d[index]; 1216 *d = dti.dta[category].d[index];
1213 if (locked) 1217 if (locked)
1214 d->pw = LOCKED_STRING.latin1(); 1218 d->pw = LOCKED_STRING.latin1();
1215 1219
1216 return true; 1220 return true;
1217} 1221}
1218 1222
1219PwMerror PwMDoc::getCommentByLvp(const QString &category, int listViewPos, 1223PwMerror PwMDoc::getCommentByLvp(const QString &category, int listViewPos,
1220 string *foundComment) 1224 string *foundComment)
1221{ 1225{
1222 PWM_ASSERT(foundComment); 1226 PWM_ASSERT(foundComment);
1223 unsigned int cat = 0; 1227 unsigned int cat = 0;
1224 1228
1225 if (!findCategory(category, &cat)) 1229 if (!findCategory(category, &cat))
1226 return e_invalidArg; 1230 return e_invalidArg;
1227 1231
1228 unsigned int i, entries = numEntries(cat); 1232 unsigned int i, entries = numEntries(cat);
1229 for (i = 0; i < entries; ++i) { 1233 for (i = 0; i < entries; ++i) {
1230 if (dta[cat].d[i].listViewPos == listViewPos) { 1234 if (dti.dta[cat].d[i].listViewPos == listViewPos) {
1231 *foundComment = dta[cat].d[i].comment; 1235 *foundComment = dti.dta[cat].d[i].comment;
1232 if (dta[cat].d[i].binary) 1236 if (dti.dta[cat].d[i].binary)
1233 return e_binEntry; 1237 return e_binEntry;
1234 return e_normalEntry; 1238 return e_normalEntry;
1235 } 1239 }
1236 } 1240 }
1237 BUG(); 1241 BUG();
1238 return e_generic; 1242 return e_generic;
1239} 1243}
1240 1244
1241bool PwMDoc::compressDta(string *d, char algo) 1245bool PwMDoc::compressDta(string *d, char algo)
1242{ 1246{
1243 PWM_ASSERT(d); 1247 PWM_ASSERT(d);
1244 switch (algo) { 1248 switch (algo) {
1245 case PWM_COMPRESS_GZIP: { 1249 case PWM_COMPRESS_GZIP: {
1246 CompressGzip comp; 1250 CompressGzip comp;
1247 return comp.compress(d); 1251 return comp.compress(d);
1248 } case PWM_COMPRESS_BZIP2: { 1252 } case PWM_COMPRESS_BZIP2: {
1249 CompressBzip2 comp; 1253 CompressBzip2 comp;
1250 return comp.compress(d); 1254 return comp.compress(d);
1251 } case PWM_COMPRESS_NONE: { 1255 } case PWM_COMPRESS_NONE: {
1252 return true; 1256 return true;
1253 } default: { 1257 } default: {
1254 BUG(); 1258 BUG();
1255 } 1259 }
1256 } 1260 }
@@ -1469,74 +1473,74 @@ PwMerror PwMDoc::checkDataHash(char dataHashType, const string *dataHash,
1469 dataHashType); 1473 dataHashType);
1470 if (err != e_success) 1474 if (err != e_success)
1471 return e_hashNotImpl; 1475 return e_hashNotImpl;
1472 string calcHash(reinterpret_cast<const char *>(buf), 1476 string calcHash(reinterpret_cast<const char *>(buf),
1473 static_cast<string::size_type>(hashLen)); 1477 static_cast<string::size_type>(hashLen));
1474 delete [] buf; 1478 delete [] buf;
1475 if (calcHash != *dataHash) 1479 if (calcHash != *dataHash)
1476 return e_fileCorrupt; 1480 return e_fileCorrupt;
1477 break; 1481 break;
1478 } 1482 }
1479#endif 1483#endif
1480 default: 1484 default:
1481 return e_hashNotImpl; 1485 return e_hashNotImpl;
1482 } 1486 }
1483 return e_success; 1487 return e_success;
1484} 1488}
1485 1489
1486bool PwMDoc::lockAt(unsigned int category, unsigned int index, 1490bool PwMDoc::lockAt(unsigned int category, unsigned int index,
1487 bool lock) 1491 bool lock)
1488{ 1492{
1489 if (index >= numEntries(category)) { 1493 if (index >= numEntries(category)) {
1490 BUG(); 1494 BUG();
1491 return false; 1495 return false;
1492 } 1496 }
1493 if (lock == dta[category].d[index].lockStat) 1497 if (lock == dti.dta[category].d[index].lockStat)
1494 return true; 1498 return true;
1495 1499
1496 if (!lock && currentPw != "") { 1500 if (!lock && currentPw != "") {
1497 // "unlocking" and "password is already set" 1501 // "unlocking" and "password is already set"
1498 if (!getDocStatFlag(DOC_STAT_UNLOCK_WITHOUT_PW)) { 1502 if (!getDocStatFlag(DOC_STAT_UNLOCK_WITHOUT_PW)) {
1499 // unlocking without pw not allowed 1503 // unlocking without pw not allowed
1500 QString pw; 1504 QString pw;
1501 pw = requestMpw(getDocStatFlag(DOC_STAT_USE_CHIPCARD)); 1505 pw = requestMpw(getDocStatFlag(DOC_STAT_USE_CHIPCARD));
1502 if (pw != "") { 1506 if (pw != "") {
1503 if (pw != currentPw) { 1507 if (pw != currentPw) {
1504 wrongMpwMsgBox(getDocStatFlag(DOC_STAT_USE_CHIPCARD)); 1508 wrongMpwMsgBox(getDocStatFlag(DOC_STAT_USE_CHIPCARD));
1505 return false; 1509 return false;
1506 } else { 1510 } else {
1507 timer()->start(DocTimer::id_mpwTimer); 1511 timer()->start(DocTimer::id_mpwTimer);
1508 } 1512 }
1509 } else { 1513 } else {
1510 return false; 1514 return false;
1511 } 1515 }
1512 } else { 1516 } else {
1513 timer()->start(DocTimer::id_mpwTimer); 1517 timer()->start(DocTimer::id_mpwTimer);
1514 } 1518 }
1515 } 1519 }
1516 1520
1517 dta[category].d[index].lockStat = lock; 1521 dti.dta[category].d[index].lockStat = lock;
1518 dta[category].d[index].rev++; // increment revision counter. 1522 dti.dta[category].d[index].rev++; // increment revision counter.
1519 1523
1520 emitDataChanged(this); 1524 emitDataChanged(this);
1521 if (!lock) 1525 if (!lock)
1522 timer()->start(DocTimer::id_autoLockTimer); 1526 timer()->start(DocTimer::id_autoLockTimer);
1523 1527
1524 return true; 1528 return true;
1525 1529
1526} 1530}
1527 1531
1528bool PwMDoc::lockAt(const QString &category,unsigned int index, 1532bool PwMDoc::lockAt(const QString &category,unsigned int index,
1529 bool lock) 1533 bool lock)
1530{ 1534{
1531 unsigned int cat = 0; 1535 unsigned int cat = 0;
1532 1536
1533 if (!findCategory(category, &cat)) { 1537 if (!findCategory(category, &cat)) {
1534 BUG(); 1538 BUG();
1535 return false; 1539 return false;
1536 } 1540 }
1537 1541
1538 return lockAt(cat, index, lock); 1542 return lockAt(cat, index, lock);
1539} 1543}
1540 1544
1541bool PwMDoc::lockAll(bool lock) 1545bool PwMDoc::lockAll(bool lock)
1542{ 1546{
@@ -1550,50 +1554,50 @@ bool PwMDoc::lockAll(bool lock)
1550 if (isDocEmpty()) { 1554 if (isDocEmpty()) {
1551 return true; 1555 return true;
1552 } 1556 }
1553 if (!lock && currentPw != "") { 1557 if (!lock && currentPw != "") {
1554 // unlocking and password is already set 1558 // unlocking and password is already set
1555 if (!getDocStatFlag(DOC_STAT_UNLOCK_WITHOUT_PW)) { 1559 if (!getDocStatFlag(DOC_STAT_UNLOCK_WITHOUT_PW)) {
1556 // unlocking without pw not allowed 1560 // unlocking without pw not allowed
1557 QString pw; 1561 QString pw;
1558 pw = requestMpw(getDocStatFlag(DOC_STAT_USE_CHIPCARD)); 1562 pw = requestMpw(getDocStatFlag(DOC_STAT_USE_CHIPCARD));
1559 if (pw != "") { 1563 if (pw != "") {
1560 if (pw != currentPw) { 1564 if (pw != currentPw) {
1561 wrongMpwMsgBox(getDocStatFlag(DOC_STAT_USE_CHIPCARD)); 1565 wrongMpwMsgBox(getDocStatFlag(DOC_STAT_USE_CHIPCARD));
1562 return false; 1566 return false;
1563 } else { 1567 } else {
1564 timer()->start(DocTimer::id_mpwTimer); 1568 timer()->start(DocTimer::id_mpwTimer);
1565 } 1569 }
1566 } else { 1570 } else {
1567 return false; 1571 return false;
1568 } 1572 }
1569 } else { 1573 } else {
1570 timer()->start(DocTimer::id_mpwTimer); 1574 timer()->start(DocTimer::id_mpwTimer);
1571 } 1575 }
1572 } 1576 }
1573 1577
1574 vector<PwMCategoryItem>::iterator catBegin = dta.begin(), 1578 vector<PwMCategoryItem>::iterator catBegin = dti.dta.begin(),
1575 catEnd = dta.end(), 1579 catEnd = dti.dta.end(),
1576 catI = catBegin; 1580 catI = catBegin;
1577 vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI; 1581 vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
1578 while (catI != catEnd) { 1582 while (catI != catEnd) {
1579 entrBegin = catI->d.begin(); 1583 entrBegin = catI->d.begin();
1580 entrEnd = catI->d.end(); 1584 entrEnd = catI->d.end();
1581 entrI = entrBegin; 1585 entrI = entrBegin;
1582 while (entrI != entrEnd) { 1586 while (entrI != entrEnd) {
1583 entrI->lockStat = lock; 1587 entrI->lockStat = lock;
1584 entrI->rev++; // increment revision counter. 1588 entrI->rev++; // increment revision counter.
1585 ++entrI; 1589 ++entrI;
1586 } 1590 }
1587 ++catI; 1591 ++catI;
1588 } 1592 }
1589 1593
1590 emitDataChanged(this); 1594 emitDataChanged(this);
1591 if (lock) 1595 if (lock)
1592 timer()->stop(DocTimer::id_autoLockTimer); 1596 timer()->stop(DocTimer::id_autoLockTimer);
1593 else 1597 else
1594 timer()->start(DocTimer::id_autoLockTimer); 1598 timer()->start(DocTimer::id_autoLockTimer);
1595 1599
1596 return true; 1600 return true;
1597} 1601}
1598 1602
1599bool PwMDoc::isLocked(const QString &category, unsigned int index) 1603bool PwMDoc::isLocked(const QString &category, unsigned int index)
@@ -1624,50 +1628,50 @@ bool PwMDoc::unlockAll_tempoary(bool revert)
1624 if (ret == e_success) { 1628 if (ret == e_success) {
1625 /* deep-lock succeed. We are save. 1629 /* deep-lock succeed. We are save.
1626 * (but if it failed, just go on 1630 * (but if it failed, just go on
1627 * lock them normally) 1631 * lock them normally)
1628 */ 1632 */
1629 delete_and_null(oldLockStates); 1633 delete_and_null(oldLockStates);
1630 timer()->start(DocTimer::id_autoLockTimer); 1634 timer()->start(DocTimer::id_autoLockTimer);
1631 printDebug("tempoary unlocking of dta " 1635 printDebug("tempoary unlocking of dta "
1632 "reverted by deep-locking."); 1636 "reverted by deep-locking.");
1633 return true; 1637 return true;
1634 } 1638 }
1635 printDebug("deep-lock failed while reverting! " 1639 printDebug("deep-lock failed while reverting! "
1636 "Falling back to normal-lock."); 1640 "Falling back to normal-lock.");
1637 } 1641 }
1638 if (unlikely(!wasDeepLocked && 1642 if (unlikely(!wasDeepLocked &&
1639 numCategories() != oldLockStates->size())) { 1643 numCategories() != oldLockStates->size())) {
1640 /* DOH! We have modified "dta" while 1644 /* DOH! We have modified "dta" while
1641 * it was unlocked tempoary. DON'T DO THIS! 1645 * it was unlocked tempoary. DON'T DO THIS!
1642 */ 1646 */
1643 BUG(); 1647 BUG();
1644 delete_and_null(oldLockStates); 1648 delete_and_null(oldLockStates);
1645 timer()->start(DocTimer::id_autoLockTimer); 1649 timer()->start(DocTimer::id_autoLockTimer);
1646 return false; 1650 return false;
1647 } 1651 }
1648 vector<PwMCategoryItem>::iterator catBegin = dta.begin(), 1652 vector<PwMCategoryItem>::iterator catBegin = dti.dta.begin(),
1649 catEnd = dta.end(), 1653 catEnd = dti.dta.end(),
1650 catI = catBegin; 1654 catI = catBegin;
1651 vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI; 1655 vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
1652 vector< vector<bool> >::iterator oldCatStatI = oldLockStates->begin(); 1656 vector< vector<bool> >::iterator oldCatStatI = oldLockStates->begin();
1653 vector<bool>::iterator oldEntrStatBegin, 1657 vector<bool>::iterator oldEntrStatBegin,
1654 oldEntrStatEnd, 1658 oldEntrStatEnd,
1655 oldEntrStatI; 1659 oldEntrStatI;
1656 while (catI != catEnd) { 1660 while (catI != catEnd) {
1657 entrBegin = catI->d.begin(); 1661 entrBegin = catI->d.begin();
1658 entrEnd = catI->d.end(); 1662 entrEnd = catI->d.end();
1659 entrI = entrBegin; 1663 entrI = entrBegin;
1660 if (likely(!wasDeepLocked)) { 1664 if (likely(!wasDeepLocked)) {
1661 oldEntrStatBegin = oldCatStatI->begin(); 1665 oldEntrStatBegin = oldCatStatI->begin();
1662 oldEntrStatEnd = oldCatStatI->end(); 1666 oldEntrStatEnd = oldCatStatI->end();
1663 oldEntrStatI = oldEntrStatBegin; 1667 oldEntrStatI = oldEntrStatBegin;
1664 if (unlikely(catI->d.size() != oldCatStatI->size())) { 1668 if (unlikely(catI->d.size() != oldCatStatI->size())) {
1665 /* DOH! We have modified "dta" while 1669 /* DOH! We have modified "dta" while
1666 * it was unlocked tempoary. DON'T DO THIS! 1670 * it was unlocked tempoary. DON'T DO THIS!
1667 */ 1671 */
1668 BUG(); 1672 BUG();
1669 delete_and_null(oldLockStates); 1673 delete_and_null(oldLockStates);
1670 timer()->start(DocTimer::id_autoLockTimer); 1674 timer()->start(DocTimer::id_autoLockTimer);
1671 return false; 1675 return false;
1672 } 1676 }
1673 } 1677 }
@@ -1708,96 +1712,96 @@ bool PwMDoc::unlockAll_tempoary(bool revert)
1708 */ 1712 */
1709 BUG(); 1713 BUG();
1710 return false; 1714 return false;
1711 } 1715 }
1712 wasDeepLocked = false; 1716 wasDeepLocked = false;
1713 bool mustUnlock = false; 1717 bool mustUnlock = false;
1714 if (isDeepLocked()) { 1718 if (isDeepLocked()) {
1715 PwMerror ret; 1719 PwMerror ret;
1716 while (1) { 1720 while (1) {
1717 ret = deepLock(false); 1721 ret = deepLock(false);
1718 if (ret == e_success) { 1722 if (ret == e_success) {
1719 break; 1723 break;
1720 } else if (ret == e_wrongPw) { 1724 } else if (ret == e_wrongPw) {
1721 wrongMpwMsgBox(getDocStatFlag(DOC_STAT_USE_CHIPCARD)); 1725 wrongMpwMsgBox(getDocStatFlag(DOC_STAT_USE_CHIPCARD));
1722 } else { 1726 } else {
1723 printDebug("deep-unlocking failed while " 1727 printDebug("deep-unlocking failed while "
1724 "tempoary unlocking!"); 1728 "tempoary unlocking!");
1725 return false; 1729 return false;
1726 } 1730 }
1727 } 1731 }
1728 wasDeepLocked = true; 1732 wasDeepLocked = true;
1729 mustUnlock = true; 1733 mustUnlock = true;
1730 } else { 1734 } else {
1731 // first check if it's needed to unlock some entries 1735 // first check if it's needed to unlock some entries
1732 vector<PwMCategoryItem>::iterator catBegin = dta.begin(), 1736 vector<PwMCategoryItem>::iterator catBegin = dti.dta.begin(),
1733 catEnd = dta.end(), 1737 catEnd = dti.dta.end(),
1734 catI = catBegin; 1738 catI = catBegin;
1735 vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI; 1739 vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
1736 while (catI != catEnd) { 1740 while (catI != catEnd) {
1737 entrBegin = catI->d.begin(); 1741 entrBegin = catI->d.begin();
1738 entrEnd = catI->d.end(); 1742 entrEnd = catI->d.end();
1739 entrI = entrBegin; 1743 entrI = entrBegin;
1740 while (entrI != entrEnd) { 1744 while (entrI != entrEnd) {
1741 if (entrI->lockStat == true) { 1745 if (entrI->lockStat == true) {
1742 mustUnlock = true; 1746 mustUnlock = true;
1743 break; 1747 break;
1744 } 1748 }
1745 ++entrI; 1749 ++entrI;
1746 } 1750 }
1747 if (mustUnlock) 1751 if (mustUnlock)
1748 break; 1752 break;
1749 ++catI; 1753 ++catI;
1750 } 1754 }
1751 } 1755 }
1752 if (!mustUnlock) { 1756 if (!mustUnlock) {
1753 // nothing to do. 1757 // nothing to do.
1754 timer()->stop(DocTimer::id_autoLockTimer); 1758 timer()->stop(DocTimer::id_autoLockTimer);
1755 printDebug("unlockAll_tempoary(): nothing to do."); 1759 printDebug("unlockAll_tempoary(): nothing to do.");
1756 return true; 1760 return true;
1757 } else if (!wasDeepLocked) { 1761 } else if (!wasDeepLocked) {
1758 if (!getDocStatFlag(DOC_STAT_UNLOCK_WITHOUT_PW) && 1762 if (!getDocStatFlag(DOC_STAT_UNLOCK_WITHOUT_PW) &&
1759 currentPw != "") { 1763 currentPw != "") {
1760 /* we can't unlock without mpw, so 1764 /* we can't unlock without mpw, so
1761 * we need to ask for it. 1765 * we need to ask for it.
1762 */ 1766 */
1763 QString pw; 1767 QString pw;
1764 while (1) { 1768 while (1) {
1765 pw = requestMpw(getDocStatFlag(DOC_STAT_USE_CHIPCARD)); 1769 pw = requestMpw(getDocStatFlag(DOC_STAT_USE_CHIPCARD));
1766 if (pw == "") { 1770 if (pw == "") {
1767 return false; 1771 return false;
1768 } else if (pw == currentPw) { 1772 } else if (pw == currentPw) {
1769 break; 1773 break;
1770 } 1774 }
1771 wrongMpwMsgBox(getDocStatFlag(DOC_STAT_USE_CHIPCARD)); 1775 wrongMpwMsgBox(getDocStatFlag(DOC_STAT_USE_CHIPCARD));
1772 } 1776 }
1773 } 1777 }
1774 } 1778 }
1775 timer()->stop(DocTimer::id_autoLockTimer); 1779 timer()->stop(DocTimer::id_autoLockTimer);
1776 oldLockStates = new vector< vector<bool> >; 1780 oldLockStates = new vector< vector<bool> >;
1777 vector<bool> tmp_vec; 1781 vector<bool> tmp_vec;
1778 vector<PwMCategoryItem>::iterator catBegin = dta.begin(), 1782 vector<PwMCategoryItem>::iterator catBegin = dti.dta.begin(),
1779 catEnd = dta.end(), 1783 catEnd = dti.dta.end(),
1780 catI = catBegin; 1784 catI = catBegin;
1781 vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI; 1785 vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
1782 while (catI != catEnd) { 1786 while (catI != catEnd) {
1783 entrBegin = catI->d.begin(); 1787 entrBegin = catI->d.begin();
1784 entrEnd = catI->d.end(); 1788 entrEnd = catI->d.end();
1785 entrI = entrBegin; 1789 entrI = entrBegin;
1786 while (entrI != entrEnd) { 1790 while (entrI != entrEnd) {
1787 if (!wasDeepLocked) { 1791 if (!wasDeepLocked) {
1788 tmp_vec.push_back(entrI->lockStat); 1792 tmp_vec.push_back(entrI->lockStat);
1789 } 1793 }
1790 entrI->lockStat = false; 1794 entrI->lockStat = false;
1791 ++entrI; 1795 ++entrI;
1792 } 1796 }
1793 if (!wasDeepLocked) { 1797 if (!wasDeepLocked) {
1794 oldLockStates->push_back(tmp_vec); 1798 oldLockStates->push_back(tmp_vec);
1795 tmp_vec.clear(); 1799 tmp_vec.clear();
1796 } 1800 }
1797 ++catI; 1801 ++catI;
1798 } 1802 }
1799 printDebug("tempoary unlocked dta."); 1803 printDebug("tempoary unlocked dta.");
1800 } 1804 }
1801 1805
1802 return true; 1806 return true;
1803} 1807}
@@ -1839,448 +1843,448 @@ PwMerror PwMDoc::deepLock(bool lock, bool saveToFile)
1839 ret = openDoc(&filename, (conf()->confGlobUnlockOnOpen()) 1843 ret = openDoc(&filename, (conf()->confGlobUnlockOnOpen())
1840 ? 0 : 1); 1844 ? 0 : 1);
1841 if (ret == e_wrongPw) { 1845 if (ret == e_wrongPw) {
1842 return e_wrongPw; 1846 return e_wrongPw;
1843 } else if (ret != e_success) { 1847 } else if (ret != e_success) {
1844 printDebug(string("PwMDoc::deepLock(false): ERR! openDoc() == ") 1848 printDebug(string("PwMDoc::deepLock(false): ERR! openDoc() == ")
1845 + tostr(static_cast<int>(ret))); 1849 + tostr(static_cast<int>(ret)));
1846 return e_lock; 1850 return e_lock;
1847 } 1851 }
1848 unsetDocStatFlag(DOC_STAT_DEEPLOCKED); 1852 unsetDocStatFlag(DOC_STAT_DEEPLOCKED);
1849 timer()->start(DocTimer::id_autoLockTimer); 1853 timer()->start(DocTimer::id_autoLockTimer);
1850 } 1854 }
1851 1855
1852 emitDataChanged(this); 1856 emitDataChanged(this);
1853 return e_success; 1857 return e_success;
1854} 1858}
1855 1859
1856void PwMDoc::_deepUnlock() 1860void PwMDoc::_deepUnlock()
1857{ 1861{
1858 deepLock(false); 1862 deepLock(false);
1859} 1863}
1860 1864
1861void PwMDoc::clearDoc() 1865void PwMDoc::clearDoc()
1862{ 1866{
1863 dta.clear(); 1867 dti.clear();
1864 PwMCategoryItem d; 1868 PwMCategoryItem d;
1865 d.name = DEFAULT_CATEGORY.latin1(); 1869 d.name = DEFAULT_CATEGORY.latin1();
1866 dta.push_back(d); 1870 dti.dta.push_back(d);
1867 currentPw = ""; 1871 currentPw = "";
1868 unsetDocStatFlag(DOC_STAT_UNLOCK_WITHOUT_PW); 1872 unsetDocStatFlag(DOC_STAT_UNLOCK_WITHOUT_PW);
1869} 1873}
1870 1874
1871void PwMDoc::changeCurrentPw() 1875void PwMDoc::changeCurrentPw()
1872{ 1876{
1873 if (currentPw == "") 1877 if (currentPw == "")
1874 return; // doc hasn't been saved. No mpw available. 1878 return; // doc hasn't been saved. No mpw available.
1875 bool useChipcard = getDocStatFlag(DOC_STAT_USE_CHIPCARD); 1879 bool useChipcard = getDocStatFlag(DOC_STAT_USE_CHIPCARD);
1876 QString pw = requestMpwChange(&currentPw, &useChipcard); 1880 QString pw = requestMpwChange(&currentPw, &useChipcard);
1877 if (pw == "") 1881 if (pw == "")
1878 return; 1882 return;
1879 if (useChipcard) 1883 if (useChipcard)
1880 setDocStatFlag(DOC_STAT_USE_CHIPCARD); 1884 setDocStatFlag(DOC_STAT_USE_CHIPCARD);
1881 else 1885 else
1882 unsetDocStatFlag(DOC_STAT_USE_CHIPCARD); 1886 unsetDocStatFlag(DOC_STAT_USE_CHIPCARD);
1883 setCurrentPw(pw); 1887 setCurrentPw(pw);
1884} 1888}
1885 1889
1886void PwMDoc::setListViewPos(const QString &category, unsigned int index, 1890void PwMDoc::setListViewPos(const QString &category, unsigned int index,
1887 int pos) 1891 int pos)
1888{ 1892{
1889 unsigned int cat = 0; 1893 unsigned int cat = 0;
1890 1894
1891 if (!findCategory(category, &cat)) { 1895 if (!findCategory(category, &cat)) {
1892 BUG(); 1896 BUG();
1893 return; 1897 return;
1894 } 1898 }
1895 setListViewPos(cat, index, pos); 1899 setListViewPos(cat, index, pos);
1896} 1900}
1897 1901
1898void PwMDoc::setListViewPos(unsigned int category, unsigned int index, 1902void PwMDoc::setListViewPos(unsigned int category, unsigned int index,
1899 int pos) 1903 int pos)
1900{ 1904{
1901 dta[category].d[index].listViewPos = pos; 1905 dti.dta[category].d[index].listViewPos = pos;
1902 1906
1903/* FIXME workaround: don't flag dirty, because this function sometimes 1907/* FIXME workaround: don't flag dirty, because this function sometimes
1904 * get's called when it shouldn't. It's because PwMView assumes 1908 * get's called when it shouldn't. It's because PwMView assumes
1905 * the user resorted the UI on behalf of signal layoutChanged(). 1909 * the user resorted the UI on behalf of signal layoutChanged().
1906 * This is somewhat broken and incorrect, but I've no other 1910 * This is somewhat broken and incorrect, but I've no other
1907 * solution for now. 1911 * solution for now.
1908 */ 1912 */
1909 //setDocStatFlag(DOC_STAT_DISK_DIRTY); 1913 //setDocStatFlag(DOC_STAT_DISK_DIRTY);
1910} 1914}
1911 1915
1912int PwMDoc::getListViewPos(const QString &category, unsigned int index) 1916int PwMDoc::getListViewPos(const QString &category, unsigned int index)
1913{ 1917{
1914 unsigned int cat = 0; 1918 unsigned int cat = 0;
1915 1919
1916 if (!findCategory(category, &cat)) { 1920 if (!findCategory(category, &cat)) {
1917 BUG(); 1921 BUG();
1918 return -1; 1922 return -1;
1919 } 1923 }
1920 1924
1921 return dta[cat].d[index].listViewPos; 1925 return dti.dta[cat].d[index].listViewPos;
1922} 1926}
1923 1927
1924void PwMDoc::findEntry(unsigned int category, PwMDataItem find, unsigned int searchIn, 1928void PwMDoc::findEntry(unsigned int category, PwMDataItem find, unsigned int searchIn,
1925 vector<unsigned int> *foundPositions, bool breakAfterFound, 1929 vector<unsigned int> *foundPositions, bool breakAfterFound,
1926 bool caseSensitive, bool exactWordMatch, bool sortByLvp) 1930 bool caseSensitive, bool exactWordMatch, bool sortByLvp)
1927{ 1931{
1928 PWM_ASSERT(foundPositions); 1932 PWM_ASSERT(foundPositions);
1929 PWM_ASSERT(searchIn); 1933 PWM_ASSERT(searchIn);
1930 foundPositions->clear(); 1934 foundPositions->clear();
1931 1935
1932 unsigned int i, entries = numEntries(category); 1936 unsigned int i, entries = numEntries(category);
1933 for (i = 0; i < entries; ++i) { 1937 for (i = 0; i < entries; ++i) {
1934 if (searchIn & SEARCH_IN_DESC) { 1938 if (searchIn & SEARCH_IN_DESC) {
1935 if (!compareString(find.desc, dta[category].d[i].desc, 1939 if (!compareString(find.desc, dti.dta[category].d[i].desc,
1936 caseSensitive, exactWordMatch)) { 1940 caseSensitive, exactWordMatch)) {
1937 continue; 1941 continue;
1938 } 1942 }
1939 } 1943 }
1940 if (searchIn & SEARCH_IN_NAME) { 1944 if (searchIn & SEARCH_IN_NAME) {
1941 if (!compareString(find.name, dta[category].d[i].name, 1945 if (!compareString(find.name, dti.dta[category].d[i].name,
1942 caseSensitive, exactWordMatch)) { 1946 caseSensitive, exactWordMatch)) {
1943 continue; 1947 continue;
1944 } 1948 }
1945 } 1949 }
1946 if (searchIn & SEARCH_IN_PW) { 1950 if (searchIn & SEARCH_IN_PW) {
1947 bool wasLocked = isLocked(category, i); 1951 bool wasLocked = isLocked(category, i);
1948 getDataChangedLock(); 1952 getDataChangedLock();
1949 lockAt(category, i, false); 1953 lockAt(category, i, false);
1950 if (!compareString(find.pw, dta[category].d[i].pw, 1954 if (!compareString(find.pw, dti.dta[category].d[i].pw,
1951 caseSensitive, exactWordMatch)) { 1955 caseSensitive, exactWordMatch)) {
1952 lockAt(category, i, wasLocked); 1956 lockAt(category, i, wasLocked);
1953 putDataChangedLock(); 1957 putDataChangedLock();
1954 continue; 1958 continue;
1955 } 1959 }
1956 lockAt(category, i, wasLocked); 1960 lockAt(category, i, wasLocked);
1957 putDataChangedLock(); 1961 putDataChangedLock();
1958 } 1962 }
1959 if (searchIn & SEARCH_IN_COMMENT) { 1963 if (searchIn & SEARCH_IN_COMMENT) {
1960 if (!compareString(find.comment, dta[category].d[i].comment, 1964 if (!compareString(find.comment, dti.dta[category].d[i].comment,
1961 caseSensitive, exactWordMatch)) { 1965 caseSensitive, exactWordMatch)) {
1962 continue; 1966 continue;
1963 } 1967 }
1964 } 1968 }
1965 if (searchIn & SEARCH_IN_URL) { 1969 if (searchIn & SEARCH_IN_URL) {
1966 if (!compareString(find.url, dta[category].d[i].url, 1970 if (!compareString(find.url, dti.dta[category].d[i].url,
1967 caseSensitive, exactWordMatch)) { 1971 caseSensitive, exactWordMatch)) {
1968 continue; 1972 continue;
1969 } 1973 }
1970 } 1974 }
1971 if (searchIn & SEARCH_IN_LAUNCHER) { 1975 if (searchIn & SEARCH_IN_LAUNCHER) {
1972 if (!compareString(find.launcher, dta[category].d[i].launcher, 1976 if (!compareString(find.launcher, dti.dta[category].d[i].launcher,
1973 caseSensitive, exactWordMatch)) { 1977 caseSensitive, exactWordMatch)) {
1974 continue; 1978 continue;
1975 } 1979 }
1976 } 1980 }
1977 1981
1978 // all selected "searchIn" matched. 1982 // all selected "searchIn" matched.
1979 foundPositions->push_back(i); 1983 foundPositions->push_back(i);
1980 if (breakAfterFound) 1984 if (breakAfterFound)
1981 break; 1985 break;
1982 } 1986 }
1983 1987
1984 if (sortByLvp && foundPositions->size() > 1) { 1988 if (sortByLvp && foundPositions->size() > 1) {
1985 vector< pair<unsigned int /* foundPosition (real doc pos) */, 1989 vector< pair<unsigned int /* foundPosition (real doc pos) */,
1986 unsigned int /* lvp-pos */> > tmp_vec; 1990 unsigned int /* lvp-pos */> > tmp_vec;
1987 1991
1988 unsigned int i, items = foundPositions->size(); 1992 unsigned int i, items = foundPositions->size();
1989 pair<unsigned int, unsigned int> tmp_pair; 1993 pair<unsigned int, unsigned int> tmp_pair;
1990 for (i = 0; i < items; ++i) { 1994 for (i = 0; i < items; ++i) {
1991 tmp_pair.first = (*foundPositions)[i]; 1995 tmp_pair.first = (*foundPositions)[i];
1992 tmp_pair.second = dta[category].d[(*foundPositions)[i]].listViewPos; 1996 tmp_pair.second = dti.dta[category].d[(*foundPositions)[i]].listViewPos;
1993 tmp_vec.push_back(tmp_pair); 1997 tmp_vec.push_back(tmp_pair);
1994 } 1998 }
1995 sort(tmp_vec.begin(), tmp_vec.end(), dta_lvp_greater()); 1999 sort(tmp_vec.begin(), tmp_vec.end(), dta_lvp_greater());
1996 foundPositions->clear(); 2000 foundPositions->clear();
1997 for (i = 0; i < items; ++i) { 2001 for (i = 0; i < items; ++i) {
1998 foundPositions->push_back(tmp_vec[i].first); 2002 foundPositions->push_back(tmp_vec[i].first);
1999 } 2003 }
2000 } 2004 }
2001} 2005}
2002 2006
2003void PwMDoc::findEntry(const QString &category, PwMDataItem find, unsigned int searchIn, 2007void PwMDoc::findEntry(const QString &category, PwMDataItem find, unsigned int searchIn,
2004 vector<unsigned int> *foundPositions, bool breakAfterFound, 2008 vector<unsigned int> *foundPositions, bool breakAfterFound,
2005 bool caseSensitive, bool exactWordMatch, bool sortByLvp) 2009 bool caseSensitive, bool exactWordMatch, bool sortByLvp)
2006{ 2010{
2007 PWM_ASSERT(foundPositions); 2011 PWM_ASSERT(foundPositions);
2008 unsigned int cat = 0; 2012 unsigned int cat = 0;
2009 2013
2010 if (!findCategory(category, &cat)) { 2014 if (!findCategory(category, &cat)) {
2011 foundPositions->clear(); 2015 foundPositions->clear();
2012 return; 2016 return;
2013 } 2017 }
2014 2018
2015 findEntry(cat, find, searchIn, foundPositions, breakAfterFound, 2019 findEntry(cat, find, searchIn, foundPositions, breakAfterFound,
2016 caseSensitive, exactWordMatch, sortByLvp); 2020 caseSensitive, exactWordMatch, sortByLvp);
2017} 2021}
2018 2022
2019bool PwMDoc::compareString(const string &s1, const string &s2, bool caseSensitive, 2023bool PwMDoc::compareString(const string &s1, const string &s2, bool caseSensitive,
2020 bool exactWordMatch) 2024 bool exactWordMatch)
2021{ 2025{
2022 QString _s1(s1.c_str()); 2026 QString _s1(s1.c_str());
2023 QString _s2(s2.c_str()); 2027 QString _s2(s2.c_str());
2024 if (!caseSensitive) { 2028 if (!caseSensitive) {
2025 _s1 = _s1.lower(); 2029 _s1 = _s1.lower();
2026 _s2 = _s2.lower(); 2030 _s2 = _s2.lower();
2027 } 2031 }
2028 if (exactWordMatch ? (_s1 == _s2) : (_s2.find(_s1) != -1)) 2032 if (exactWordMatch ? (_s1 == _s2) : (_s2.find(_s1) != -1))
2029 return true; 2033 return true;
2030 return false; 2034 return false;
2031} 2035}
2032 2036
2033bool PwMDoc::findCategory(const QString &name, unsigned int *index) 2037bool PwMDoc::findCategory(const QString &name, unsigned int *index)
2034{ 2038{
2035 vector<PwMCategoryItem>::iterator i = dta.begin(), 2039 vector<PwMCategoryItem>::iterator i = dti.dta.begin(),
2036 end = dta.end(); 2040 end = dti.dta.end();
2037 while (i != end) { 2041 while (i != end) {
2038 if ((*i).name == name.latin1()) { 2042 if ((*i).name == name.latin1()) {
2039 if (index) { 2043 if (index) {
2040 *index = i - dta.begin(); 2044 *index = i - dti.dta.begin();
2041 } 2045 }
2042 return true; 2046 return true;
2043 } 2047 }
2044 ++i; 2048 ++i;
2045 } 2049 }
2046 return false; 2050 return false;
2047} 2051}
2048 2052
2049bool PwMDoc::renameCategory(const QString &category, const QString &newName) 2053bool PwMDoc::renameCategory(const QString &category, const QString &newName)
2050{ 2054{
2051 unsigned int cat = 0; 2055 unsigned int cat = 0;
2052 2056
2053 if (!findCategory(category, &cat)) 2057 if (!findCategory(category, &cat))
2054 return false; 2058 return false;
2055 2059
2056 return renameCategory(cat, newName); 2060 return renameCategory(cat, newName);
2057} 2061}
2058 2062
2059bool PwMDoc::renameCategory(unsigned int category, const QString &newName, 2063bool PwMDoc::renameCategory(unsigned int category, const QString &newName,
2060 bool dontFlagDirty) 2064 bool dontFlagDirty)
2061{ 2065{
2062 if (category > numCategories() - 1) 2066 if (category > numCategories() - 1)
2063 return false; 2067 return false;
2064 2068
2065 dta[category].name = newName.latin1(); 2069 dti.dta[category].name = newName.latin1();
2066 if (!dontFlagDirty) 2070 if (!dontFlagDirty)
2067 flagDirty(); 2071 flagDirty();
2068 2072
2069 return true; 2073 return true;
2070} 2074}
2071 2075
2072bool PwMDoc::delCategory(const QString &category) 2076bool PwMDoc::delCategory(const QString &category)
2073{ 2077{
2074 unsigned int cat = 0; 2078 unsigned int cat = 0;
2075 2079
2076 if (!findCategory(category, &cat)) 2080 if (!findCategory(category, &cat))
2077 return false; 2081 return false;
2078 2082
2079 return delCategory(cat); 2083 return delCategory(cat);
2080} 2084}
2081 2085
2082bool PwMDoc::delCategory(unsigned int category, bool dontFlagDirty) 2086bool PwMDoc::delCategory(unsigned int category, bool dontFlagDirty)
2083{ 2087{
2084 if (category > numCategories() - 1) 2088 if (category > numCategories() - 1)
2085 return false; 2089 return false;
2086 2090
2087 // We don't delete it, if it is the last existing 2091 // We don't delete it, if it is the last existing
2088 // category! Instead we rename it to "Default". 2092 // category! Instead we rename it to "Default".
2089 if (numCategories() > 1) { 2093 if (numCategories() > 1) {
2090 dta.erase(dta.begin() + category); 2094 dti.dta.erase(dti.dta.begin() + category);
2091 } else { 2095 } else {
2092 renameCategory(category, DEFAULT_CATEGORY, dontFlagDirty); 2096 renameCategory(category, DEFAULT_CATEGORY, dontFlagDirty);
2093 return true; 2097 return true;
2094 } 2098 }
2095 if (!dontFlagDirty) 2099 if (!dontFlagDirty)
2096 flagDirty(); 2100 flagDirty();
2097 2101
2098 return true; 2102 return true;
2099} 2103}
2100 2104
2101void PwMDoc::delAllEmptyCat(bool dontFlagDirty) 2105void PwMDoc::delAllEmptyCat(bool dontFlagDirty)
2102{ 2106{
2103 vector<PwMCategoryItem>::iterator begin = dta.begin(), 2107 vector<PwMCategoryItem>::iterator begin = dti.dta.begin(),
2104 end = dta.end(), 2108 end = dti.dta.end(),
2105 i = begin; 2109 i = begin;
2106 while (i != end) { 2110 while (i != end) {
2107 if (i->d.empty()) { 2111 if (i->d.empty()) {
2108 delCategory(begin - i, dontFlagDirty); 2112 delCategory(begin - i, dontFlagDirty);
2109 } 2113 }
2110 ++i; 2114 ++i;
2111 } 2115 }
2112} 2116}
2113 2117
2114void PwMDoc::getCategoryList(vector<string> *list) 2118void PwMDoc::getCategoryList(vector<string> *list)
2115{ 2119{
2116 PWM_ASSERT(list); 2120 PWM_ASSERT(list);
2117 list->clear(); 2121 list->clear();
2118 vector<PwMCategoryItem>::iterator i = dta.begin(), 2122 vector<PwMCategoryItem>::iterator i = dti.dta.begin(),
2119 end = dta.end(); 2123 end = dti.dta.end();
2120 while (i != end) { 2124 while (i != end) {
2121 list->push_back(i->name); 2125 list->push_back(i->name);
2122 ++i; 2126 ++i;
2123 } 2127 }
2124} 2128}
2125 2129
2126void PwMDoc::getCategoryList(QStringList *list) 2130void PwMDoc::getCategoryList(QStringList *list)
2127{ 2131{
2128 PWM_ASSERT(list); 2132 PWM_ASSERT(list);
2129 list->clear(); 2133 list->clear();
2130 vector<PwMCategoryItem>::iterator i = dta.begin(), 2134 vector<PwMCategoryItem>::iterator i = dti.dta.begin(),
2131 end = dta.end(); 2135 end = dti.dta.end();
2132 while (i != end) { 2136 while (i != end) {
2133#ifndef PWM_EMBEDDED 2137#ifndef PWM_EMBEDDED
2134 list->push_back(i->name.c_str()); 2138 list->push_back(i->name.c_str());
2135#else 2139#else
2136 list->append(i->name.c_str()); 2140 list->append(i->name.c_str());
2137#endif 2141#endif
2138 ++i; 2142 ++i;
2139 } 2143 }
2140} 2144}
2141 2145
2142void PwMDoc::getEntryList(const QString &category, QStringList *list) 2146void PwMDoc::getEntryList(const QString &category, QStringList *list)
2143{ 2147{
2144 PWM_ASSERT(list); 2148 PWM_ASSERT(list);
2145 unsigned int cat = 0; 2149 unsigned int cat = 0;
2146 if (!findCategory(category, &cat)) { 2150 if (!findCategory(category, &cat)) {
2147 list->clear(); 2151 list->clear();
2148 return; 2152 return;
2149 } 2153 }
2150 getEntryList(cat, list); 2154 getEntryList(cat, list);
2151} 2155}
2152 2156
2153void PwMDoc::getEntryList(const QString &category, vector<string> *list) 2157void PwMDoc::getEntryList(const QString &category, vector<string> *list)
2154{ 2158{
2155 PWM_ASSERT(list); 2159 PWM_ASSERT(list);
2156 unsigned int cat = 0; 2160 unsigned int cat = 0;
2157 if (!findCategory(category, &cat)) { 2161 if (!findCategory(category, &cat)) {
2158 list->clear(); 2162 list->clear();
2159 return; 2163 return;
2160 } 2164 }
2161 getEntryList(cat, list); 2165 getEntryList(cat, list);
2162} 2166}
2163 2167
2164void PwMDoc::getEntryList(unsigned int category, vector<string> *list) 2168void PwMDoc::getEntryList(unsigned int category, vector<string> *list)
2165{ 2169{
2166 PWM_ASSERT(list); 2170 PWM_ASSERT(list);
2167 list->clear(); 2171 list->clear();
2168 vector<PwMDataItem>::iterator begin = dta[category].d.begin(), 2172 vector<PwMDataItem>::iterator begin = dti.dta[category].d.begin(),
2169 end = dta[category].d.end(), 2173 end = dti.dta[category].d.end(),
2170 i = begin; 2174 i = begin;
2171 while (i != end) { 2175 while (i != end) {
2172 list->push_back(i->desc); 2176 list->push_back(i->desc);
2173 ++i; 2177 ++i;
2174 } 2178 }
2175} 2179}
2176 2180
2177void PwMDoc::getEntryList(unsigned int category, QStringList *list) 2181void PwMDoc::getEntryList(unsigned int category, QStringList *list)
2178{ 2182{
2179 PWM_ASSERT(list); 2183 PWM_ASSERT(list);
2180 list->clear(); 2184 list->clear();
2181 vector<PwMDataItem>::iterator begin = dta[category].d.begin(), 2185 vector<PwMDataItem>::iterator begin = dti.dta[category].d.begin(),
2182 end = dta[category].d.end(), 2186 end = dti.dta[category].d.end(),
2183 i = begin; 2187 i = begin;
2184 while (i != end) { 2188 while (i != end) {
2185#ifndef PWM_EMBEDDED 2189#ifndef PWM_EMBEDDED
2186 list->push_back(i->desc.c_str()); 2190 list->push_back(i->desc.c_str());
2187#else 2191#else
2188 list->append(i->desc.c_str()); 2192 list->append(i->desc.c_str());
2189#endif 2193#endif
2190 ++i; 2194 ++i;
2191 } 2195 }
2192} 2196}
2193 2197
2194bool PwMDoc::execLauncher(const QString &category, unsigned int entryIndex) 2198bool PwMDoc::execLauncher(const QString &category, unsigned int entryIndex)
2195{ 2199{
2196 unsigned int cat = 0; 2200 unsigned int cat = 0;
2197 2201
2198 if (!findCategory(category, &cat)) 2202 if (!findCategory(category, &cat))
2199 return false; 2203 return false;
2200 2204
2201 return execLauncher(cat, entryIndex); 2205 return execLauncher(cat, entryIndex);
2202} 2206}
2203 2207
2204bool PwMDoc::execLauncher(unsigned int category, unsigned int entryIndex) 2208bool PwMDoc::execLauncher(unsigned int category, unsigned int entryIndex)
2205{ 2209{
2206 if (geteuid() == 0) { 2210 if (geteuid() == 0) {
2207 rootAlertMsgBox(); 2211 rootAlertMsgBox();
2208 return false; 2212 return false;
2209 } 2213 }
2210 QString command(dta[category].d[entryIndex].launcher.c_str()); 2214 QString command(dti.dta[category].d[entryIndex].launcher.c_str());
2211 bool wasLocked = isLocked(category, entryIndex); 2215 bool wasLocked = isLocked(category, entryIndex);
2212 2216
2213 if (command.find("$p") != -1) { 2217 if (command.find("$p") != -1) {
2214 /* the user requested the password to be included 2218 /* the user requested the password to be included
2215 * into the command. We have to ask for the password, 2219 * into the command. We have to ask for the password,
2216 * if it's locked. We do that by unlocking the entry 2220 * if it's locked. We do that by unlocking the entry
2217 */ 2221 */
2218 if (!lockAt(category, entryIndex, false)) 2222 if (!lockAt(category, entryIndex, false))
2219 return false; 2223 return false;
2220 } 2224 }
2221#ifndef PWM_EMBEDDED 2225#ifndef PWM_EMBEDDED
2222 command.replace("$d", dta[category].d[entryIndex].desc.c_str()); 2226 command.replace("$d", dti.dta[category].d[entryIndex].desc.c_str());
2223 command.replace("$n", dta[category].d[entryIndex].name.c_str()); 2227 command.replace("$n", dti.dta[category].d[entryIndex].name.c_str());
2224 command.replace("$p", dta[category].d[entryIndex].pw.c_str()); 2228 command.replace("$p", dti.dta[category].d[entryIndex].pw.c_str());
2225 command.replace("$u", dta[category].d[entryIndex].url.c_str()); 2229 command.replace("$u", dti.dta[category].d[entryIndex].url.c_str());
2226 command.replace("$c", dta[category].d[entryIndex].comment.c_str()); 2230 command.replace("$c", dti.dta[category].d[entryIndex].comment.c_str());
2227#else 2231#else
2228 command.replace(QRegExp("$d"), dta[category].d[entryIndex].desc.c_str()); 2232 command.replace(QRegExp("$d"), dti.dta[category].d[entryIndex].desc.c_str());
2229 command.replace(QRegExp("$n"), dta[category].d[entryIndex].name.c_str()); 2233 command.replace(QRegExp("$n"), dti.dta[category].d[entryIndex].name.c_str());
2230 command.replace(QRegExp("$p"), dta[category].d[entryIndex].pw.c_str()); 2234 command.replace(QRegExp("$p"), dti.dta[category].d[entryIndex].pw.c_str());
2231 command.replace(QRegExp("$u"), dta[category].d[entryIndex].url.c_str()); 2235 command.replace(QRegExp("$u"), dti.dta[category].d[entryIndex].url.c_str());
2232 command.replace(QRegExp("$c"), dta[category].d[entryIndex].comment.c_str()); 2236 command.replace(QRegExp("$c"), dti.dta[category].d[entryIndex].comment.c_str());
2233#endif 2237#endif
2234 command.append(" &"); 2238 command.append(" &");
2235 2239
2236 QString customXterm(conf()->confGlobXtermCommand()); 2240 QString customXterm(conf()->confGlobXtermCommand());
2237 if (!customXterm.isEmpty()) 2241 if (!customXterm.isEmpty())
2238 command = customXterm + " " + command; 2242 command = customXterm + " " + command;
2239 2243
2240 system(command.latin1()); 2244 system(command.latin1());
2241 2245
2242 lockAt(category, entryIndex, wasLocked); 2246 lockAt(category, entryIndex, wasLocked);
2243 return true; 2247 return true;
2244} 2248}
2245 2249
2246bool PwMDoc::goToURL(const QString &category, unsigned int entryIndex) 2250bool PwMDoc::goToURL(const QString &category, unsigned int entryIndex)
2247{ 2251{
2248 unsigned int cat = 0; 2252 unsigned int cat = 0;
2249 2253
2250 if (!findCategory(category, &cat)) 2254 if (!findCategory(category, &cat))
2251 return false; 2255 return false;
2252 2256
2253 return goToURL(cat, entryIndex); 2257 return goToURL(cat, entryIndex);
2254} 2258}
2255 2259
2256bool PwMDoc::goToURL(unsigned int category, unsigned int entryIndex) 2260bool PwMDoc::goToURL(unsigned int category, unsigned int entryIndex)
2257{ 2261{
2258 if (geteuid() == 0) { 2262 if (geteuid() == 0) {
2259 rootAlertMsgBox(); 2263 rootAlertMsgBox();
2260 return false; 2264 return false;
2261 } 2265 }
2262 QString url(dta[category].d[entryIndex].url.c_str()); 2266 QString url(dti.dta[category].d[entryIndex].url.c_str());
2263 if (url.isEmpty()) 2267 if (url.isEmpty())
2264 return false; 2268 return false;
2265 2269
2266 QString customBrowser(conf()->confGlobBrowserCommand()); 2270 QString customBrowser(conf()->confGlobBrowserCommand());
2267 if (!customBrowser.isEmpty()) { 2271 if (!customBrowser.isEmpty()) {
2268 browserProc.clearArguments(); 2272 browserProc.clearArguments();
2269 browserProc << customBrowser << url; 2273 browserProc << customBrowser << url;
2270 if (browserProc.start(KProcess::DontCare)) 2274 if (browserProc.start(KProcess::DontCare))
2271 return true; 2275 return true;
2272 } 2276 }
2273 2277
2274 browserProc.clearArguments(); 2278 browserProc.clearArguments();
2275 browserProc << "konqueror" << url; 2279 browserProc << "konqueror" << url;
2276 if (browserProc.start(KProcess::DontCare)) 2280 if (browserProc.start(KProcess::DontCare))
2277 return true; 2281 return true;
2278 2282
2279 browserProc.clearArguments(); 2283 browserProc.clearArguments();
2280 browserProc << "mozilla" << url; 2284 browserProc << "mozilla" << url;
2281 if (browserProc.start(KProcess::DontCare)) 2285 if (browserProc.start(KProcess::DontCare))
2282 return true; 2286 return true;
2283 2287
2284 browserProc.clearArguments(); 2288 browserProc.clearArguments();
2285 browserProc << "opera" << url; 2289 browserProc << "opera" << url;
2286 if (browserProc.start(KProcess::DontCare)) 2290 if (browserProc.start(KProcess::DontCare))
@@ -2329,119 +2333,119 @@ PwMerror PwMDoc::exportToText(const QString *file)
2329 header += tostr(currDate.year()); 2333 header += tostr(currDate.year());
2330 header += "\n==============================\n\n"; 2334 header += "\n==============================\n\n";
2331 2335
2332 2336
2333#ifndef PWM_EMBEDDED 2337#ifndef PWM_EMBEDDED
2334 if (f.writeBlock(header.c_str(), header.length()) != (Q_LONG)header.length()) { 2338 if (f.writeBlock(header.c_str(), header.length()) != (Q_LONG)header.length()) {
2335 unlockAll_tempoary(true); 2339 unlockAll_tempoary(true);
2336 f.close(); 2340 f.close();
2337 return e_writeFile; 2341 return e_writeFile;
2338 } 2342 }
2339#else 2343#else
2340 if (f.writeBlock(header.c_str(), header.length()) != (long)header.length()) { 2344 if (f.writeBlock(header.c_str(), header.length()) != (long)header.length()) {
2341 unlockAll_tempoary(true); 2345 unlockAll_tempoary(true);
2342 f.close(); 2346 f.close();
2343 return e_writeFile; 2347 return e_writeFile;
2344 } 2348 }
2345#endif 2349#endif
2346 unsigned int i, numCat = numCategories(); 2350 unsigned int i, numCat = numCategories();
2347 unsigned int j, numEnt; 2351 unsigned int j, numEnt;
2348 string exp; 2352 string exp;
2349 for (i = 0; i < numCat; ++i) { 2353 for (i = 0; i < numCat; ++i) {
2350 numEnt = numEntries(i); 2354 numEnt = numEntries(i);
2351 2355
2352 exp = "\n== Category: "; 2356 exp = "\n== Category: ";
2353 exp += dta[i].name; 2357 exp += dti.dta[i].name;
2354 exp += " ==\n"; 2358 exp += " ==\n";
2355#ifndef PWM_EMBEDDED 2359#ifndef PWM_EMBEDDED
2356 if (f.writeBlock(exp.c_str(), exp.length()) != (Q_LONG)exp.length()) { 2360 if (f.writeBlock(exp.c_str(), exp.length()) != (Q_LONG)exp.length()) {
2357 unlockAll_tempoary(true); 2361 unlockAll_tempoary(true);
2358 f.close(); 2362 f.close();
2359 return e_writeFile; 2363 return e_writeFile;
2360 } 2364 }
2361#else 2365#else
2362 if (f.writeBlock(exp.c_str(), exp.length()) != (long)exp.length()) { 2366 if (f.writeBlock(exp.c_str(), exp.length()) != (long)exp.length()) {
2363 unlockAll_tempoary(true); 2367 unlockAll_tempoary(true);
2364 f.close(); 2368 f.close();
2365 return e_writeFile; 2369 return e_writeFile;
2366 } 2370 }
2367#endif 2371#endif
2368 for (j = 0; j < numEnt; ++j) { 2372 for (j = 0; j < numEnt; ++j) {
2369 exp = "\n-- "; 2373 exp = "\n-- ";
2370 exp += dta[i].d[j].desc; 2374 exp += dti.dta[i].d[j].desc;
2371 exp += " --\n"; 2375 exp += " --\n";
2372 2376
2373 exp += i18n("Username: ").latin1(); 2377 exp += i18n("Username: ").latin1();
2374 exp += dta[i].d[j].name; 2378 exp += dti.dta[i].d[j].name;
2375 exp += "\n"; 2379 exp += "\n";
2376 2380
2377 exp += i18n("Password: ").latin1(); 2381 exp += i18n("Password: ").latin1();
2378 exp += dta[i].d[j].pw; 2382 exp += dti.dta[i].d[j].pw;
2379 exp += "\n"; 2383 exp += "\n";
2380 2384
2381 exp += i18n("Comment: ").latin1(); 2385 exp += i18n("Comment: ").latin1();
2382 exp += dta[i].d[j].comment; 2386 exp += dti.dta[i].d[j].comment;
2383 exp += "\n"; 2387 exp += "\n";
2384 2388
2385 exp += i18n("URL: ").latin1(); 2389 exp += i18n("URL: ").latin1();
2386 exp += dta[i].d[j].url; 2390 exp += dti.dta[i].d[j].url;
2387 exp += "\n"; 2391 exp += "\n";
2388 2392
2389 exp += i18n("Launcher: ").latin1(); 2393 exp += i18n("Launcher: ").latin1();
2390 exp += dta[i].d[j].launcher; 2394 exp += dti.dta[i].d[j].launcher;
2391 exp += "\n"; 2395 exp += "\n";
2392 2396
2393#ifndef PWM_EMBEDDED 2397#ifndef PWM_EMBEDDED
2394 if (f.writeBlock(exp.c_str(), exp.length()) != (Q_LONG)exp.length()) { 2398 if (f.writeBlock(exp.c_str(), exp.length()) != (Q_LONG)exp.length()) {
2395 unlockAll_tempoary(true); 2399 unlockAll_tempoary(true);
2396 f.close(); 2400 f.close();
2397 return e_writeFile; 2401 return e_writeFile;
2398 } 2402 }
2399#else 2403#else
2400 if (f.writeBlock(exp.c_str(), exp.length()) != (long)exp.length()) { 2404 if (f.writeBlock(exp.c_str(), exp.length()) != (long)exp.length()) {
2401 unlockAll_tempoary(true); 2405 unlockAll_tempoary(true);
2402 f.close(); 2406 f.close();
2403 return e_writeFile; 2407 return e_writeFile;
2404 } 2408 }
2405#endif 2409#endif
2406 } 2410 }
2407 } 2411 }
2408 unlockAll_tempoary(true); 2412 unlockAll_tempoary(true);
2409 f.close(); 2413 f.close();
2410 2414
2411 return e_success; 2415 return e_success;
2412} 2416}
2413 2417
2414PwMerror PwMDoc::importFromText(const QString *file, int format) 2418PwMerror PwMDoc::importFromText(const QString *file, int format)
2415{ 2419{
2416 PWM_ASSERT(file); 2420 PWM_ASSERT(file);
2417 if (format == 0) 2421 if (format == 0)
2418 return importText_PwM(file); 2422 return importText_PwM(file);
2419 else if (format == -1) { 2423 else if (format == -1) {
2420 // probe for all formats 2424 // probe for all formats
2421 if (importText_PwM(file) == e_success) 2425 if (importText_PwM(file) == e_success)
2422 return e_success; 2426 return e_success;
2423 dta.clear(); 2427 dti.clear();
2424 emitDataChanged(this); 2428 emitDataChanged(this);
2425 // add next format here... 2429 // add next format here...
2426 return e_fileFormat; 2430 return e_fileFormat;
2427 } 2431 }
2428 return e_invalidArg; 2432 return e_invalidArg;
2429} 2433}
2430 2434
2431PwMerror PwMDoc::importText_PwM(const QString *file) 2435PwMerror PwMDoc::importText_PwM(const QString *file)
2432{ 2436{
2433 PWM_ASSERT(file); 2437 PWM_ASSERT(file);
2434 FILE *f; 2438 FILE *f;
2435 int tmp; 2439 int tmp;
2436 ssize_t ret; 2440 ssize_t ret;
2437 string curCat; 2441 string curCat;
2438 unsigned int entriesRead = 0; 2442 unsigned int entriesRead = 0;
2439 PwMDataItem currItem; 2443 PwMDataItem currItem;
2440 f = fopen(file->latin1(), "r"); 2444 f = fopen(file->latin1(), "r");
2441 if (!f) 2445 if (!f)
2442 return e_openFile; 2446 return e_openFile;
2443 size_t ch_tmp_size = 1024; 2447 size_t ch_tmp_size = 1024;
2444 char *ch_tmp = (char*)malloc(ch_tmp_size); 2448 char *ch_tmp = (char*)malloc(ch_tmp_size);
2445 if (!ch_tmp) { 2449 if (!ch_tmp) {
2446 fclose(f); 2450 fclose(f);
2447 return e_outOfMem; 2451 return e_outOfMem;
@@ -2593,60 +2597,60 @@ PwMerror PwMDoc::exportToGpasman(const QString *file)
2593 if (gpmPassword == "") { 2597 if (gpmPassword == "") {
2594 unlockAll_tempoary(true); 2598 unlockAll_tempoary(true);
2595 return e_noPw; 2599 return e_noPw;
2596 } 2600 }
2597 if (gpmPassword.length() < 4) { 2601 if (gpmPassword.length() < 4) {
2598 gpmPwLenErrMsgBox(); 2602 gpmPwLenErrMsgBox();
2599 } else { 2603 } else {
2600 break; 2604 break;
2601 } 2605 }
2602 } 2606 }
2603 2607
2604 ret = gp.save_init(file->latin1(), gpmPassword.latin1()); 2608 ret = gp.save_init(file->latin1(), gpmPassword.latin1());
2605 if (ret != 1) { 2609 if (ret != 1) {
2606 unlockAll_tempoary(true); 2610 unlockAll_tempoary(true);
2607 return e_accessFile; 2611 return e_accessFile;
2608 } 2612 }
2609 2613
2610 char *entry[4]; 2614 char *entry[4];
2611 unsigned int numCat = numCategories(), i; 2615 unsigned int numCat = numCategories(), i;
2612 unsigned int numEntr, j; 2616 unsigned int numEntr, j;
2613 int descLen, nameLen, pwLen, commentLen; 2617 int descLen, nameLen, pwLen, commentLen;
2614 for (i = 0; i < numCat; ++i) { 2618 for (i = 0; i < numCat; ++i) {
2615 numEntr = numEntries(i); 2619 numEntr = numEntries(i);
2616 for (j = 0; j < numEntr; ++j) { 2620 for (j = 0; j < numEntr; ++j) {
2617 descLen = dta[i].d[j].desc.length(); 2621 descLen = dti.dta[i].d[j].desc.length();
2618 nameLen = dta[i].d[j].name.length(); 2622 nameLen = dti.dta[i].d[j].name.length();
2619 pwLen = dta[i].d[j].pw.length(); 2623 pwLen = dti.dta[i].d[j].pw.length();
2620 commentLen = dta[i].d[j].comment.length(); 2624 commentLen = dti.dta[i].d[j].comment.length();
2621 entry[0] = new char[descLen + 1]; 2625 entry[0] = new char[descLen + 1];
2622 entry[1] = new char[nameLen + 1]; 2626 entry[1] = new char[nameLen + 1];
2623 entry[2] = new char[pwLen + 1]; 2627 entry[2] = new char[pwLen + 1];
2624 entry[3] = new char[commentLen + 1]; 2628 entry[3] = new char[commentLen + 1];
2625 strcpy(entry[0], descLen == 0 ? " " : dta[i].d[j].desc.c_str()); 2629 strcpy(entry[0], descLen == 0 ? " " : dti.dta[i].d[j].desc.c_str());
2626 strcpy(entry[1], nameLen == 0 ? " " : dta[i].d[j].name.c_str()); 2630 strcpy(entry[1], nameLen == 0 ? " " : dti.dta[i].d[j].name.c_str());
2627 strcpy(entry[2], pwLen == 0 ? " " : dta[i].d[j].pw.c_str()); 2631 strcpy(entry[2], pwLen == 0 ? " " : dti.dta[i].d[j].pw.c_str());
2628 strcpy(entry[3], commentLen == 0 ? " " : dta[i].d[j].comment.c_str()); 2632 strcpy(entry[3], commentLen == 0 ? " " : dti.dta[i].d[j].comment.c_str());
2629 entry[0][descLen == 0 ? descLen + 1 : descLen] = '\0'; 2633 entry[0][descLen == 0 ? descLen + 1 : descLen] = '\0';
2630 entry[1][nameLen == 0 ? nameLen + 1 : nameLen] = '\0'; 2634 entry[1][nameLen == 0 ? nameLen + 1 : nameLen] = '\0';
2631 entry[2][pwLen == 0 ? pwLen + 1 : pwLen] = '\0'; 2635 entry[2][pwLen == 0 ? pwLen + 1 : pwLen] = '\0';
2632 entry[3][commentLen == 0 ? commentLen + 1 : commentLen] = '\0'; 2636 entry[3][commentLen == 0 ? commentLen + 1 : commentLen] = '\0';
2633 2637
2634 ret = gp.save_entry(entry); 2638 ret = gp.save_entry(entry);
2635 if (ret == -1){ 2639 if (ret == -1){
2636 delete [] entry[0]; 2640 delete [] entry[0];
2637 delete [] entry[1]; 2641 delete [] entry[1];
2638 delete [] entry[2]; 2642 delete [] entry[2];
2639 delete [] entry[3]; 2643 delete [] entry[3];
2640 gp.save_finalize(); 2644 gp.save_finalize();
2641 unlockAll_tempoary(true); 2645 unlockAll_tempoary(true);
2642 return e_writeFile; 2646 return e_writeFile;
2643 } 2647 }
2644 2648
2645 delete [] entry[0]; 2649 delete [] entry[0];
2646 delete [] entry[1]; 2650 delete [] entry[1];
2647 delete [] entry[2]; 2651 delete [] entry[2];
2648 delete [] entry[3]; 2652 delete [] entry[3];
2649 } 2653 }
2650 } 2654 }
2651 unlockAll_tempoary(true); 2655 unlockAll_tempoary(true);
2652 if (gp.save_finalize() == -1) 2656 if (gp.save_finalize() == -1)
@@ -2684,50 +2688,50 @@ PwMerror PwMDoc::importFromGpasman(const QString *file)
2684 for (i = 0; i < 4; ++i) 2688 for (i = 0; i < 4; ++i)
2685 free(entry[i]); 2689 free(entry[i]);
2686 if (ret2 == e_maxAllowedEntr) { 2690 if (ret2 == e_maxAllowedEntr) {
2687 gp.load_finalize(); 2691 gp.load_finalize();
2688 return e_maxAllowedEntr; 2692 return e_maxAllowedEntr;
2689 } 2693 }
2690 } while (1); 2694 } while (1);
2691 gp.load_finalize(); 2695 gp.load_finalize();
2692 if (isDocEmpty()) 2696 if (isDocEmpty())
2693 return e_wrongPw; // we assume this. 2697 return e_wrongPw; // we assume this.
2694 2698
2695 flagDirty(); 2699 flagDirty();
2696 return e_success; 2700 return e_success;
2697} 2701}
2698 2702
2699void PwMDoc::ensureLvp() 2703void PwMDoc::ensureLvp()
2700{ 2704{
2701 if (isDocEmpty()) 2705 if (isDocEmpty())
2702 return; 2706 return;
2703 2707
2704 vector< vector<PwMDataItem>::iterator > undefined; 2708 vector< vector<PwMDataItem>::iterator > undefined;
2705 vector< vector<PwMDataItem>::iterator >::iterator undefBegin, 2709 vector< vector<PwMDataItem>::iterator >::iterator undefBegin,
2706 undefEnd, 2710 undefEnd,
2707 undefI; 2711 undefI;
2708 vector<PwMCategoryItem>::iterator catBegin = dta.begin(), 2712 vector<PwMCategoryItem>::iterator catBegin = dti.dta.begin(),
2709 catEnd = dta.end(), 2713 catEnd = dti.dta.end(),
2710 catI = catBegin; 2714 catI = catBegin;
2711 vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI; 2715 vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
2712 int lvpTop, tmpLvp; 2716 int lvpTop, tmpLvp;
2713 2717
2714 while (catI != catEnd) { 2718 while (catI != catEnd) {
2715 lvpTop = -1; 2719 lvpTop = -1;
2716 undefined.clear(); 2720 undefined.clear();
2717 2721
2718 entrBegin = catI->d.begin(); 2722 entrBegin = catI->d.begin();
2719 entrEnd = catI->d.end(); 2723 entrEnd = catI->d.end();
2720 entrI = entrBegin; 2724 entrI = entrBegin;
2721 2725
2722 while (entrI != entrEnd) { 2726 while (entrI != entrEnd) {
2723 tmpLvp = entrI->listViewPos; 2727 tmpLvp = entrI->listViewPos;
2724 if (tmpLvp == -1) 2728 if (tmpLvp == -1)
2725 undefined.push_back(entrI); 2729 undefined.push_back(entrI);
2726 else if (tmpLvp > lvpTop) 2730 else if (tmpLvp > lvpTop)
2727 lvpTop = tmpLvp; 2731 lvpTop = tmpLvp;
2728 ++entrI; 2732 ++entrI;
2729 } 2733 }
2730 undefBegin = undefined.begin(); 2734 undefBegin = undefined.begin();
2731 undefEnd = undefined.end(); 2735 undefEnd = undefined.end();
2732 undefI = undefBegin; 2736 undefI = undefBegin;
2733 while (undefI != undefEnd) { 2737 while (undefI != undefEnd) {
@@ -2764,73 +2768,347 @@ bool PwMDoc::tryDelete()
2764 int ret; 2768 int ret;
2765 if (isDirty()) { 2769 if (isDirty()) {
2766 ret = dirtyAskSave(getTitle()); 2770 ret = dirtyAskSave(getTitle());
2767 if (ret == 0) { // save to disk 2771 if (ret == 0) { // save to disk
2768 if (!saveDocUi(this)) 2772 if (!saveDocUi(this))
2769 goto out_ignore; 2773 goto out_ignore;
2770 } else if (ret == 1) { // don't save and delete 2774 } else if (ret == 1) { // don't save and delete
2771 goto out_accept; 2775 goto out_accept;
2772 } else { // cancel operation 2776 } else { // cancel operation
2773 goto out_ignore; 2777 goto out_ignore;
2774 } 2778 }
2775 } 2779 }
2776out_accept: 2780out_accept:
2777 deleted = true; 2781 deleted = true;
2778 delete this; 2782 delete this;
2779 return true; 2783 return true;
2780out_ignore: 2784out_ignore:
2781 return false; 2785 return false;
2782} 2786}
2783 2787
2784 2788
2785 2789
2786#ifdef PWM_EMBEDDED 2790#ifdef PWM_EMBEDDED
2787//US ENH: this is the magic function that syncronizes the this doc with the remote doc 2791//US ENH: this is the magic function that syncronizes the this doc with the remote doc
2792//US it could have been defined as static, but I did not want to.
2788PwMerror PwMDoc::syncronize(KSyncManager* manager, PwMDoc* syncLocal , PwMDoc* syncRemote, int mode ) 2793PwMerror PwMDoc::syncronize(KSyncManager* manager, PwMDoc* syncLocal , PwMDoc* syncRemote, int mode )
2789{ 2794{
2790 bool syncOK = true;
2791 int addedPasswordsLocal = 0; 2795 int addedPasswordsLocal = 0;
2792 int addedPasswordsRemote = 0; 2796 int addedPasswordsRemote = 0;
2793 int deletedPasswordsRemote = 0; 2797 int deletedPasswordsRemote = 0;
2794 int deletedPasswordsLocal = 0; 2798 int deletedPasswordsLocal = 0;
2795 int changedLocal = 0; 2799 int changedLocal = 0;
2796 int changedRemote = 0; 2800 int changedRemote = 0;
2797 2801
2802 PwMSyncItem* syncItemLocal;
2803 PwMSyncItem* syncItemRemote;
2804
2798 QString mCurrentSyncName = manager->getCurrentSyncName(); 2805 QString mCurrentSyncName = manager->getCurrentSyncName();
2799 QString mCurrentSyncDevice = manager->getCurrentSyncDevice(); 2806 QString mCurrentSyncDevice = manager->getCurrentSyncDevice();
2800 2807
2808 bool fullDateRange = false;
2809 int take;
2810 // local->resetTempSyncStat();
2811 QDateTime mLastSync = QDateTime::currentDateTime();
2812 QDateTime modifiedSync = mLastSync;
2813
2814 unsigned int index;
2815 //Step 1. Find syncinfo in Local file and create if not existent.
2816 bool found = syncLocal->findSyncData(mCurrentSyncDevice, &index);
2817 if (found == false)
2818 {
2819 PwMSyncItem newSyncItemLocal;
2820 newSyncItemLocal.syncName = mCurrentSyncDevice;
2821 newSyncItemLocal.lastSyncDate = mLastSync;
2822 syncLocal->addSyncDataEntry(&newSyncItemLocal, true);
2823 found = syncLocal->findSyncData(mCurrentSyncDevice, &index);
2824 if (found == false) {
2825 qDebug("PwMDoc::syncronize : newly created local sync data could not be found");
2826 return e_syncError;
2827 }
2828 }
2829
2830 syncItemLocal = syncLocal->getSyncDataEntry(index);
2831 qDebug("Last Sync %s ", syncItemLocal->lastSyncDate.toString().latin1());
2832
2833 //Step 2. Find syncinfo in remote file and create if not existent.
2834 found = syncRemote->findSyncData(mCurrentSyncName, &index);
2835 if (found == false)
2836 {
2837 qDebug("FULLDATE 1");
2838 fullDateRange = true;
2839 PwMSyncItem newSyncItemRemote;
2840 newSyncItemRemote.syncName = mCurrentSyncName;
2841 newSyncItemRemote.lastSyncDate = mLastSync;
2842 syncRemote->addSyncDataEntry(&newSyncItemRemote, true);
2843 found = syncRemote->findSyncData(mCurrentSyncName, &index);
2844 if (found == false) {
2845 qDebug("PwMDoc::syncronize : newly created remote sync data could not be found");
2846 return e_syncError;
2847 }
2848 }
2849
2850 syncItemRemote = syncRemote->getSyncDataEntry(index);
2851 //and remove the found entry here. We will reenter it later again.
2852 syncRemote->delSyncDataEntry(index, true);
2801 2853
2802 2854
2855 if ( syncItemLocal->lastSyncDate == mLastSync ) {
2856 qDebug("FULLDATE 2");
2857 fullDateRange = true;
2858 }
2859
2860 if ( ! fullDateRange ) {
2861 if ( syncItemLocal->lastSyncDate != syncItemRemote->lastSyncDate ) {
2862
2863 // qDebug("set fulldate to true %s %s" ,addresseeLSync->dtStart().toString().latin1(), addresseeRSync->dtStart().toString().latin1() );
2864 //qDebug("%d %d %d %d ", addresseeLSync->dtStart().time().second(), addresseeLSync->dtStart().time().msec() , addresseeRSync->dtStart().time().second(), addresseeRSync->dtStart().time().msec());
2865 fullDateRange = true;
2866 qDebug("FULLDATE 3 %s %s", syncItemLocal->lastSyncDate.toString().latin1() , syncItemRemote->lastSyncDate.toString().latin1() );
2867 }
2868 }
2869 // fullDateRange = true; // debug only!
2870 if ( fullDateRange )
2871 mLastSync = QDateTime::currentDateTime().addDays( -100*365);
2872 else
2873 mLastSync = syncItemLocal->lastSyncDate;
2874
2875
2876 qDebug("*************************** ");
2877 // qDebug("mLastAddressbookSync %s ",mLastAddressbookSync.toString().latin1() );
2878 QStringList er = syncRemote->getIDEntryList();
2879 PwMDataItem* inRemote ;//= er.first();
2880 PwMDataItem* inLocal;
2881 unsigned int catLocal, indexLocal;
2882 unsigned int catRemote, indexRemote;
2883
2884 QString uid;
2885 manager->showProgressBar(0, i18n("Syncing - close to abort!"), er.count());
2886
2887 int modulo = (er.count()/10)+1;
2888 unsigned int incCounter = 0;
2889 while ( incCounter < er.count()) {
2890 if (manager->isProgressBarCanceled())
2891 return e_syncError;
2892 if ( incCounter % modulo == 0 )
2893 manager->showProgressBar(incCounter);
2894
2895 uid = er[ incCounter ];
2896 qApp->processEvents();
2897
2898 inLocal = syncLocal->findEntryByID( uid, &catLocal, &indexLocal );
2899 inRemote = syncRemote->findEntryByID( uid, &catRemote, &indexRemote );
2900 if ( inLocal != 0 ) { // maybe conflict - same uid in both files
2901 if ( (take = takePwMDataItem( inLocal, inRemote, mLastSync, mode, fullDateRange) ) ) {
2902 //qDebug("take %d %s ", take, inL.summary().latin1());
2903 if ( take == 3 )
2904 return e_syncError;
2905 if ( take == 1 ) {// take local
2906 //US syncRemote->removeAddressee( inRemote );
2907 (*inRemote) = (*inLocal);
2908 //US syncRemote->insertAddressee( inRemote , false);
2909 ++changedRemote;
2910 } else { // take == 2 take remote
2911 //US syncLocal->removeAddressee( inLocal );
2912 (*inLocal) = (*inRemote);
2913 //US syncLocal->insertAddressee( inLocal , false );
2914 ++changedLocal;
2915 }
2916 }
2917 } else { // no conflict
2918 if ( inRemote->meta.update > mLastSync || mode == 5 ) {
2919 inRemote->meta.update = modifiedSync;
2920 //US syncRemote->insertAddressee( inRemote, false );
2921 //US syncLocal->insertAddressee( inRemote, false );
2922 syncLocal->addEntry("newcategory", inRemote, true, false);
2923
2924 ++addedPasswordsLocal;
2925 } else {
2926 // pending checkExternSyncAddressee(addresseeRSyncSharp, inR);
2927 syncRemote->delEntry(catRemote, indexRemote, true);
2928 //USsyncRemote->removeAddressee( inRemote );
2929 ++deletedPasswordsRemote;
2930 }
2931 }
2932
2933 ++incCounter;
2934 }
2803 2935
2804 2936
2937 er.clear();
2938 QStringList el = syncLocal->getIDEntryList();
2939 modulo = (el.count()/10)+1;
2940
2941 manager->showProgressBar(0, i18n("Add / remove addressees"), el.count());
2942 incCounter = 0;
2943 while ( incCounter < el.count()) {
2944 qApp->processEvents();
2945 if (manager->isProgressBarCanceled())
2946 return e_syncError;
2947 if ( incCounter % modulo == 0 )
2948 manager->showProgressBar(incCounter);
2949 uid = el[ incCounter ];
2950
2951 inLocal = syncLocal->findEntryByID( uid, &catLocal, &indexLocal );
2952 inRemote = syncRemote->findEntryByID( uid, &catRemote, &indexRemote );
2953 if ( inRemote == 0 ) {
2954 if ( inLocal->meta.update < mLastSync && mode != 4 ) {
2955 // pending checkExternSyncAddressee(addresseeLSyncSharp, inL);
2956 syncLocal->delEntry(catLocal, indexLocal, true);
2957 //USsyncLocal->removeAddressee( inLocal );
2958 ++deletedPasswordsLocal;
2959 } else {
2960 if ( ! PWMPrefs::instance()->mWriteBackExistingOnly ) {
2961 ++addedPasswordsRemote;
2962 inLocal->meta.update = modifiedSync;
2963 //USsyncLocal->insertAddressee( inLocal, false );
2964 (*inRemote) = (*inLocal);
2965 //USsyncRemote->insertAddressee( inRemote, false );
2966 syncRemote->addEntry("newcategory", inRemote, true, false);
2967
2968 }
2969 }
2970
2971 }
2972 ++incCounter;
2973 }
2974 el.clear();
2975 manager->hideProgressBar();
2976
2977 // Now write the info back into the sync data space of the files
2805 2978
2979 mLastSync = QDateTime::currentDateTime().addSecs( 1 );
2980 // get rid of micro seconds
2981 QTime t = mLastSync.time();
2982 mLastSync.setTime( QTime (t.hour (), t.minute (), t.second () ) );
2806 2983
2984
2985 syncItemLocal->lastSyncDate = mLastSync;
2986 syncItemRemote->lastSyncDate = mLastSync;
2807 2987
2988 // addresseeRSync.setRole( i18n("!Remote from: ")+mCurrentSyncName ) ;
2989 // addresseeLSync.setRole(i18n("!Local from: ") + mCurrentSyncName );
2808 2990
2991 syncRemote->addSyncDataEntry( syncItemRemote, false );
2992 syncLocal->addSyncDataEntry( syncItemLocal, false );
2993 QString mes;
2994 mes .sprintf( i18n("Synchronization summary:\n\n %d items added to local\n %d items added to remote\n %d items updated on local\n %d items updated on remote\n %d items deleted on local\n %d items deleted on remote\n"),addedPasswordsLocal, addedPasswordsRemote, changedLocal, changedRemote, deletedPasswordsLocal, deletedPasswordsRemote );
2995 if ( PWMPrefs::instance()->mShowSyncSummary ) {
2996 KMessageBox::information(0, mes, i18n("PWM/Pi Synchronization") );
2997 }
2998 qDebug( mes );
2809 return e_success; 2999 return e_success;
2810} 3000}
2811 3001
2812 3002
3003int PwMDoc::takePwMDataItem( PwMDataItem* local, PwMDataItem* remote, QDateTime lastSync, int mode , bool full )
3004{
3005 // 0 equal
3006 // 1 take local
3007 // 2 take remote
3008 // 3 cancel
3009 QDateTime localMod = local->meta.update;
3010 QDateTime remoteMod = remote->meta.update;
3011
3012 //US QString mCurrentSyncDevice = syncManager->getCurrentSyncDevice();
3013
3014 if ( localMod == remoteMod )
3015 return 0;
3016
3017 qDebug(" %d %d conflict on %s %s ", mode, full, local->desc.c_str(), remote->desc.c_str() );
3018
3019 //qDebug("%s %d %s %d", local->lastModified().toString().latin1() , localMod, remote->lastModified().toString().latin1(), remoteMod);
3020 //qDebug("%d %d %d %d ", local->lastModified().time().second(), local->lastModified().time().msec(), remote->lastModified().time().second(), remote->lastModified().time().msec() );
3021 //full = true; //debug only
3022 if ( full ) {
3023 bool equ = true;//US ( (*local) == (*remote) );
3024 if ( equ ) {
3025 //qDebug("equal ");
3026 if ( mode < SYNC_PREF_FORCE_LOCAL )
3027 return 0;
3028
3029 }//else //debug only
3030 //qDebug("not equal %s %s ", local->summary().latin1(), remote->summary().latin1());
3031 }
3032
3033 int result;
3034 bool localIsNew;
3035 //qDebug("%s -- %s mLastCalendarSync %s lastsync %s --- local %s remote %s ",local->summary().latin1(), remote->summary().latin1(),mLastCalendarSync.toString().latin1() ,lastSync.toString().latin1() , local->lastModified().toString().latin1() , remote->lastModified().toString().latin1() );
3036
3037 if ( full && mode < SYNC_PREF_NEWEST )
3038 mode = SYNC_PREF_ASK;
3039
3040 switch( mode ) {
3041 case SYNC_PREF_LOCAL:
3042 if ( lastSync > remoteMod )
3043 return 1;
3044 if ( lastSync > localMod )
3045 return 2;
3046 return 1;
3047 break;
3048 case SYNC_PREF_REMOTE:
3049 if ( lastSync > remoteMod )
3050 return 1;
3051 if ( lastSync > localMod )
3052 return 2;
3053 return 2;
3054 break;
3055 case SYNC_PREF_NEWEST:
3056 if ( localMod > remoteMod )
3057 return 1;
3058 else
3059 return 2;
3060 break;
3061 case SYNC_PREF_ASK:
3062 //qDebug("lsy %s --- lo %s --- re %s ", lastSync.toString().latin1(), localMod.toString().latin1(), remoteMod.toString().latin1() );
3063 if ( lastSync > remoteMod )
3064 return 1;
3065 if ( lastSync > localMod )
3066 return 2;
3067 localIsNew = localMod >= remoteMod;
3068 //qDebug("conflict! ************************************** ");
3069 {
3070 PwMDataItemChooser acd ( *local,*remote, localIsNew , 0/*this*/ );
3071 result = acd.executeD(localIsNew);
3072 return result;
3073 }
3074 break;
3075 case SYNC_PREF_FORCE_LOCAL:
3076 return 1;
3077 break;
3078 case SYNC_PREF_FORCE_REMOTE:
3079 return 2;
3080 break;
3081
3082 default:
3083 // SYNC_PREF_TAKE_BOTH not implemented
3084 break;
3085 }
3086 return 0;
3087}
3088
3089
3090
2813 3091
2814//this are the overwritten callbackmethods from the syncinterface 3092//this are the overwritten callbackmethods from the syncinterface
2815bool PwMDoc::sync(KSyncManager* manager, QString filename, int mode) 3093bool PwMDoc::sync(KSyncManager* manager, QString filename, int mode)
2816{ 3094{
2817 QString mCurrentSyncDevice = manager->getCurrentSyncDevice(); 3095 QString mCurrentSyncDevice = manager->getCurrentSyncDevice();
2818 3096
2819 // construct on the stack = automatic cleanup. 3097 // construct on the stack = automatic cleanup.
2820 PwMDoc syncTarget(this, "synctarget"); 3098 PwMDoc syncTarget(this, "synctarget");
2821 3099
2822 PwMerror err = syncTarget.openDoc(&filename, 2 /*== deeplocked*/); 3100 PwMerror err = syncTarget.openDoc(&filename, 2 /*== deeplocked*/);
2823 3101
2824 if (err != e_success) 3102 if (err != e_success)
2825 return false; 3103 return false;
2826 3104
2827 qDebug("PWM file loaded %s,sync mode %d",filename.latin1(), mode ); 3105 qDebug("PWM file loaded %s,sync mode %d",filename.latin1(), mode );
2828 3106
2829 3107
2830 err = syncronize(manager, this, &syncTarget, mode ); 3108 err = syncronize(manager, this, &syncTarget, mode );
2831 3109
2832 if (err == e_success) { 3110 if (err == e_success) {
2833 if ( PWMPrefs::instance()->mWriteBackFile ){ 3111 if ( PWMPrefs::instance()->mWriteBackFile ){
2834 qDebug("Saving remote PWManager file"); 3112 qDebug("Saving remote PWManager file");
2835 err = syncTarget.saveDoc(conf()->confGlobCompression()); 3113 err = syncTarget.saveDoc(conf()->confGlobCompression());
2836 if (err != e_success) 3114 if (err != e_success)
@@ -2840,39 +3118,151 @@ bool PwMDoc::sync(KSyncManager* manager, QString filename, int mode)
2840 3118
2841 flagDirty(); 3119 flagDirty();
2842 return true; 3120 return true;
2843 } 3121 }
2844 else { 3122 else {
2845 return false; 3123 return false;
2846 } 3124 }
2847} 3125}
2848 3126
2849//called by the syncmanager to indicate that the work has to marked as dirty. 3127//called by the syncmanager to indicate that the work has to marked as dirty.
2850void PwMDoc::sync_setModified() 3128void PwMDoc::sync_setModified()
2851{ 3129{
2852 flagDirty(); 3130 flagDirty();
2853} 3131}
2854 3132
2855//called by the syncmanager to ask if the dirty flag is set. 3133//called by the syncmanager to ask if the dirty flag is set.
2856bool PwMDoc::sync_isModified() 3134bool PwMDoc::sync_isModified()
2857{ 3135{
2858 return isDirty(); 3136 return isDirty();
2859} 3137}
2860 3138
2861//called by the syncmanager to indicate that the work has to be saved. 3139//called by the syncmanager to indicate that the work has to be saved.
2862void PwMDoc::sync_save() 3140void PwMDoc::sync_save()
2863{ 3141{
2864 PwMerror ret = saveDoc(conf()->confGlobCompression()); 3142 saveDoc(conf()->confGlobCompression());
2865} 3143}
2866
2867#endif 3144#endif
2868 3145
2869 3146
3147bool PwMDoc::findSyncData(const QString &syncname, unsigned int *index)
3148{
3149 vector<PwMSyncItem>::iterator i = dti.syncDta.begin(),
3150 end = dti.syncDta.end();
3151
3152 while (i != end) {
3153 if ((*i).syncName == syncname.latin1()) {
3154 if (index) {
3155 *index = i - dti.syncDta.begin();
3156 }
3157 return true;
3158 }
3159 ++i;
3160 }
3161 return false;
3162};
3163
3164/** add new syncdataentry */
3165PwMerror PwMDoc::addSyncDataEntry(PwMSyncItem *d, bool dontFlagDirty)
3166{
3167 PWM_ASSERT(d);
3168
3169 if (isDeepLocked()) {
3170 PwMerror ret;
3171 ret = deepLock(false);
3172 if (ret != e_success)
3173 return e_lock;
3174 }
3175 unsigned int index;
3176
3177 const QString tmp = d->syncName.c_str();
3178 bool exists = findSyncData(d->syncName.c_str(), &index);
3179
3180 if (exists == true) {
3181 // DOH! We found this entry.
3182 return e_entryExists;
3183 }
3184
3185 dti.syncDta.push_back(*d);
3186
3187 if (!dontFlagDirty)
3188 flagDirty();
3189 return e_success;
3190}
3191
3192
2870 3193
3194/** delete syncdata entry */
3195bool PwMDoc::delSyncDataEntry(unsigned int index, bool dontFlagDirty)
3196{
3197 if (isDeepLocked())
3198 return false;
3199 if (index > dti.syncDta.size() - 1)
3200 return false;
3201
3202 // delete entry
3203 dti.syncDta.erase(dti.syncDta.begin() + index);
3204
3205 if (!dontFlagDirty)
3206 flagDirty();
3207 return true;
3208}
3209
3210
3211PwMDataItem* PwMDoc::findEntryByID(const QString &uid, unsigned int *category, unsigned int *index)
3212{
3213 vector<PwMCategoryItem>::iterator catcounter = dti.dta.begin(),
3214 catend = dti.dta.end();
3215
3216 vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
3217
3218 while (catcounter != catend) {
3219 entrBegin = catcounter->d.begin();
3220 entrEnd = catcounter->d.end();
3221 entrI = entrBegin;
3222 while (entrI != entrEnd) {
3223 if ((*entrI).meta.uniqueid == uid.latin1()) {
3224 if (category)
3225 *category = catcounter - dti.dta.begin();
3226 if (index)
3227 *index = entrI - entrBegin;
3228
3229 return &(*entrI);
3230 }
3231 ++entrI;
3232 }
3233 ++catcounter;
3234 }
3235
3236 return 0;
3237}
3238
3239QStringList PwMDoc::getIDEntryList()
3240{
3241 QStringList results;
3242
3243 vector<PwMCategoryItem>::iterator catcounter = dti.dta.begin(),
3244 catend = dti.dta.end();
3245
3246 vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
3247
3248 while (catcounter != catend) {
3249 entrBegin = catcounter->d.begin();
3250 entrEnd = catcounter->d.end();
3251 entrI = entrBegin;
3252 while (entrI != entrEnd) {
3253 results.append( (*entrI).meta.uniqueid );
3254 ++entrI;
3255 }
3256 ++catcounter;
3257 }
3258
3259 return results;
3260}
2871 3261
2872 3262
2873 3263
2874 3264
2875 3265
2876#ifndef PWM_EMBEDDED 3266#ifndef PWM_EMBEDDED
2877#include "pwmdoc.moc" 3267#include "pwmdoc.moc"
2878#endif 3268#endif
diff --git a/pwmanager/pwmanager/pwmdoc.h b/pwmanager/pwmanager/pwmdoc.h
index ea4d687..91277f6 100644
--- a/pwmanager/pwmanager/pwmdoc.h
+++ b/pwmanager/pwmanager/pwmdoc.h
@@ -185,64 +185,90 @@ struct PwMDataItem
185 /** data revision counter. This counter can be used 185 /** data revision counter. This counter can be used
186 * to easily, efficiently determine if this data item 186 * to easily, efficiently determine if this data item
187 * has changed since some time. 187 * has changed since some time.
188 * This counter is incremented on every update. 188 * This counter is incremented on every update.
189 */ 189 */
190 unsigned int rev; 190 unsigned int rev;
191 191
192 void clear(bool clearMeta = true) 192 void clear(bool clearMeta = true)
193 { 193 {
194 /* NOTE: Don't use .clear() here to be 194 /* NOTE: Don't use .clear() here to be
195 * backward compatible with gcc-2 (Debian Woody) 195 * backward compatible with gcc-2 (Debian Woody)
196 */ 196 */
197 desc = ""; 197 desc = "";
198 name = ""; 198 name = "";
199 pw = ""; 199 pw = "";
200 comment = ""; 200 comment = "";
201 url = ""; 201 url = "";
202 launcher = ""; 202 launcher = "";
203 lockStat = true; 203 lockStat = true;
204 listViewPos = -1; 204 listViewPos = -1;
205 binary = false; 205 binary = false;
206 if (clearMeta) 206 if (clearMeta)
207 meta.clear(); 207 meta.clear();
208 } 208 }
209
209}; 210};
210 211
211struct PwMCategoryItem 212struct PwMCategoryItem
212{ 213{
213 /** all PwMDataItems (all passwords) within this category */ 214 /** all PwMDataItems (all passwords) within this category */
214 vector<PwMDataItem>d; 215 vector<PwMDataItem>d;
215 /** category name/description */ 216 /** category name/description */
216 string name; 217 string name;
217 218
218 void clear() 219 void clear()
219 { 220 {
220 d.clear(); 221 d.clear();
221 name = ""; 222 name = "";
222 } 223 }
223}; 224};
224 225
226struct PwMSyncItem
227{
228 string syncName;
229 QDateTime lastSyncDate;
230
231 void clear()
232 {
233 lastSyncDate = QDateTime();
234 syncName = "";
235 }
236};
237
238struct PwMItem
239{
240 vector<PwMCategoryItem> dta;
241 vector<PwMSyncItem> syncDta;
242
243 void clear()
244 {
245 dta.clear();
246 syncDta.clear();
247 }
248};
249
250
225/** "Function Object" for sort()ing PwMDataItem::listViewPos */ 251/** "Function Object" for sort()ing PwMDataItem::listViewPos */
226class dta_lvp_greater 252class dta_lvp_greater
227{ 253{
228public: 254public:
229 bool operator() (const pair<unsigned int, unsigned int> &d1, 255 bool operator() (const pair<unsigned int, unsigned int> &d1,
230 const pair<unsigned int, unsigned int> &d2) 256 const pair<unsigned int, unsigned int> &d2)
231 { 257 {
232 return d1.second > d2.second; 258 return d1.second > d2.second;
233 } 259 }
234}; 260};
235 261
236/** list of PwMDoc documents and it's IDs */ 262/** list of PwMDoc documents and it's IDs */
237class PwMDocList 263class PwMDocList
238{ 264{
239public: 265public:
240 struct listItem 266 struct listItem
241 { 267 {
242 /** document filename (known as ID, here) */ 268 /** document filename (known as ID, here) */
243 string docId; 269 string docId;
244 /** pointer to the document class */ 270 /** pointer to the document class */
245 PwMDoc *doc; 271 PwMDoc *doc;
246 }; 272 };
247 273
248 PwMDocList() {} 274 PwMDocList() {}
@@ -419,81 +445,82 @@ public:
419 unsigned int index, PwMDataItem *d, bool updateMeta = true); 445 unsigned int index, PwMDataItem *d, bool updateMeta = true);
420 /** finds the category with the "name" and return it's index */ 446 /** finds the category with the "name" and return it's index */
421 bool findCategory(const QString &name, unsigned int *index); 447 bool findCategory(const QString &name, unsigned int *index);
422 /** search for an entry "find" and check while searching only for 448 /** search for an entry "find" and check while searching only for
423 * the data-fields specified by "searchIn". To set the "searchIn" 449 * the data-fields specified by "searchIn". To set the "searchIn"
424 * value, we may use one or more of the SEARCH_IN_* defines at 450 * value, we may use one or more of the SEARCH_IN_* defines at
425 * the top of this header-file. It returns the positions of all 451 * the top of this header-file. It returns the positions of all
426 * matched entries in "foundPositions". If "breakAfterFound" is true, 452 * matched entries in "foundPositions". If "breakAfterFound" is true,
427 * the function terminates after the first occurence of the entry 453 * the function terminates after the first occurence of the entry
428 * and doesn't go on searching. So foundPositions->size() is never 454 * and doesn't go on searching. So foundPositions->size() is never
429 * > 1 if breakAfterFound is true. 455 * > 1 if breakAfterFound is true.
430 */ 456 */
431 void findEntry(unsigned int category, PwMDataItem find, unsigned int searchIn, 457 void findEntry(unsigned int category, PwMDataItem find, unsigned int searchIn,
432 vector<unsigned int> *foundPositions, bool breakAfterFound = false, 458 vector<unsigned int> *foundPositions, bool breakAfterFound = false,
433 bool caseSensitive = true, bool exactWordMatch = true, 459 bool caseSensitive = true, bool exactWordMatch = true,
434 bool sortByLvp = false); 460 bool sortByLvp = false);
435 /** see the above funtion. This function allows to set the category by name. */ 461 /** see the above funtion. This function allows to set the category by name. */
436 void findEntry(const QString &category, PwMDataItem find, unsigned int searchIn, 462 void findEntry(const QString &category, PwMDataItem find, unsigned int searchIn,
437 vector<unsigned int> *foundPositions, bool breakAfterFound = false, 463 vector<unsigned int> *foundPositions, bool breakAfterFound = false,
438 bool caseSensitive = true, bool exactWordMatch = true, 464 bool caseSensitive = true, bool exactWordMatch = true,
439 bool sortByLvp = false); 465 bool sortByLvp = false);
440 /** returns number of entries */ 466 /** returns number of entries */
441 unsigned int numEntries(const QString &category); 467 unsigned int numEntries(const QString &category);
442 unsigned int numEntries(unsigned int category) 468 unsigned int numEntries(unsigned int category)
443 { return dta[category].d.size(); } 469 { return dti.dta[category].d.size(); }
444 /** returns number of categories */ 470 /** returns number of categories */
445 unsigned int numCategories() 471 unsigned int numCategories()
446 { return dta.size(); } 472 { return dti.dta.size(); }
447 /** returns the name of the category at "index" */ 473 /** returns the name of the category at "index" */
448 const string* getCategory(unsigned int index) 474 const string* getCategory(unsigned int index)
449 { return (&(dta[index].name)); } 475 { return (&(dti.dta[index].name)); }
476
450 /** returns the data of item at "index". 477 /** returns the data of item at "index".
451 * It unlocks the entry if it's locked and unlockIfLocked is true. 478 * It unlocks the entry if it's locked and unlockIfLocked is true.
452 * If the entry is locked, but unlockIfLocked is false, it'll not return 479 * If the entry is locked, but unlockIfLocked is false, it'll not return
453 * the pw. 480 * the pw.
454 */ 481 */
455 bool getEntry(const QString &category, unsigned int index, 482 bool getEntry(const QString &category, unsigned int index,
456 PwMDataItem *d, bool unlockIfLocked = false); 483 PwMDataItem *d, bool unlockIfLocked = false);
457 bool getEntry(unsigned int category, unsigned int index, 484 bool getEntry(unsigned int category, unsigned int index,
458 PwMDataItem *d, bool unlockIfLocked = false); 485 PwMDataItem *d, bool unlockIfLocked = false);
459 /** returns the comment-string by looking at the category 486 /** returns the comment-string by looking at the category
460 * and the listViewPos 487 * and the listViewPos
461 */ 488 */
462 PwMerror getCommentByLvp(const QString &category, int listViewPos, 489 PwMerror getCommentByLvp(const QString &category, int listViewPos,
463 string *foundComment); 490 string *foundComment);
464 /** checks if a password is already available. (currentPw) */ 491 /** checks if a password is already available. (currentPw) */
465 bool isPwAvailable() 492 bool isPwAvailable()
466 { return (currentPw != ""); } 493 { return (currentPw != ""); }
467 /** un/lock entry at "index". If needed, ask for password. */ 494 /** un/lock entry at "index". If needed, ask for password. */
468 bool lockAt(const QString &category, unsigned int index, 495 bool lockAt(const QString &category, unsigned int index,
469 bool lock = true); 496 bool lock = true);
470 bool lockAt(unsigned int category, unsigned int index, 497 bool lockAt(unsigned int category, unsigned int index,
471 bool lock = true); 498 bool lock = true);
472 /** returns the lock-status at "index" */ 499 /** returns the lock-status at "index" */
473 bool isLocked(const QString &category, unsigned int index); 500 bool isLocked(const QString &category, unsigned int index);
474 bool isLocked(unsigned int category, unsigned int index) 501 bool isLocked(unsigned int category, unsigned int index)
475 { return dta[category].d[index].lockStat; } 502 { return dti.dta[category].d[index].lockStat; }
476 /** returns the deeplock status */ 503 /** returns the deeplock status */
477 bool isDeepLocked() 504 bool isDeepLocked()
478 { return getDocStatFlag(DOC_STAT_DEEPLOCKED); } 505 { return getDocStatFlag(DOC_STAT_DEEPLOCKED); }
479 /** (un)lock all entries */ 506 /** (un)lock all entries */
480 bool lockAll(bool lock); 507 bool lockAll(bool lock);
481 /** unlocks all entries tempoarly. 508 /** unlocks all entries tempoarly.
482 * 1st NOTE: Be very careful with this function! :) 509 * 1st NOTE: Be very careful with this function! :)
483 * 2nd NOTE: After you have called unlockAll_Tempoary(); , 510 * 2nd NOTE: After you have called unlockAll_Tempoary(); ,
484 * please DON'T forget to call unlockAll_Tempoary(true); 511 * please DON'T forget to call unlockAll_Tempoary(true);
485 * _before_ the user (or someone else) is able to change 512 * _before_ the user (or someone else) is able to change
486 * the document! 513 * the document!
487 * 3rd NOTE: Please DON'T change "dta" while the data is tempoary 514 * 3rd NOTE: Please DON'T change "dta" while the data is tempoary
488 * unlocked! This will cause corruption. 515 * unlocked! This will cause corruption.
489 */ 516 */
490 bool unlockAll_tempoary(bool revert = false); 517 bool unlockAll_tempoary(bool revert = false);
491 /** deep-(un)locks the document. 518 /** deep-(un)locks the document.
492 * deep-locking writes all data to the file, deletes all data 519 * deep-locking writes all data to the file, deletes all data
493 * in memory, but doesn't close the document. 520 * in memory, but doesn't close the document.
494 * deep-locking is only available, if the user previously saved 521 * deep-locking is only available, if the user previously saved
495 * the doc to a file (with a password). 522 * the doc to a file (with a password).
496 * If "saveToFile" is false, it does NOT write the data to the file! 523 * If "saveToFile" is false, it does NOT write the data to the file!
497 */ 524 */
498 PwMerror deepLock(bool lock = true, bool saveToFile = true); 525 PwMerror deepLock(bool lock = true, bool saveToFile = true);
499 /** is unlockable without pw? */ 526 /** is unlockable without pw? */
@@ -553,89 +580,91 @@ public:
553 /** returns the list-view-pointer */ 580 /** returns the list-view-pointer */
554 PwMView * getListViewPointer() 581 PwMView * getListViewPointer()
555 { return listView; } 582 { return listView; }
556 /** try to delete the doc. The user may be asked to save 583 /** try to delete the doc. The user may be asked to save
557 * the data. The user may cancel the whole operation. 584 * the data. The user may cancel the whole operation.
558 * false is returned, then. 585 * false is returned, then.
559 */ 586 */
560 bool tryDelete(); 587 bool tryDelete();
561 /** is the doc deleted? (with tryDelete() ) */ 588 /** is the doc deleted? (with tryDelete() ) */
562 bool isDeleted() 589 bool isDeleted()
563 { return deleted; } 590 { return deleted; }
564 /** returns the document timer object */ 591 /** returns the document timer object */
565 DocTimer * timer() 592 DocTimer * timer()
566 { return _timer; } 593 { return _timer; }
567 /** get a lock on the dataChanged signal. 594 /** get a lock on the dataChanged signal.
568 * If someone is holding a lock, the signal is not emitted. 595 * If someone is holding a lock, the signal is not emitted.
569 */ 596 */
570 void getDataChangedLock() 597 void getDataChangedLock()
571 { ++dataChangedLock; } 598 { ++dataChangedLock; }
572 /** put the dataChanged lock */ 599 /** put the dataChanged lock */
573 void putDataChangedLock() 600 void putDataChangedLock()
574 { --dataChangedLock; } 601 { --dataChangedLock; }
575 /** returns the revision count of the item at cat/index */ 602 /** returns the revision count of the item at cat/index */
576 unsigned int getEntryRevCnt(unsigned int category, unsigned int index) 603 unsigned int getEntryRevCnt(unsigned int category, unsigned int index)
577 { return dta[category].d[index].rev; } 604 { return dti.dta[category].d[index].rev; }
578 /** returns a const pointer to the entries meta */ 605 /** returns a const pointer to the entries meta */
579 const PwMMetaData * getEntryMeta(unsigned int category, unsigned int index) 606 const PwMMetaData * getEntryMeta(unsigned int category, unsigned int index)
580 { return &(dta[category].d[index].meta); } 607 { return &(dti.dta[category].d[index].meta); }
581 /** is the entry at "category" "index" a binary entry? */ 608 /** is the entry at "category" "index" a binary entry? */
582 bool isBinEntry(unsigned int category, unsigned int index) 609 bool isBinEntry(unsigned int category, unsigned int index)
583 { return dta[category].d[index].binary; } 610 { return dti.dta[category].d[index].binary; }
584 611
585public slots: 612public slots:
586 /** wrapper for PwMTray */ 613 /** wrapper for PwMTray */
587 void _deepUnlock(); 614 void _deepUnlock();
588 615
589signals: 616signals:
590 /** the data of the document has changed and must be updated 617 /** the data of the document has changed and must be updated
591 * in all views. 618 * in all views.
592 * NOTE: use emitDataChanged(PwMDoc *document) to emit this signal! 619 * NOTE: use emitDataChanged(PwMDoc *document) to emit this signal!
593 */ 620 */
594 void dataChanged(PwMDoc *document); 621 void dataChanged(PwMDoc *document);
595 /** the document class is going to close. This signal may be 622 /** the document class is going to close. This signal may be
596 * used to nofify all views, that the user closed the document, 623 * used to nofify all views, that the user closed the document,
597 * so the views can go down, too. 624 * so the views can go down, too.
598 */ 625 */
599 void docClosed(PwMDoc *document); 626 void docClosed(PwMDoc *document);
600 /** somebody just opened the document */ 627 /** somebody just opened the document */
601 void docOpened(PwMDoc *document); 628 void docOpened(PwMDoc *document);
602 /** this document object just got created */ 629 /** this document object just got created */
603 void docCreated(PwMDoc *document); 630 void docCreated(PwMDoc *document);
604 631
605public: 632public:
606 /** emit the dataChanged signal after checking for a lock */ 633 /** emit the dataChanged signal after checking for a lock */
607 void emitDataChanged(PwMDoc *document) 634 void emitDataChanged(PwMDoc *document)
608 { 635 {
609 if (!dataChangedLock) 636 if (!dataChangedLock)
610 emit dataChanged(document); 637 emit dataChanged(document);
611 } 638 }
612 639
613protected: 640protected:
614 /** current file for this doc */ 641 /** current file for this doc */
615 QString filename; 642 QString filename;
643//US ENH: we need a place where we keep the syncentries. So I invented
644// struct PwMItem, that has a vector of PwMCategoryItem and vector of PwMSyncItem
616 /** holds all data */ 645 /** holds all data */
617 vector<PwMCategoryItem> dta; 646 PwMItem dti;
618 /** maximum number of entries */ 647 /** maximum number of entries */
619 unsigned int maxEntries; 648 unsigned int maxEntries;
620 /** currently used password to encrypt data */ 649 /** currently used password to encrypt data */
621 QString currentPw; 650 QString currentPw;
622 /** current global document status flags */ 651 /** current global document status flags */
623 unsigned int curDocStat; 652 unsigned int curDocStat;
624 /** browser process for goToURL() */ 653 /** browser process for goToURL() */
625 KProcess browserProc; 654 KProcess browserProc;
626 /** pointer to the list-view, using this document. 655 /** pointer to the list-view, using this document.
627 * As there can only be one list-view per doc, we 656 * As there can only be one list-view per doc, we
628 * don't need a list here. 657 * don't need a list here.
629 */ 658 */
630 PwMView *listView; 659 PwMView *listView;
631 /** unnamedNum is used to store the "unnamed counter" 660 /** unnamedNum is used to store the "unnamed counter"
632 * for this document, while it's unnamed. If it's 0, 661 * for this document, while it's unnamed. If it's 0,
633 * we have to get a new unique one. 662 * we have to get a new unique one.
634 */ 663 */
635 unsigned int unnamedNum; 664 unsigned int unnamedNum;
636 /** is this doc going to be deleted (executing in destructor context) */ 665 /** is this doc going to be deleted (executing in destructor context) */
637 bool deleted; 666 bool deleted;
638 /** document timer */ 667 /** document timer */
639 DocTimer *_timer; 668 DocTimer *_timer;
640 /** lock counter for the "dataChanged" signal */ 669 /** lock counter for the "dataChanged" signal */
641 unsigned int dataChangedLock; 670 unsigned int dataChangedLock;
@@ -686,39 +715,64 @@ protected:
686 { curDocStat |= statFlag; } 715 { curDocStat |= statFlag; }
687 /** unset a document status flag */ 716 /** unset a document status flag */
688 void unsetDocStatFlag(unsigned int statFlag) 717 void unsetDocStatFlag(unsigned int statFlag)
689 { curDocStat &= ~statFlag; } 718 { curDocStat &= ~statFlag; }
690 /** get a document status flag */ 719 /** get a document status flag */
691 bool getDocStatFlag(unsigned int statFlag) const 720 bool getDocStatFlag(unsigned int statFlag) const
692 { return (curDocStat & statFlag); } 721 { return (curDocStat & statFlag); }
693 /** set the "currentPassword" */ 722 /** set the "currentPassword" */
694 void setCurrentPw(const QString &pw) 723 void setCurrentPw(const QString &pw)
695 { 724 {
696 currentPw = pw; 725 currentPw = pw;
697 setDocStatFlag(DOC_STAT_DISK_DIRTY); 726 setDocStatFlag(DOC_STAT_DISK_DIRTY);
698 } 727 }
699 /** make a backup-copy of the given file */ 728 /** make a backup-copy of the given file */
700 bool backupFile(const QString &filePath); 729 bool backupFile(const QString &filePath);
701 /** copy a file from src to dst */ 730 /** copy a file from src to dst */
702 bool copyFile(const QString &src, const QString &dst); 731 bool copyFile(const QString &src, const QString &dst);
703 732
704 733
705 public: 734 public:
706#ifdef PWM_EMBEDDED 735#ifdef PWM_EMBEDDED
707 //US ENH: this is the magic function that syncronizes the local doc with the remote doc. 736 //US ENH: this is the magic function that syncronizes the local doc with the remote doc.
708 PwMerror syncronize(KSyncManager* manager, PwMDoc* syncLocal, PwMDoc* syncRemote, int mode ); 737 PwMerror syncronize(KSyncManager* manager, PwMDoc* syncLocal, PwMDoc* syncRemote, int mode );
709 738
739 //takePwMDataItem returns the following values
740 // 0 equal
741 // 1 take local
742 // 2 take remote
743 // 3 cancel
744 int takePwMDataItem( PwMDataItem* local, PwMDataItem* remote, QDateTime lastSync, int mode , bool full );
710 745
711 //the following methods are the overwritten callbackmethods from the syncinterface 746 //the following methods are the overwritten callbackmethods from the syncinterface
712 virtual bool sync(KSyncManager* manager, QString filename, int mode); 747 virtual bool sync(KSyncManager* manager, QString filename, int mode);
713 748
714 //called by the syncmanager to indicate that the work has to be marked as dirty. 749 //called by the syncmanager to indicate that the work has to be marked as dirty.
715 virtual void sync_setModified(); 750 virtual void sync_setModified();
716 //called by the syncmanager to ask if the dirty flag is set. 751 //called by the syncmanager to ask if the dirty flag is set.
717 virtual bool sync_isModified(); 752 virtual bool sync_isModified();
718 //called by the syncmanager to indicate that the work has to be saved. 753 //called by the syncmanager to indicate that the work has to be saved.
719 virtual void sync_save(); 754 virtual void sync_save();
755
720#endif 756#endif
757 private:
758 //US ENH: helpermethods to access the sync data for a certain syncname.
759 // It returns the syncdatas index
760 bool findSyncData(const QString &syncname, unsigned int *index);
761
762 /** add new syncdataentry */
763 PwMerror addSyncDataEntry(PwMSyncItem *d, bool dontFlagDirty = false);
764
765 /** returns a pointer to the syncdata */
766 PwMSyncItem* getSyncDataEntry(unsigned int index)
767 { return &(dti.syncDta[index]); }
768
769 /** delete entry */
770 bool delSyncDataEntry(unsigned int index, bool dontFlagDirty = false);
771
772 PwMDataItem* findEntryByID(const QString &uid, unsigned int *category, unsigned int *index);
773
774 QStringList getIDEntryList();
721 775
722}; 776};
723 777
724#endif 778#endif
diff --git a/pwmanager/pwmanager/pwmdocui.cpp b/pwmanager/pwmanager/pwmdocui.cpp
index 5e675fc..41afa6a 100644
--- a/pwmanager/pwmanager/pwmdocui.cpp
+++ b/pwmanager/pwmanager/pwmdocui.cpp
@@ -255,49 +255,49 @@ bool PwMDocUi::saveDocUi(PwMDoc *doc)
255 i18n("nothing to do")); 255 i18n("nothing to do"));
256 doc->timer()->putLock(DocTimer::id_autoLockTimer); 256 doc->timer()->putLock(DocTimer::id_autoLockTimer);
257 return true; 257 return true;
258 } 258 }
259 PwMerror ret = doc->saveDoc(conf()->confGlobCompression()); 259 PwMerror ret = doc->saveDoc(conf()->confGlobCompression());
260 if (ret == e_filename) { 260 if (ret == e_filename) {
261 doc->timer()->putLock(DocTimer::id_autoLockTimer); 261 doc->timer()->putLock(DocTimer::id_autoLockTimer);
262 return saveAsDocUi(doc); 262 return saveAsDocUi(doc);
263 } else if (ret == e_weakPw) { 263 } else if (ret == e_weakPw) {
264 KMessageBox::error(currentView, 264 KMessageBox::error(currentView,
265 i18n("Error: This is a weak password.\n" 265 i18n("Error: This is a weak password.\n"
266 "Please select another password."), 266 "Please select another password."),
267 i18n("weak password")); 267 i18n("weak password"));
268 doc->timer()->putLock(DocTimer::id_autoLockTimer); 268 doc->timer()->putLock(DocTimer::id_autoLockTimer);
269 return false; 269 return false;
270 } else if (ret == e_fileBackup) { 270 } else if (ret == e_fileBackup) {
271 KMessageBox::error(currentView, 271 KMessageBox::error(currentView,
272 i18n("Error: Couldn't make backup-file!"), 272 i18n("Error: Couldn't make backup-file!"),
273 i18n("backup failed")); 273 i18n("backup failed"));
274 doc->timer()->putLock(DocTimer::id_autoLockTimer); 274 doc->timer()->putLock(DocTimer::id_autoLockTimer);
275 return false; 275 return false;
276 } else if (ret != e_success) { 276 } else if (ret != e_success) {
277 KMessageBox::error(currentView, 277 KMessageBox::error(currentView,
278 i18n("Error: Couldn't write to file.\n" 278 i18n("Error: Couldn't write to file.\n"
279 "Please check if you have permission to " 279 "Please check if you have permission to\n"
280 "write to the file in that directory."), 280 "write to the file in that directory."),
281 i18n("error while writing")); 281 i18n("error while writing"));
282 doc->timer()->putLock(DocTimer::id_autoLockTimer); 282 doc->timer()->putLock(DocTimer::id_autoLockTimer);
283 return false; 283 return false;
284 } 284 }
285 doc->timer()->putLock(DocTimer::id_autoLockTimer); 285 doc->timer()->putLock(DocTimer::id_autoLockTimer);
286 return true; 286 return true;
287} 287}
288 288
289bool PwMDocUi::saveAsDocUi(PwMDoc *doc) 289bool PwMDocUi::saveAsDocUi(PwMDoc *doc)
290{ 290{
291 PWM_ASSERT(doc); 291 PWM_ASSERT(doc);
292 doc->timer()->getLock(DocTimer::id_autoLockTimer); 292 doc->timer()->getLock(DocTimer::id_autoLockTimer);
293 if (doc->isDocEmpty()) { 293 if (doc->isDocEmpty()) {
294 KMessageBox::information(currentView, 294 KMessageBox::information(currentView,
295 i18n 295 i18n
296 ("Sorry, there's nothing to save.\n" 296 ("Sorry, there's nothing to save.\n"
297 "Please first add some passwords."), 297 "Please first add some passwords."),
298 i18n("nothing to do")); 298 i18n("nothing to do"));
299 doc->timer()->putLock(DocTimer::id_autoLockTimer); 299 doc->timer()->putLock(DocTimer::id_autoLockTimer);
300 return true; 300 return true;
301 } 301 }
302#ifndef PWM_EMBEDDED 302#ifndef PWM_EMBEDDED
303 QString fn(KFileDialog::getSaveFileName(QString::null, 303 QString fn(KFileDialog::getSaveFileName(QString::null,
diff --git a/pwmanager/pwmanager/pwmexception.h b/pwmanager/pwmanager/pwmexception.h
index c8a8c0f..301ebd7 100644
--- a/pwmanager/pwmanager/pwmexception.h
+++ b/pwmanager/pwmanager/pwmexception.h
@@ -138,48 +138,49 @@ enum PwMerror {
138 e_weakPw, 138 e_weakPw,
139 e_noPw, 139 e_noPw,
140 140
141 // action not implemented errors 141 // action not implemented errors
142 e_hashNotImpl, 142 e_hashNotImpl,
143 e_cryptNotImpl, 143 e_cryptNotImpl,
144 144
145 // argument/parameter errors 145 // argument/parameter errors
146 e_incompleteArg, 146 e_incompleteArg,
147 e_invalidArg, 147 e_invalidArg,
148 148
149 // misc 149 // misc
150 e_writeHeader, 150 e_writeHeader,
151 e_serializeDta, 151 e_serializeDta,
152 e_enc, 152 e_enc,
153 e_entryExists, 153 e_entryExists,
154 e_categoryExists, 154 e_categoryExists,
155 e_maxAllowedEntr,// no more entries can be added. 155 e_maxAllowedEntr,// no more entries can be added.
156 e_outOfMem, 156 e_outOfMem,
157 e_lock, // error while (un)locking 157 e_lock, // error while (un)locking
158 e_docNotSaved, // doc wasn't saved to a file, yet. 158 e_docNotSaved, // doc wasn't saved to a file, yet.
159 e_docIsEmpty, 159 e_docIsEmpty,
160 e_binEntry, 160 e_binEntry,
161 e_normalEntry, 161 e_normalEntry,
162 e_syncError,
162 163
163 e_generic 164 e_generic
164}; 165};
165 166
166/** can be used for general exception faults */ 167/** can be used for general exception faults */
167class PwMException 168class PwMException
168{ 169{
169public: 170public:
170 enum exceptionId 171 enum exceptionId
171 { 172 {
172 EX_GENERIC = 0, 173 EX_GENERIC = 0,
173 EX_OPEN, 174 EX_OPEN,
174 EX_CLOSE, 175 EX_CLOSE,
175 EX_READ, 176 EX_READ,
176 EX_WRITE, 177 EX_WRITE,
177 EX_LOAD_MODULE, 178 EX_LOAD_MODULE,
178 EX_PARSE 179 EX_PARSE
179 }; 180 };
180 181
181public: 182public:
182 PwMException(exceptionId id = EX_GENERIC, 183 PwMException(exceptionId id = EX_GENERIC,
183 const char *message = "") 184 const char *message = "")
184 { 185 {
185 exId = id; 186 exId = id;
diff --git a/pwmanager/pwmanager/pwmview.cpp b/pwmanager/pwmanager/pwmview.cpp
index d192119..e23ce25 100644
--- a/pwmanager/pwmanager/pwmview.cpp
+++ b/pwmanager/pwmanager/pwmview.cpp
@@ -14,48 +14,49 @@
14 * This file is originaly based on version 1.0.1 of pwmanager 14 * This file is originaly based on version 1.0.1 of pwmanager
15 * and was modified to run on embedded devices that run microkde 15 * and was modified to run on embedded devices that run microkde
16 * 16 *
17 * $Id$ 17 * $Id$
18 **************************************************************************/ 18 **************************************************************************/
19 19
20#include "pwmview.h" 20#include "pwmview.h"
21#include "pwmexception.h" 21#include "pwmexception.h"
22#include "globalstuff.h" 22#include "globalstuff.h"
23#include "pwm.h" 23#include "pwm.h"
24#include "rencatwnd.h" 24#include "rencatwnd.h"
25#ifndef PWM_EMBEDDED 25#ifndef PWM_EMBEDDED
26#include "configuration.h" 26#include "configuration.h"
27#else 27#else
28#include "pwmprefs.h" 28#include "pwmprefs.h"
29#endif 29#endif
30#include "commentbox.h" 30#include "commentbox.h"
31 31
32#include <kmessagebox.h> 32#include <kmessagebox.h>
33#include <klocale.h> 33#include <klocale.h>
34 34
35#include <qlineedit.h> 35#include <qlineedit.h>
36#include <qpoint.h> 36#include <qpoint.h>
37#include <qapplication.h> 37#include <qapplication.h>
38#include <qlayout.h>
38 39
39//US ENH: wouldn't it be a good idea if we could use this consts everywhere else. 40//US ENH: wouldn't it be a good idea if we could use this consts everywhere else.
40//US ENH: for examle in listviewpwm.cpp 41//US ENH: for examle in listviewpwm.cpp
41//US ENH: Because of that I transfer them into the headerfile. 42//US ENH: Because of that I transfer them into the headerfile.
42/* 43/*
43 #define COLUMN_DESC 0 44 #define COLUMN_DESC 0
44 #define COLUMN_NAME 1 45 #define COLUMN_NAME 1
45 #define COLUMN_PW 2 46 #define COLUMN_PW 2
46 #define COLUMN_URL 3 47 #define COLUMN_URL 3
47 #define COLUMN_LAUNCHER 4 48 #define COLUMN_LAUNCHER 4
48*/ 49*/
49 50
50PwMView::PwMView(PwM *_mainClass, 51PwMView::PwMView(PwM *_mainClass,
51 QWidget *parent, PwMDoc *_doc, 52 QWidget *parent, PwMDoc *_doc,
52 const char *name) 53 const char *name)
53 : PwMViewStyle(parent, name) 54 : PwMViewStyle(parent, name)
54{ 55{
55 PWM_ASSERT(_mainClass); 56 PWM_ASSERT(_mainClass);
56 PWM_ASSERT(parent); 57 PWM_ASSERT(parent);
57 PWM_ASSERT(_doc); 58 PWM_ASSERT(_doc);
58 setView(this); 59 setView(this);
59 doc = _doc; 60 doc = _doc;
60 doc->setListViewPointer(this); 61 doc->setListViewPointer(this);
61 mainClass = _mainClass; 62 mainClass = _mainClass;
@@ -434,27 +435,90 @@ void PwMView::copyUrlToClip()
434void PwMView::copyLauncherToClip() 435void PwMView::copyLauncherToClip()
435{ 436{
436 if (doc->isDeepLocked()) 437 if (doc->isDeepLocked())
437 return; 438 return;
438 unsigned int curIndex = 0; 439 unsigned int curIndex = 0;
439 if (!getCurEntryIndex(&curIndex)) 440 if (!getCurEntryIndex(&curIndex))
440 return; 441 return;
441 PwMDataItem d; 442 PwMDataItem d;
442 document()->getEntry(getCurrentCategory(), curIndex, &d); 443 document()->getEntry(getCurrentCategory(), curIndex, &d);
443 PwM::copyToClipboard(d.launcher.c_str()); 444 PwM::copyToClipboard(d.launcher.c_str());
444} 445}
445 446
446void PwMView::copyCommentToClip() 447void PwMView::copyCommentToClip()
447{ 448{
448 if (doc->isDeepLocked()) 449 if (doc->isDeepLocked())
449 return; 450 return;
450 unsigned int curIndex = 0; 451 unsigned int curIndex = 0;
451 if (!getCurEntryIndex(&curIndex)) 452 if (!getCurEntryIndex(&curIndex))
452 return; 453 return;
453 PwMDataItem d; 454 PwMDataItem d;
454 document()->getEntry(getCurrentCategory(), curIndex, &d); 455 document()->getEntry(getCurrentCategory(), curIndex, &d);
455 PwM::copyToClipboard(d.comment.c_str()); 456 PwM::copyToClipboard(d.comment.c_str());
456} 457}
457 458
459
460
461
462PwMDataItemChooser::PwMDataItemChooser( PwMDataItem loc, PwMDataItem rem, bool takeloc, QWidget *parent, const char *name ) : KDialogBase(parent,name,
463 true ,i18n("Conflict! Please choose Entry!"),Ok|User1|Close,Close, false)
464{
465 findButton( Close )->setText( i18n("Cancel Sync"));
466 findButton( Ok )->setText( i18n("Remote"));
467 findButton( User1 )->setText( i18n("Local"));
468 QWidget* topframe = new QWidget( this );
469 setMainWidget( topframe );
470 QBoxLayout* bl;
471 if ( QApplication::desktop()->width() < 640 ) {
472 bl = new QVBoxLayout( topframe );
473 } else {
474 bl = new QHBoxLayout( topframe );
475 }
476 QVBox* subframe = new QVBox( topframe );
477 bl->addWidget(subframe );
478 QLabel* lab = new QLabel( i18n("Local Entry"), subframe );
479 if ( takeloc )
480 lab->setBackgroundColor(Qt::green.light() );
481 // AddresseeView * av = new AddresseeView( subframe );
482 // av->setAddressee( loc );
483 subframe = new QVBox( topframe );
484 bl->addWidget(subframe );
485 lab = new QLabel( i18n("Remote Entry"), subframe );
486 if ( !takeloc )
487 lab->setBackgroundColor(Qt::green.light() );
488 // av = new AddresseeView( subframe );
489 // av->setAddressee( rem );
490 QObject::connect(findButton( Ok ),SIGNAL(clicked()),this, SLOT(slot_remote()));
491 QObject::connect(this,SIGNAL(user1Clicked()),this, SLOT(slot_local()));
492#ifndef DESKTOP_VERSION
493 showMaximized();
494#else
495 resize ( 640, 400 );
496#endif
497}
498
499int PwMDataItemChooser::executeD( bool local )
500{
501 mSyncResult = 3;
502 if ( local )
503 findButton( User1 )->setFocus();
504 else
505 findButton( Ok )->setFocus();
506 exec();
507 return mSyncResult;
508}
509void PwMDataItemChooser::slot_remote()
510{
511 mSyncResult = 2;
512 accept();
513}
514void PwMDataItemChooser::slot_local()
515{
516 mSyncResult = 1;
517 accept();
518}
519
520
521
458#ifndef PWM_EMBEDDED 522#ifndef PWM_EMBEDDED
459#include "pwmview.moc" 523#include "pwmview.moc"
460#endif 524#endif
diff --git a/pwmanager/pwmanager/pwmview.h b/pwmanager/pwmanager/pwmview.h
index 5a326d3..75cce51 100644
--- a/pwmanager/pwmanager/pwmview.h
+++ b/pwmanager/pwmanager/pwmview.h
@@ -15,48 +15,49 @@
15 * and was modified to run on embedded devices that run microkde 15 * and was modified to run on embedded devices that run microkde
16 * 16 *
17 * $Id$ 17 * $Id$
18 **************************************************************************/ 18 **************************************************************************/
19 19
20#ifndef PWMVIEW_H 20#ifndef PWMVIEW_H
21#define PWMVIEW_H 21#define PWMVIEW_H
22 22
23//US ENH: wouldn't it be a good idea if we could use this consts everywhere else. 23//US ENH: wouldn't it be a good idea if we could use this consts everywhere else.
24//US ENH: for examle in listviewpwm.cpp 24//US ENH: for examle in listviewpwm.cpp
25//US ENH: Because of that I transfer them into the headerfile. 25//US ENH: Because of that I transfer them into the headerfile.
26 #define COLUMN_DESC 0 26 #define COLUMN_DESC 0
27 #define COLUMN_NAME 1 27 #define COLUMN_NAME 1
28 #define COLUMN_PW 2 28 #define COLUMN_PW 2
29 #define COLUMN_URL 3 29 #define COLUMN_URL 3
30 #define COLUMN_LAUNCHER 4 30 #define COLUMN_LAUNCHER 4
31 31
32 32
33#include "listviewpwm.h" 33#include "listviewpwm.h"
34#include "pwmdoc.h" 34#include "pwmdoc.h"
35#include "pwmviewstyle.h" 35#include "pwmviewstyle.h"
36 36
37#include <kconfig.h> 37#include <kconfig.h>
38#include <klocale.h> 38#include <klocale.h>
39#include <kdialogbase.h>
39 40
40#include <qevent.h> 41#include <qevent.h>
41#include <qfont.h> 42#include <qfont.h>
42#include <qobject.h> 43#include <qobject.h>
43 44
44#include <vector> 45#include <vector>
45#include <string> 46#include <string>
46 47
47using std::string; 48using std::string;
48using std::vector; 49using std::vector;
49 50
50class PwM; 51class PwM;
51class ConfFile; 52class ConfFile;
52class PwMStatusBar; 53class PwMStatusBar;
53 54
54 55
55/** View class for PwM */ 56/** View class for PwM */
56class PwMView : public PwMViewStyle 57class PwMView : public PwMViewStyle
57{ 58{
58 Q_OBJECT 59 Q_OBJECT
59 friend class PwMViewStyle; 60 friend class PwMViewStyle;
60public: 61public:
61 /** construtor */ 62 /** construtor */
62 PwMView(PwM *_mainClass, QWidget* parent, PwMDoc *_doc, 63 PwMView(PwM *_mainClass, QWidget* parent, PwMDoc *_doc,
@@ -126,25 +127,46 @@ protected slots:
126 /** copy pw to clipboard */ 127 /** copy pw to clipboard */
127 void copyPwToClip(); 128 void copyPwToClip();
128 /** copy name to clipboard */ 129 /** copy name to clipboard */
129 void copyNameToClip(); 130 void copyNameToClip();
130 /** copy desc to clipboard */ 131 /** copy desc to clipboard */
131 void copyDescToClip(); 132 void copyDescToClip();
132 /** copy url to clipboard */ 133 /** copy url to clipboard */
133 void copyUrlToClip(); 134 void copyUrlToClip();
134 /** copy launcher to clipboard */ 135 /** copy launcher to clipboard */
135 void copyLauncherToClip(); 136 void copyLauncherToClip();
136 /** copy comment to clipboard */ 137 /** copy comment to clipboard */
137 void copyCommentToClip(); 138 void copyCommentToClip();
138 /** reorganize the "listViewPos" positions in the document 139 /** reorganize the "listViewPos" positions in the document
139 * (for the current category only!) 140 * (for the current category only!)
140 */ 141 */
141 void reorgLp(); 142 void reorgLp();
142 143
143private: 144private:
144 /** document */ 145 /** document */
145 PwMDoc *doc; 146 PwMDoc *doc;
146 /** pointer to the main class "PwM" */ 147 /** pointer to the main class "PwM" */
147 PwM *mainClass; 148 PwM *mainClass;
148}; 149};
149 150
151
152//US ENH we need this chooser when syncing results in a conflict
153class PwMDataItemChooser : public KDialogBase
154{
155 Q_OBJECT
156
157 public:
158 PwMDataItemChooser( PwMDataItem loc, PwMDataItem rem, bool takeloc, QWidget *parent = 0, const char *name = 0 );
159
160 int executeD( bool local );
161
162 private:
163 int mSyncResult;
164
165 private slots:
166 void slot_remote();
167 void slot_local();
168
169};
170
171
150#endif 172#endif
diff --git a/pwmanager/pwmanager/serializer.cpp b/pwmanager/pwmanager/serializer.cpp
index a54ba8a..f615082 100644
--- a/pwmanager/pwmanager/serializer.cpp
+++ b/pwmanager/pwmanager/serializer.cpp
@@ -20,48 +20,52 @@
20 20
21#include "serializer.h" 21#include "serializer.h"
22#include "pwmexception.h" 22#include "pwmexception.h"
23 23
24#ifdef PWM_EMBEDDED 24#ifdef PWM_EMBEDDED
25#include <kglobal.h> 25#include <kglobal.h>
26#include <klocale.h> 26#include <klocale.h>
27#endif 27#endif
28 28
29/* enable/disable serializer debugging (0/1) */ 29/* enable/disable serializer debugging (0/1) */
30 #define SERIALIZER_DEBUG1 30 #define SERIALIZER_DEBUG1
31/* use the old xml tags for writing (0/1) */ 31/* use the old xml tags for writing (0/1) */
32 #define USE_OLD_TAGS 0 32 #define USE_OLD_TAGS 0
33/* write a CDATA section (0/1) */ 33/* write a CDATA section (0/1) */
34 #define WRITE_CDATA_SEC 0 34 #define WRITE_CDATA_SEC 0
35 35
36 36
37 #define META_CREATE_DATE"c" 37 #define META_CREATE_DATE"c"
38 #define META_VALID_DATE "v" 38 #define META_VALID_DATE "v"
39 #define META_EXPIRE_DATE"e" 39 #define META_EXPIRE_DATE"e"
40 #define META_UPDATE_DATE"u" 40 #define META_UPDATE_DATE"u"
41 #define META_UPDATE_INT "i" 41 #define META_UPDATE_INT "i"
42//US ENH : uniqueid 42//US ENH : uniqueid
43#define META_UNIQUEID "n" 43#define META_UNIQUEID "n"
44#define SYNC_ROOT "s"
45#define SYNC_TARGET_PREFIX "t"
46#define SYNC_TARGET_NAME "n"
47
44 48
45/* This is compatibility stuff. 49/* This is compatibility stuff.
46 * The names of the entries have changed and here are the 50 * The names of the entries have changed and here are the
47 * new and old ones 51 * new and old ones
48 */ 52 */
49 #define ROOT_MAGIC_OLD "PwM-xml-dat" 53 #define ROOT_MAGIC_OLD "PwM-xml-dat"
50 #define VER_STR_OLD "ver" 54 #define VER_STR_OLD "ver"
51 #define COMPAT_VER_OLD "0x02" 55 #define COMPAT_VER_OLD "0x02"
52 #define CAT_ROOT_OLD "categories" 56 #define CAT_ROOT_OLD "categories"
53 #define CAT_PREFIX_OLD "cat_" 57 #define CAT_PREFIX_OLD "cat_"
54 #define CAT_NAME_OLD "name" 58 #define CAT_NAME_OLD "name"
55 #define ENTRY_PREFIX_OLD"entry_" 59 #define ENTRY_PREFIX_OLD"entry_"
56 #define ENTRY_DESC_OLD "desc" 60 #define ENTRY_DESC_OLD "desc"
57 #define ENTRY_NAME_OLD "name" 61 #define ENTRY_NAME_OLD "name"
58 #define ENTRY_PW_OLD "pw" 62 #define ENTRY_PW_OLD "pw"
59 #define ENTRY_COMMENT_OLD"comment" 63 #define ENTRY_COMMENT_OLD"comment"
60 #define ENTRY_URL_OLD "url" 64 #define ENTRY_URL_OLD "url"
61 #define ENTRY_LAUNCHER_OLD"launcher" 65 #define ENTRY_LAUNCHER_OLD"launcher"
62 #define ENTRY_LVP_OLD "listViewPos" 66 #define ENTRY_LVP_OLD "listViewPos"
63 #define ENTRY_BIN_OLD "b" 67 #define ENTRY_BIN_OLD "b"
64 #define ENTRY_META_OLD "m" 68 #define ENTRY_META_OLD "m"
65 69
66 #define ROOT_MAGIC_NEW "P" 70 #define ROOT_MAGIC_NEW "P"
67 #define VER_STR_NEW "v" 71 #define VER_STR_NEW "v"
@@ -185,83 +189,95 @@ QCString Serializer::getXml()
185 cout << tmp << endl; 189 cout << tmp << endl;
186 printDebug("<END Serializer::getXml() dump>"); 190 printDebug("<END Serializer::getXml() dump>");
187#endif // DEBUG 191#endif // DEBUG
188 192
189 QCString ret(domDoc->toCString(0)); 193 QCString ret(domDoc->toCString(0));
190 ret.replace('\n', ""); 194 ret.replace('\n', "");
191 return ret; 195 return ret;
192#else 196#else
193 197
194#if defined(PWM_DEBUG) && SERIALIZER_DEBUG != 0 198#if defined(PWM_DEBUG) && SERIALIZER_DEBUG != 0
195 QCString tmp(" " + domDoc->toCString()); 199 QCString tmp(" " + domDoc->toCString());
196 printDebug("<BEGIN Serializer::getXml() dump>\n"); 200 printDebug("<BEGIN Serializer::getXml() dump>\n");
197 qDebug(tmp); 201 qDebug(tmp);
198 cout << tmp << endl; 202 cout << tmp << endl;
199 printDebug("<END Serializer::getXml() dump>"); 203 printDebug("<END Serializer::getXml() dump>");
200#endif // DEBUG 204#endif // DEBUG
201 205
202 QCString ret(domDoc->toCString()); 206 QCString ret(domDoc->toCString());
203 ret.replace(QRegExp("\n"), ""); 207 ret.replace(QRegExp("\n"), "");
204 return ret; 208 return ret;
205 209
206#endif 210#endif
207} 211}
208 212
209bool Serializer::serialize(const vector<PwMCategoryItem> &dta) 213bool Serializer::serialize(PwMItem &dta)
210{ 214{
211 PWM_ASSERT(domDoc); 215 PWM_ASSERT(domDoc);
212 QDomElement root(genNewRoot()); 216 QDomElement root(genNewRoot());
213 QDomElement catNode(domDoc->createElement(CAT_ROOT_WR)); 217 QDomElement catNode(domDoc->createElement(CAT_ROOT_WR));
214 root.appendChild(catNode); 218 QDomElement syncNode(domDoc->createElement(SYNC_ROOT));
215 if (!addCategories(&catNode, dta)) 219 if (!addSyncData(&syncNode, dta.syncDta))
216 return false; 220 return false;
221 root.appendChild(syncNode);
222 if (!addCategories(&catNode, dta.dta))
223 return false;
224 root.appendChild(catNode);
217 return true; 225 return true;
218} 226}
219 227
220bool Serializer::deSerialize(vector<PwMCategoryItem> *dta) 228bool Serializer::deSerialize(PwMItem *dta)
221{ 229{
222 PWM_ASSERT(domDoc); 230 PWM_ASSERT(domDoc);
223 PWM_ASSERT(dta); 231 PWM_ASSERT(dta);
224 QDomElement root(domDoc->documentElement()); 232 QDomElement root(domDoc->documentElement());
225 QDomNode n; 233 QDomNode n;
226 234
227 dta->clear(); 235 dta->clear();
228 for (n = root.firstChild(); !n.isNull(); n = n.nextSibling()) { 236 for (n = root.firstChild(); !n.isNull(); n = n.nextSibling()) {
229 // find <categories> ... </categories> 237 // find <categories> ... </categories>
230 // <c> ... </c> 238 // <c> ... </c>
231 if (n.nodeName() == CAT_ROOT_NEW || 239 if (n.nodeName() == CAT_ROOT_NEW ||
232 n.nodeName() == CAT_ROOT_OLD) { 240 n.nodeName() == CAT_ROOT_OLD) {
233 if (!readCategories(n, dta)) { 241 if (!readCategories(n, &(dta->dta))) {
234 return false; 242 return false;
235 } 243 }
244 continue;
245 }
246 else if (n.nodeName() == SYNC_ROOT) {
247 if (!readSyncData(n, &(dta->syncDta))) {
248 return false;
249 }
250 continue;
251 }
236 252
237 /* NOTE: We can stop processing here, as we 253 /* NOTE: We can stop processing here, as we
238 * don't have more nodes in root, yet. 254 * don't have more nodes in root, yet.
239 */ 255 */
240 return true; 256 return false;
241 } 257
242 } 258 }
243 return false; 259 return true;
244} 260}
245 261
246bool Serializer::readCategories(const QDomNode &n, 262bool Serializer::readCategories(const QDomNode &n,
247 vector<PwMCategoryItem> *dta) 263 vector<PwMCategoryItem> *dta)
248{ 264{
249 QDomNodeList nl(n.childNodes()); 265 QDomNodeList nl(n.childNodes());
250 QDomNode cur; 266 QDomNode cur;
251 QString name; 267 QString name;
252 unsigned int numCat = nl.count(), i; 268 unsigned int numCat = nl.count(), i;
253 PwMCategoryItem curCat; 269 PwMCategoryItem curCat;
254 vector<PwMDataItem> curEntr; 270 vector<PwMDataItem> curEntr;
255 271
256 if (!numCat) { 272 if (!numCat) {
257 printDebug("Serializer::readCategories(): empty"); 273 printDebug("Serializer::readCategories(): empty");
258 return false; 274 return false;
259 } 275 }
260 for (i = 0; i < numCat; ++i) { 276 for (i = 0; i < numCat; ++i) {
261 cur = nl.item(i); 277 cur = nl.item(i);
262 if (cur.nodeName().left(1) == CAT_PREFIX_NEW || 278 if (cur.nodeName().left(1) == CAT_PREFIX_NEW ||
263 cur.nodeName().left(4) == CAT_PREFIX_OLD) { 279 cur.nodeName().left(4) == CAT_PREFIX_OLD) {
264 name = cur.toElement().attribute(CAT_NAME_NEW); 280 name = cur.toElement().attribute(CAT_NAME_NEW);
265 if (name == QString::null) 281 if (name == QString::null)
266 name = cur.toElement().attribute(CAT_NAME_OLD); 282 name = cur.toElement().attribute(CAT_NAME_OLD);
267 PWM_ASSERT(name != QString::null); 283 PWM_ASSERT(name != QString::null);
@@ -640,24 +656,101 @@ bool Serializer::writeMeta(QDomElement *e,
640 656
641QString Serializer::escapeEntryData(QString dta) 657QString Serializer::escapeEntryData(QString dta)
642{ 658{
643#ifndef PWM_EMBEDDED 659#ifndef PWM_EMBEDDED
644 dta.replace('\n', "$>--endl--<$"); 660 dta.replace('\n', "$>--endl--<$");
645 dta.replace("]]>", "||>"); 661 dta.replace("]]>", "||>");
646#else 662#else
647 dta.replace(QRegExp("\n"), "$>--endl--<$"); 663 dta.replace(QRegExp("\n"), "$>--endl--<$");
648 dta.replace(QRegExp("]]>"), "||>"); 664 dta.replace(QRegExp("]]>"), "||>");
649#endif 665#endif
650 return dta; 666 return dta;
651} 667}
652 668
653QString Serializer::unescapeEntryData(QString dta) 669QString Serializer::unescapeEntryData(QString dta)
654{ 670{
655#ifndef PWM_EMBEDDED 671#ifndef PWM_EMBEDDED
656 dta.replace("$>--endl--<$", "\n"); 672 dta.replace("$>--endl--<$", "\n");
657 dta.replace("||>", "]]>"); 673 dta.replace("||>", "]]>");
658#else 674#else
659 dta.replace(QRegExp("$>--endl--<$"), "\n"); 675 dta.replace(QRegExp("$>--endl--<$"), "\n");
660 dta.replace(QRegExp("||>"), "]]>"); 676 dta.replace(QRegExp("||>"), "]]>");
661#endif 677#endif
662 return dta; 678 return dta;
663} 679}
680
681
682//US ENH: the following methods are getting used to write/read sync entries
683/** read the syncentries in the node "n" */
684bool Serializer::readSyncData(const QDomNode &n, vector<PwMSyncItem> *dta)
685{
686 QDomNodeList nl(n.childNodes());
687 QDomNode cur;
688
689 QString devicename, val;
690 unsigned int numSync = nl.count(), i;
691 PwMSyncItem curSync;
692 bool ok = true;
693
694 if (!numSync) {
695 //no sync entries is a possible result
696 printDebug("Serializer::readSyncData(): empty");
697 return true;
698 }
699 for (i = 0; i < numSync; ++i) {
700 cur = nl.item(i);
701 if (cur.nodeName().left(1) == SYNC_TARGET_PREFIX) {
702 devicename = cur.toElement().attribute(SYNC_TARGET_NAME);
703 val = cur.toElement().text();
704
705 if ((val == "") || (devicename == QString::null)) {
706 printDebug("Serializer::readSyncData(): empty synctarget name or syncdate");
707 continue;
708 }
709
710 curSync.syncName = devicename;
711#ifndef PWM_EMBEDDED
712 curSync.lastSyncDate = QDateTime::fromString(val, Qt::ISODate);
713#else
714 curSync.lastSyncDate = KGlobal::locale()->readDateTime(val, KLocale::ISODate, &ok);
715 if (ok == false)
716 qDebug("Serializer::readSyncData(): could not parse syncdate:%s",val.latin1());
717
718#endif
719 dta->push_back(curSync);
720 }
721 }
722 return true;
723
724}
725
726
727
728bool Serializer::addSyncData(QDomElement *e,
729 const vector<PwMSyncItem> &dta)
730{
731 unsigned int numSync = dta.size(), i;
732 QString curId, curDeviceName;
733 QDomElement curSync, curSyncDate;
734 QDomText text;
735
736 for (i = 0; i < numSync; ++i) {
737 curId = SYNC_TARGET_PREFIX;
738 curId += tostr(i).c_str();
739 curDeviceName = dta[i].syncName.c_str();
740 curSync = domDoc->createElement(curId);
741 curSync.setAttribute(SYNC_TARGET_NAME, curDeviceName);
742
743#ifndef PWM_EMBEDDED
744 text = domDoc->createTextNode(dta[i].lastSyncDate.toString(Qt::ISODate));
745#else
746 text = domDoc->createTextNode(KGlobal::locale()->formatDateTime(dta[i].lastSyncDate, KLocale::ISODate));
747#endif
748 curSyncDate.appendChild(text);
749 curSync.appendChild(curSyncDate);
750
751 e->appendChild(curSync);
752
753 }
754 return true;
755}
756
diff --git a/pwmanager/pwmanager/serializer.h b/pwmanager/pwmanager/serializer.h
index 245fcee..ee61b94 100644
--- a/pwmanager/pwmanager/serializer.h
+++ b/pwmanager/pwmanager/serializer.h
@@ -30,73 +30,86 @@
30 30
31using std::vector; 31using std::vector;
32 32
33/** This serializes its input data into 33/** This serializes its input data into
34 * the PwManager-XML-datastream, that becomes 34 * the PwManager-XML-datastream, that becomes
35 * encrypted and maybe compressed 35 * encrypted and maybe compressed
36 */ 36 */
37class Serializer 37class Serializer
38{ 38{
39public: 39public:
40 /** construct an empty serializer document */ 40 /** construct an empty serializer document */
41 Serializer(); 41 Serializer();
42 /** construct a serializer document and parse "buffer" */ 42 /** construct a serializer document and parse "buffer" */
43 Serializer(const QCString &buffer); 43 Serializer(const QCString &buffer);
44 /** destructor */ 44 /** destructor */
45 virtual ~Serializer(); 45 virtual ~Serializer();
46 46
47 /** clears all data */ 47 /** clears all data */
48 void clear(); 48 void clear();
49 /** parse the given data buffer */ 49 /** parse the given data buffer */
50 bool parseXml(const QCString &buffer); 50 bool parseXml(const QCString &buffer);
51 /** returns the current XML data */ 51 /** returns the current XML data */
52 QCString getXml(); 52 QCString getXml();
53 /** serialize "dta" and store it as XML data */ 53 /** serialize "dta" and store it as XML data */
54 bool serialize(const vector<PwMCategoryItem> &dta); 54 //US ENH: we need to serialize and deserialize not only categories, but also synctargets
55 bool serialize(PwMItem &dta);
55 /** deserialize the (parsed) XML data and store it in "dta" */ 56 /** deserialize the (parsed) XML data and store it in "dta" */
56 bool deSerialize(vector<PwMCategoryItem> *dta); 57 bool deSerialize(PwMItem *dta);
57 /** sets the initial default lockStat we should assign */ 58 /** sets the initial default lockStat we should assign */
58 void setDefaultLockStat(bool stat) 59 void setDefaultLockStat(bool stat)
59 { defaultLockStat = stat; } 60 { defaultLockStat = stat; }
60 61
61protected: 62protected:
62 /** main data holder */ 63 /** main data holder */
63 QDomDocument *domDoc; 64 QDomDocument *domDoc;
64 /** default lockStat to assign */ 65 /** default lockStat to assign */
65 bool defaultLockStat; 66 bool defaultLockStat;
66 67
67protected: 68protected:
68 /** check if this is valid PwManager XML data */ 69 /** check if this is valid PwManager XML data */
69 bool checkValid(); 70 bool checkValid();
70 /** read the categories in the node "n" */ 71 /** read the categories in the node "n" */
71 bool readCategories(const QDomNode &n, 72 bool readCategories(const QDomNode &n,
72 vector<PwMCategoryItem> *dta); 73 vector<PwMCategoryItem> *dta);
73 /** read the entries in the node "n" */ 74 /** read the entries in the node "n" */
74 bool readEntries(const QDomNode &n, 75 bool readEntries(const QDomNode &n,
75 vector<PwMDataItem> *dta); 76 vector<PwMDataItem> *dta);
76 /** extract the data out of the given item at "n" */ 77 /** extract the data out of the given item at "n" */
77 bool extractEntry(const QDomNode &n, 78 bool extractEntry(const QDomNode &n,
78 PwMDataItem *dta); 79 PwMDataItem *dta);
79 /** extract the meta-data */ 80 /** extract the meta-data */
80 bool extractMeta(const QDomNode &n, 81 bool extractMeta(const QDomNode &n,
81 PwMMetaData *dta); 82 PwMMetaData *dta);
82 /** generates a new root node and sets all initial parameters */ 83 /** generates a new root node and sets all initial parameters */
83 QDomElement genNewRoot(); 84 QDomElement genNewRoot();
84 /** add new categories to the XML data stream in e */ 85 /** add new categories to the XML data stream in e */
85 bool addCategories(QDomElement *e, 86 bool addCategories(QDomElement *e,
86 const vector<PwMCategoryItem> &dta); 87 const vector<PwMCategoryItem> &dta);
87 /** add the given new entries to the XML data stream in e */ 88 /** add the given new entries to the XML data stream in e */
88 bool addEntries(QDomElement *e, 89 bool addEntries(QDomElement *e,
89 const vector<PwMDataItem> &dta); 90 const vector<PwMDataItem> &dta);
90 /** do serialize and write the given entry to the XML stream */ 91 /** do serialize and write the given entry to the XML stream */
91 bool writeEntry(QDomElement *e, 92 bool writeEntry(QDomElement *e,
92 const PwMDataItem &_dta); 93 const PwMDataItem &_dta);
93 /** write the entry meta data to the xml stream */ 94 /** write the entry meta data to the xml stream */
94 bool writeMeta(QDomElement *e, 95 bool writeMeta(QDomElement *e,
95 const PwMMetaData &dta); 96 const PwMMetaData &dta);
96 /** escape illegal characters out of the given entry data string */ 97 /** escape illegal characters out of the given entry data string */
97 QString escapeEntryData(QString dta); 98 QString escapeEntryData(QString dta);
98 /** un-escape illegal characters out of the given entry data string */ 99 /** un-escape illegal characters out of the given entry data string */
99 QString unescapeEntryData(QString dta); 100 QString unescapeEntryData(QString dta);
101
102
103
104 //US ENH: the following methods are getting used to write/read sync entries
105 /** read the syncentries in the node "n" */
106 bool readSyncData(const QDomNode &n,
107 vector<PwMSyncItem> *dta);
108
109 /** add new syncentries to the XML data stream in e */
110 bool addSyncData(QDomElement *e,
111 const vector<PwMSyncItem> &dta);
112
100}; 113};
101 114
102#endif // __SERIALIZER_H 115#endif // __SERIALIZER_H