2 files changed, 25 insertions, 1 deletions
diff --git a/pwmanager/pwmanager/pwmdoc.cpp b/pwmanager/pwmanager/pwmdoc.cpp
index ddbf4f2..17cb74a 100644
--- a/pwmanager/pwmanager/pwmdoc.cpp
+++ b/pwmanager/pwmanager/pwmdoc.cpp
@@ -1264,2241 +1264,2261 @@ PwMerror PwMDoc::getCommentByLvp(const QString &category, int listViewPos,
 }
 bool PwMDoc::compressDta(string *d, char algo)
 {
        PWM_ASSERT(d);
        switch (algo) {
                case PWM_COMPRESS_GZIP: {
                        CompressGzip comp;
                        return comp.compress(d);
                }
 #ifndef PWM_EMBEDDED 
                case PWM_COMPRESS_BZIP2: {
                        CompressBzip2 comp;
                        return comp.compress(d);
                }
 #endif
                case PWM_COMPRESS_NONE: {
                        return true;
                } default: {
                        BUG();
                }
        }
        return false;
 }
 bool PwMDoc::decompressDta(string *d, char algo)
 {
        PWM_ASSERT(d);
        switch (algo) {
                case PWM_COMPRESS_GZIP: {
                        CompressGzip comp;
                        return comp.decompress(d);
                }
 #ifndef PWM_EMBEDDED 
                case PWM_COMPRESS_BZIP2: {
                        CompressBzip2 comp;
                        return comp.decompress(d);
                }
 #endif
                case PWM_COMPRESS_NONE: {
                        return true;
                }
        }
        return false;
 }
 PwMerror PwMDoc::encrypt(string *d, const QString *pw, QFile *f, char algo)
 {
        PWM_ASSERT(d);
        PWM_ASSERT(pw);
        PWM_ASSERT(f);
        size_t encSize;
        byte *encrypted = 0;
        switch (algo) {
        case PWM_CRYPT_BLOWFISH: {
                Blowfish::padNull(d);
                encSize = d->length();
                encrypted = new byte[encSize];
                Blowfish bf;
                if (bf.bf_setkey((byte *) pw->latin1(), pw->length())) {
                        delete [] encrypted;
                        return e_weakPw;
                }
                bf.bf_encrypt((byte *) encrypted, (byte *) d->c_str(), encSize);
                break;
        }
        case PWM_CRYPT_AES128:
                /*... fall through */
        case PWM_CRYPT_AES192:
        case PWM_CRYPT_AES256:
        case PWM_CRYPT_3DES:
        case PWM_CRYPT_TWOFISH:
        case PWM_CRYPT_TWOFISH128: {
                if (!LibGCryptIf::available())
                        return e_cryptNotImpl;
                LibGCryptIf gc;
                PwMerror err;
                unsigned char *plain = new unsigned char[d->length() + 1024];
                memcpy(plain, d->c_str(), d->length());
                err = gc.encrypt(&encrypted,
                                 &encSize,
                                 plain,
                                 d->length(),
                                 reinterpret_cast<const unsigned char *>(pw->latin1()),
                                 pw->length(),
                                 algo);
                delete [] plain;
                if (err != e_success)
                        return e_cryptNotImpl;
                break;
        }
        default: {
                delete_ifnot_null_array(encrypted);
                return e_cryptNotImpl;
        } }
        // write encrypted data to file
        if (f->writeBlock(reinterpret_cast<const char *>(encrypted),
                          static_cast<Q_ULONG>(encSize))
            != static_cast<Q_LONG>(encSize)) {
                delete_ifnot_null_array(encrypted);
                return e_writeFile;
        }
        delete_ifnot_null_array(encrypted);
        return e_success;
 }
 PwMerror PwMDoc::decrypt(string *d, unsigned int pos, const QString *pw,
                         char algo, QFile *f)
 {
        PWM_ASSERT(d);
        PWM_ASSERT(pw);
        PWM_ASSERT(f);
        unsigned int cryptLen = f->size() - pos;
        byte *encrypted = new byte[cryptLen];
        byte *decrypted = new byte[cryptLen];
        f->at(pos);
 #ifndef PWM_EMBEDDED
        if (f->readBlock(reinterpret_cast<char *>(encrypted),
                         static_cast<Q_ULONG>(cryptLen))
            != static_cast<Q_LONG>(cryptLen)) {
                delete [] encrypted;
                delete [] decrypted;
                return e_readFile;
        }
 #else
        if (f->readBlock((char *)(encrypted),
                         (unsigned long)(cryptLen))
            != (long)(cryptLen)) {
                delete [] encrypted;
                delete [] decrypted;
                return e_readFile;
        }
 #endif
        switch (algo) {
        case PWM_CRYPT_BLOWFISH: {
                Blowfish bf;
                bf.bf_setkey((byte *) pw->latin1(), pw->length());
                bf.bf_decrypt(decrypted, encrypted, cryptLen);
                break;
        }
        case PWM_CRYPT_AES128:
                /*... fall through */
        case PWM_CRYPT_AES192:
        case PWM_CRYPT_AES256:
        case PWM_CRYPT_3DES:
        case PWM_CRYPT_TWOFISH:
        case PWM_CRYPT_TWOFISH128: {
                if (!LibGCryptIf::available())
                        return e_cryptNotImpl;
                LibGCryptIf gc;
                PwMerror err;
                err = gc.decrypt(&decrypted,
                                 &cryptLen,
                                 encrypted,
                                 cryptLen,
                                 reinterpret_cast<const unsigned char *>(pw->latin1()),
                                 pw->length(),
                                 algo);
                if (err != e_success) {
                        delete [] encrypted;
                        delete [] decrypted;
                        return e_cryptNotImpl;
                }
                break;
        }
        default: {
                delete [] encrypted;
                delete [] decrypted;
                return e_cryptNotImpl;
        } }
        delete [] encrypted;
 #ifndef PWM_EMBEDDED
        d->assign(reinterpret_cast<const char *>(decrypted),
                  static_cast<string::size_type>(cryptLen));
 #else
        d->assign((const char *)(decrypted),
                  (string::size_type)(cryptLen));
 #endif
        delete [] decrypted;
        if (algo == PWM_CRYPT_BLOWFISH) {
                if (!Blowfish::unpadNull(d)) {
                        BUG();
                        return e_readFile;
                }
        }
        return e_success;
 }
 PwMerror PwMDoc::checkDataHash(char dataHashType, const string *dataHash,
                               const string *dataStream)
 {
        PWM_ASSERT(dataHash);
        PWM_ASSERT(dataStream);
        switch(dataHashType) {
        case PWM_HASH_SHA1: {
                Sha1 hash;
                hash.sha1_write((byte*)dataStream->c_str(), dataStream->length());
                string ret = hash.sha1_read();
                if (ret != *dataHash)
                        return e_fileCorrupt;
                break;
        }
        case PWM_HASH_SHA256:
                /*... fall through */
        case PWM_HASH_SHA384:
        case PWM_HASH_SHA512:
        case PWM_HASH_MD5:
        case PWM_HASH_RMD160:
        case PWM_HASH_TIGER: {
                if (!LibGCryptIf::available())
                        return e_hashNotImpl;
                LibGCryptIf gc;
                PwMerror err;
                unsigned char *buf;
                size_t hashLen;
                err = gc.hash(&buf,
                              &hashLen,
                              reinterpret_cast<const unsigned char *>(dataStream->c_str()),
                              dataStream->length(),
                              dataHashType);
                if (err != e_success)
                        return e_hashNotImpl;
                string calcHash(reinterpret_cast<const char *>(buf),
                                static_cast<string::size_type>(hashLen));
                delete [] buf;
                if (calcHash != *dataHash)
                        return e_fileCorrupt;
                break;
        }
        default:
                return e_hashNotImpl;
        }
        return e_success;
 }
 bool PwMDoc::lockAt(unsigned int category, unsigned int index,
                    bool lock)
 {
        if (index >= numEntries(category)) {
                BUG();
                return false;
        }
        if (lock == dti.dta[category].d[index].lockStat)
                return true;
        if (!lock && currentPw != "") {
                // "unlocking" and "password is already set"
                if (!getDocStatFlag(DOC_STAT_UNLOCK_WITHOUT_PW)) {
                        // unlocking without pw not allowed
                        QString pw;
                        pw = requestMpw(getDocStatFlag(DOC_STAT_USE_CHIPCARD));
                        if (pw != "") {
                                if (pw != currentPw) {
                                        wrongMpwMsgBox(getDocStatFlag(DOC_STAT_USE_CHIPCARD));
                                        return false;
                                } else {
                                        timer()->start(DocTimer::id_mpwTimer);
                                }
                        } else {
                                return false;
                        }
                } else {
                        timer()->start(DocTimer::id_mpwTimer);
                }
        }
        dti.dta[category].d[index].lockStat = lock;
        dti.dta[category].d[index].rev++; // increment revision counter.
        emitDataChanged(this);
        if (!lock)
                timer()->start(DocTimer::id_autoLockTimer);
        return true;
 }
 bool PwMDoc::lockAt(const QString &category,unsigned int index,
                    bool lock)
 {
        unsigned int cat = 0;
        if (!findCategory(category, &cat)) {
                BUG();
                return false;
        }
        return lockAt(cat, index, lock);
 }
 bool PwMDoc::lockAll(bool lock)
 {
        if (!lock && isDeepLocked()) {
                PwMerror ret;
                ret = deepLock(false);
                if (ret != e_success)
                        return false;
                return true;
        }
        if (isDocEmpty()) {
                return true;
        }
        if (!lock && currentPw != "") {
                // unlocking and password is already set
                if (!getDocStatFlag(DOC_STAT_UNLOCK_WITHOUT_PW)) {
                        // unlocking without pw not allowed
                        QString pw;
                        pw = requestMpw(getDocStatFlag(DOC_STAT_USE_CHIPCARD));
                        if (pw != "") {
                                if (pw != currentPw) {
                                        wrongMpwMsgBox(getDocStatFlag(DOC_STAT_USE_CHIPCARD));
                                        return false;
                                } else {
                                        timer()->start(DocTimer::id_mpwTimer);
                                }
                        } else {
                                return false;
                        }
                } else {
                        timer()->start(DocTimer::id_mpwTimer);
                }
        }
        vector<PwMCategoryItem>::iterator catBegin = dti.dta.begin(),
                                          catEnd = dti.dta.end(),
                                          catI = catBegin;
        vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
        while (catI != catEnd) {
                entrBegin = catI->d.begin();
                entrEnd = catI->d.end();
                entrI = entrBegin;
                while (entrI != entrEnd) {
                        entrI->lockStat = lock;
                        entrI->rev++; // increment revision counter.
                        ++entrI;
                }
                ++catI;
        }
        emitDataChanged(this);
        if (lock)
                timer()->stop(DocTimer::id_autoLockTimer);
        else
                timer()->start(DocTimer::id_autoLockTimer);
        return true;
 }
 bool PwMDoc::isLocked(const QString &category, unsigned int index)
 {
        unsigned int cat = 0;
        if (!findCategory(category, &cat)) {
                BUG();
                return false;
        }
        return isLocked(cat, index);
 }
 bool PwMDoc::unlockAll_tempoary(bool revert)
 {
        static vector< vector<bool> > *oldLockStates = 0;
        static bool wasDeepLocked;
                if (revert) {// revert the unlocking
                if (oldLockStates) {
                        /* we actually _have_ unlocked something, because
                         * we have allocated space for the oldLockStates.
                         * So, go on and revert them!
                         */
                        if (wasDeepLocked) {
                                PwMerror ret = deepLock(true);
                                if (ret == e_success) {
                                        /* deep-lock succeed. We are save.
                                         * (but if it failed, just go on
                                         * lock them normally)
                                         */
                                        delete_and_null(oldLockStates);
                                        timer()->start(DocTimer::id_autoLockTimer);
                                        printDebug("tempoary unlocking of dta "
                                                   "reverted by deep-locking.");
                                        return true;
                                }
                                printDebug("deep-lock failed while reverting! "
                                           "Falling back to normal-lock.");
                        }
                        if (unlikely(!wasDeepLocked &&
                                     numCategories() != oldLockStates->size())) {
                                /* DOH! We have modified "dta" while
                                 * it was unlocked tempoary. DON'T DO THIS!
                                 */
                                BUG();
                                delete_and_null(oldLockStates);
                                timer()->start(DocTimer::id_autoLockTimer);
                                return false;
                        }
                        vector<PwMCategoryItem>::iterator catBegin = dti.dta.begin(),
                                                          catEnd = dti.dta.end(),
                                                          catI = catBegin;
                        vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
                        vector< vector<bool> >::iterator oldCatStatI = oldLockStates->begin();
                        vector<bool>::iterator oldEntrStatBegin,
                                               oldEntrStatEnd,
                                               oldEntrStatI;
                        while (catI != catEnd) {
                                entrBegin = catI->d.begin();
                                entrEnd = catI->d.end();
                                entrI = entrBegin;
                                if (likely(!wasDeepLocked)) {
                                        oldEntrStatBegin = oldCatStatI->begin();
                                        oldEntrStatEnd = oldCatStatI->end();
                                        oldEntrStatI = oldEntrStatBegin;
                                        if (unlikely(catI->d.size() != oldCatStatI->size())) {
                                                /* DOH! We have modified "dta" while
                                                 * it was unlocked tempoary. DON'T DO THIS!
                                                 */
                                                BUG();
                                                delete_and_null(oldLockStates);
                                                timer()->start(DocTimer::id_autoLockTimer);
                                                return false;
                                        }
                                }
                                while (entrI != entrEnd) {
                                        if (wasDeepLocked) {
                                                /* this is an error-fallback if
                                                 * deeplock didn't succeed
                                                 */
                                                entrI->lockStat = true;
                                        } else {
                                                entrI->lockStat = *oldEntrStatI;
                                        }
                                        ++entrI;
                                        if (likely(!wasDeepLocked))
                                                ++oldEntrStatI;
                                }
                                ++catI;
                                if (likely(!wasDeepLocked))
                                        ++oldCatStatI;
                        }
                        delete_and_null(oldLockStates);
                        if (unlikely(wasDeepLocked)) {
                                /* error fallback... */
                                unsetDocStatFlag(DOC_STAT_DEEPLOCKED);
                                emitDataChanged(this);
                                printDebug("WARNING: unlockAll_tempoary(true) "
                                           "deeplock fallback!");
                        }
                        printDebug("tempoary unlocking of dta reverted.");
                } else {
                        printDebug("unlockAll_tempoary(true): nothing to do.");
                }
                timer()->start(DocTimer::id_autoLockTimer);
                } else {// unlock all data tempoary
                if (unlikely(oldLockStates != 0)) {
                        /* DOH! We have already unlocked the data tempoarly.
                         * No need to do it twice. ;)
                         */
                        BUG();
                        return false;
                }
                wasDeepLocked = false;
                bool mustUnlock = false;
                if (isDeepLocked()) {
                        PwMerror ret;
                        while (1) {
                                ret = deepLock(false);
                                if (ret == e_success) {
                                        break;
                                } else if (ret == e_wrongPw) {
                                        wrongMpwMsgBox(getDocStatFlag(DOC_STAT_USE_CHIPCARD));
                                } else {
                                        printDebug("deep-unlocking failed while "
                                                   "tempoary unlocking!");
                                        return false;
                                }
                        }
                        wasDeepLocked = true;
                        mustUnlock = true;
                } else {
                        // first check if it's needed to unlock some entries
                        vector<PwMCategoryItem>::iterator catBegin = dti.dta.begin(),
                                                          catEnd = dti.dta.end(),
                                                          catI = catBegin;
                        vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
                        while (catI != catEnd) {
                                entrBegin = catI->d.begin();
                                entrEnd = catI->d.end();
                                entrI = entrBegin;
                                while (entrI != entrEnd) {
                                        if (entrI->lockStat == true) {
                                                mustUnlock = true;
                                                break;
                                        }
                                        ++entrI;
                                }
                                if (mustUnlock)
                                        break;
                                ++catI;
                        }
                }
                if (!mustUnlock) {
                        // nothing to do.
                        timer()->stop(DocTimer::id_autoLockTimer);
                        printDebug("unlockAll_tempoary(): nothing to do.");
                        return true;
                } else if (!wasDeepLocked) {
                        if (!getDocStatFlag(DOC_STAT_UNLOCK_WITHOUT_PW) &&
                            currentPw != "") {
                                /* we can't unlock without mpw, so
                                 * we need to ask for it.
                                 */
                                QString pw;
                                while (1) {
                                        pw = requestMpw(getDocStatFlag(DOC_STAT_USE_CHIPCARD));
                                        if (pw == "") {
                                                return false;
                                        } else if (pw == currentPw) {
                                                break;
                                        }
                                        wrongMpwMsgBox(getDocStatFlag(DOC_STAT_USE_CHIPCARD));
                                }
                        }
                }
                timer()->stop(DocTimer::id_autoLockTimer);
                oldLockStates = new vector< vector<bool> >;
                vector<bool> tmp_vec;
                vector<PwMCategoryItem>::iterator catBegin = dti.dta.begin(),
                                                  catEnd = dti.dta.end(),
                                                  catI = catBegin;
                vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
                while (catI != catEnd) {
                        entrBegin = catI->d.begin();
                        entrEnd = catI->d.end();
                        entrI = entrBegin;
                        while (entrI != entrEnd) {
                                if (!wasDeepLocked) {
                                        tmp_vec.push_back(entrI->lockStat);
                                }
                                entrI->lockStat = false;
                                ++entrI;
                        }
                        if (!wasDeepLocked) {
                                oldLockStates->push_back(tmp_vec);
                                tmp_vec.clear();
                        }
                        ++catI;
                }
                printDebug("tempoary unlocked dta.");
        }
        return true;
 }
 PwMerror PwMDoc::deepLock(bool lock, bool saveToFile)
 {
        PwMerror ret;
        /* NOTE: saveDoc() depends on this function to return
         *       e_success if saveToFile == false
         */
        if (lock) {
                if (isDeepLocked())
                        return e_lock;
                if (saveToFile) {
                        if (isDocEmpty())
                                return e_docIsEmpty;
                        ret = saveDoc(conf()->confGlobCompression());
                        if (ret == e_filename) {
                                /* the doc wasn't saved to a file
                                 * by the user, yet.
                                 */
                                cantDeeplock_notSavedMsgBox();
                                return e_docNotSaved;
                        } else if (ret != e_success) {
                                return e_lock;
                        }
                }
                timer()->stop(DocTimer::id_autoLockTimer);
                clearDoc();
                PwMDataItem d;
                d.desc = IS_DEEPLOCKED_SHORTMSG.latin1();
                d.comment = IS_DEEPLOCKED_MSG.latin1();
                d.listViewPos = 0;
                addEntry(DEFAULT_CATEGORY, &d, true);
                lockAt(DEFAULT_CATEGORY, 0, true);
                unsetDocStatFlag(DOC_STAT_DISK_DIRTY);
                setDocStatFlag(DOC_STAT_DEEPLOCKED);
        } else {
                if (!isDeepLocked())
                        return e_lock;
                ret = openDoc(&filename, (conf()->confGlobUnlockOnOpen())
                                          ? 0 : 1);
                if (ret == e_wrongPw) {
                        return e_wrongPw;
                } else if (ret != e_success) {
                        printDebug(string("PwMDoc::deepLock(false): ERR! openDoc() == ")
                                   + tostr(static_cast<int>(ret)));
                        return e_lock;
                }
                unsetDocStatFlag(DOC_STAT_DEEPLOCKED);
                timer()->start(DocTimer::id_autoLockTimer);
        }
        emitDataChanged(this);
        return e_success;
 }
 void PwMDoc::_deepUnlock()
 {
        deepLock(false);
 }
 void PwMDoc::clearDoc()
 {
        dti.clear();
        PwMCategoryItem d;
        //US ENH: to initialize all members with meaningfull data.
        d.clear();
        d.name = DEFAULT_CATEGORY.latin1();
        dti.dta.push_back(d);
        currentPw = "";
        unsetDocStatFlag(DOC_STAT_UNLOCK_WITHOUT_PW);
 }
 void PwMDoc::changeCurrentPw()
 {
        if (currentPw == "")
                return; // doc hasn't been saved. No mpw available.
        bool useChipcard = getDocStatFlag(DOC_STAT_USE_CHIPCARD);
        QString pw = requestMpwChange(&currentPw, &useChipcard);
        if (pw == "")
                return;
        if (useChipcard)
                setDocStatFlag(DOC_STAT_USE_CHIPCARD);
        else
                unsetDocStatFlag(DOC_STAT_USE_CHIPCARD);
        setCurrentPw(pw);
 }
 void PwMDoc::setListViewPos(const QString &category, unsigned int index,
                            int pos)
 {
        unsigned int cat = 0;
        if (!findCategory(category, &cat)) {
                BUG();
                return;
        }
        setListViewPos(cat, index, pos);
 }
 void PwMDoc::setListViewPos(unsigned int category, unsigned int index,
                            int pos)
 {
        dti.dta[category].d[index].listViewPos = pos;
 /* FIXME workaround: don't flag dirty, because this function sometimes
 * get's called when it shouldn't. It's because PwMView assumes
 * the user resorted the UI on behalf of signal layoutChanged().
 * This is somewhat broken and incorrect, but I've no other
 * solution for now.
 */
        //setDocStatFlag(DOC_STAT_DISK_DIRTY);
 }
 int PwMDoc::getListViewPos(const QString &category, unsigned int index)
 {
        unsigned int cat = 0;
        if (!findCategory(category, &cat)) {
                BUG();
                return -1;
        }
        return dti.dta[cat].d[index].listViewPos;
 }
 void PwMDoc::findEntry(unsigned int category, PwMDataItem find, unsigned int searchIn,
                       vector<unsigned int> *foundPositions, bool breakAfterFound,
                       bool caseSensitive, bool exactWordMatch, bool sortByLvp)
 {
        PWM_ASSERT(foundPositions);
        PWM_ASSERT(searchIn);
        foundPositions->clear();
        unsigned int i, entries = numEntries(category);
        for (i = 0; i < entries; ++i) {
                if (searchIn & SEARCH_IN_DESC) {
                        if (!compareString(find.desc, dti.dta[category].d[i].desc,
                                          caseSensitive, exactWordMatch)) {
                                continue;
                        }
                }
                if (searchIn & SEARCH_IN_NAME) {
                        if (!compareString(find.name, dti.dta[category].d[i].name,
                                          caseSensitive, exactWordMatch)) {
                                continue;
                        }
                }
                if (searchIn & SEARCH_IN_PW) {
                        bool wasLocked = isLocked(category, i);
                        getDataChangedLock();
                        lockAt(category, i, false);
                        if (!compareString(find.pw, dti.dta[category].d[i].pw,
                                          caseSensitive, exactWordMatch)) {
                                lockAt(category, i, wasLocked);
                                putDataChangedLock();
                                continue;
                        }
                        lockAt(category, i, wasLocked);
                        putDataChangedLock();
                }
                if (searchIn & SEARCH_IN_COMMENT) {
                        if (!compareString(find.comment, dti.dta[category].d[i].comment,
                                          caseSensitive, exactWordMatch)) {
                                continue;
                        }
                }
                if (searchIn & SEARCH_IN_URL) {
                        if (!compareString(find.url, dti.dta[category].d[i].url,
                                          caseSensitive, exactWordMatch)) {
                                continue;
                        }
                }
                if (searchIn & SEARCH_IN_LAUNCHER) {
                        if (!compareString(find.launcher, dti.dta[category].d[i].launcher,
                                          caseSensitive, exactWordMatch)) {
                                continue;
                        }
                }
                // all selected "searchIn" matched.
                foundPositions->push_back(i);
                if (breakAfterFound)
                        break;
        }
        if (sortByLvp && foundPositions->size() > 1) {
                vector< pair<unsigned int /* foundPosition (real doc pos) */,
                             unsigned int /* lvp-pos */> > tmp_vec;
                
                unsigned int i, items = foundPositions->size();
                pair<unsigned int, unsigned int> tmp_pair;
                for (i = 0; i < items; ++i) {
                        tmp_pair.first = (*foundPositions)[i];
                        tmp_pair.second = dti.dta[category].d[(*foundPositions)[i]].listViewPos;
                        tmp_vec.push_back(tmp_pair);
                }
                sort(tmp_vec.begin(), tmp_vec.end(), dta_lvp_greater());
                foundPositions->clear();
                for (i = 0; i < items; ++i) {
                        foundPositions->push_back(tmp_vec[i].first);
                }
        }
 }
 void PwMDoc::findEntry(const QString &category, PwMDataItem find, unsigned int searchIn,
                       vector<unsigned int> *foundPositions, bool breakAfterFound,
                       bool caseSensitive, bool exactWordMatch, bool sortByLvp)
 {
        PWM_ASSERT(foundPositions);
        unsigned int cat = 0;
        if (!findCategory(category, &cat)) {
                foundPositions->clear();
                return;
        }
        findEntry(cat, find, searchIn, foundPositions, breakAfterFound,
                  caseSensitive, exactWordMatch, sortByLvp);
 }
 bool PwMDoc::compareString(const string &s1, const string &s2, bool caseSensitive,
                           bool exactWordMatch)
 {
        QString _s1(s1.c_str());
        QString _s2(s2.c_str());
        if (!caseSensitive) {
                _s1 = _s1.lower();
                _s2 = _s2.lower();
        }
        if (exactWordMatch ? (_s1 == _s2) : (_s2.find(_s1) != -1))
                return true;
        return false;
 }
 bool PwMDoc::findCategory(const QString &name, unsigned int *index)
 {
        vector<PwMCategoryItem>::iterator i = dti.dta.begin(),
                                          end = dti.dta.end();
        while (i != end) {
                if ((*i).name == name.latin1()) {
                        if (index) {
                                *index = i - dti.dta.begin();
                        }
                        return true;
                }
                ++i;
        }
        return false;
 }
 bool PwMDoc::renameCategory(const QString &category, const QString &newName)
 {
        unsigned int cat = 0;
        if (!findCategory(category, &cat))
                return false;
        return renameCategory(cat, newName);
 }
 bool PwMDoc::renameCategory(unsigned int category, const QString &newName,
                            bool dontFlagDirty)
 {
        if (category > numCategories() - 1)
                return false;
        dti.dta[category].name = newName.latin1();
        if (!dontFlagDirty)
                flagDirty();
        return true;
 }
 bool PwMDoc::delCategory(const QString &category)
 {
        unsigned int cat = 0;
        if (!findCategory(category, &cat))
                return false;
        return delCategory(cat);
 }
 bool PwMDoc::delCategory(unsigned int category, bool dontFlagDirty)
 {
        if (category > numCategories() - 1)
                return false;
        // We don't delete it, if it is the last existing
        // category! Instead we rename it to "Default".
        if (numCategories() > 1) {
                dti.dta.erase(dti.dta.begin() + category);
        } else {
                renameCategory(category, DEFAULT_CATEGORY, dontFlagDirty);
                return true;
        }
        if (!dontFlagDirty)
                flagDirty();
        return true;
 }
 void PwMDoc::delAllEmptyCat(bool dontFlagDirty)
 {
        vector<PwMCategoryItem>::iterator begin = dti.dta.begin(),
                                          end = dti.dta.end(),
                                          i = begin;
        while (i != end) {
                if (i->d.empty()) {
                        delCategory(begin - i, dontFlagDirty);
                }
                ++i;
        }
 }
 void PwMDoc::getCategoryList(vector<string> *list)
 {
        PWM_ASSERT(list);
        list->clear();
        vector<PwMCategoryItem>::iterator i = dti.dta.begin(),
                                          end = dti.dta.end();
        while (i != end) {
                list->push_back(i->name);
                ++i;
        }
 }
 void PwMDoc::getCategoryList(QStringList *list)
 {
        PWM_ASSERT(list);
        list->clear();
        vector<PwMCategoryItem>::iterator i = dti.dta.begin(),
                                          end = dti.dta.end();
        while (i != end) {
 #ifndef PWM_EMBEDDED
                list->push_back(i->name.c_str());
 #else
                list->append(i->name.c_str());
 #endif
                ++i;
        }
 }
 void PwMDoc::getEntryList(const QString &category, QStringList *list)
 {
        PWM_ASSERT(list);
        unsigned int cat = 0;
        if (!findCategory(category, &cat)) {
                list->clear();
                return;
        }
        getEntryList(cat, list);
 }
 void PwMDoc::getEntryList(const QString &category, vector<string> *list)
 {
        PWM_ASSERT(list);
        unsigned int cat = 0;
        if (!findCategory(category, &cat)) {
                list->clear();
                return;
        }
        getEntryList(cat, list);
 }
 void PwMDoc::getEntryList(unsigned int category, vector<string> *list)
 {
        PWM_ASSERT(list);
        list->clear();
        vector<PwMDataItem>::iterator begin = dti.dta[category].d.begin(),
                                      end = dti.dta[category].d.end(),
                                      i = begin;
        while (i != end) {
                list->push_back(i->desc);
                ++i;
        }
 }
 void PwMDoc::getEntryList(unsigned int category, QStringList *list)
 {
        PWM_ASSERT(list);
        list->clear();
        vector<PwMDataItem>::iterator begin = dti.dta[category].d.begin(),
                                      end = dti.dta[category].d.end(),
                                      i = begin;
        while (i != end) {
 #ifndef PWM_EMBEDDED
                list->push_back(i->desc.c_str());
 #else
                list->append(i->desc.c_str());
 #endif
                ++i;
        }
 }
 bool PwMDoc::execLauncher(const QString &category, unsigned int entryIndex)
 {
        unsigned int cat = 0;
        if (!findCategory(category, &cat))
                return false;
        return execLauncher(cat, entryIndex);
 }
 bool PwMDoc::execLauncher(unsigned int category, unsigned int entryIndex)
 {
 #ifndef _WIN32_
        if (geteuid() == 0) {
                rootAlertMsgBox();
                return false;
        }
 #endif
        QString command(dti.dta[category].d[entryIndex].launcher.c_str());
        bool wasLocked = isLocked(category, entryIndex);
        if (command.find("$p") != -1) {
                /* the user requested the password to be included
                 * into the command. We have to ask for the password,
                 * if it's locked. We do that by unlocking the entry
                 */
                if (!lockAt(category, entryIndex, false))
                        return false;
        }
 #ifndef PWM_EMBEDDED
        command.replace("$d", dti.dta[category].d[entryIndex].desc.c_str());
        command.replace("$n", dti.dta[category].d[entryIndex].name.c_str());
        command.replace("$p", dti.dta[category].d[entryIndex].pw.c_str());
        command.replace("$u", dti.dta[category].d[entryIndex].url.c_str());
        command.replace("$c", dti.dta[category].d[entryIndex].comment.c_str());
 #else
        command.replace(QRegExp("$d"), dti.dta[category].d[entryIndex].desc.c_str());
        command.replace(QRegExp("$n"), dti.dta[category].d[entryIndex].name.c_str());
        command.replace(QRegExp("$p"), dti.dta[category].d[entryIndex].pw.c_str());
        command.replace(QRegExp("$u"), dti.dta[category].d[entryIndex].url.c_str());
        command.replace(QRegExp("$c"), dti.dta[category].d[entryIndex].comment.c_str());
 #endif
        command.append(" &");
        QString customXterm(conf()->confGlobXtermCommand());
        if (!customXterm.isEmpty())
                command = customXterm + " " + command;
        system(command.latin1());
        lockAt(category, entryIndex, wasLocked);
        return true;
 }
 bool PwMDoc::goToURL(const QString &category, unsigned int entryIndex)
 {
        unsigned int cat = 0;
        if (!findCategory(category, &cat))
                return false;
        return goToURL(cat, entryIndex);
 }
 bool PwMDoc::goToURL(unsigned int category, unsigned int entryIndex)
 {
 #ifndef _WIN32_
        if (geteuid() == 0) {
                rootAlertMsgBox();
                return false;
        }
 #endif
        QString url(dti.dta[category].d[entryIndex].url.c_str());
        if (url.isEmpty())
                return false;
        QString customBrowser(conf()->confGlobBrowserCommand());
        if (!customBrowser.isEmpty()) {
                browserProc.clearArguments();
                browserProc << customBrowser << url;
                if (browserProc.start(KProcess::DontCare))
                        return true;
        }
        browserProc.clearArguments();
        browserProc << "konqueror" << url;
        if (browserProc.start(KProcess::DontCare))
                return true;
        browserProc.clearArguments();
        browserProc << "mozilla" << url;
        if (browserProc.start(KProcess::DontCare))
                return true;
        browserProc.clearArguments();
        browserProc << "opera" << url;
        if (browserProc.start(KProcess::DontCare))
                return true;
        return false;
 }
 PwMerror PwMDoc::exportToText(const QString *file)
 {
        PWM_ASSERT(file);
        if (QFile::exists(*file)) {
                if (!QFile::remove(*file))
                        return e_accessFile;
        }
        QFile f(*file);
        if (!f.open(IO_ReadWrite))
                return e_openFile;
        if (!unlockAll_tempoary()) {
                f.close();
                return e_lock;
        }
        // write header
        string header = i18n("Password table generated by\nPwM v").latin1();
        header += PACKAGE_VER;
        header += i18n("\non ").latin1();
        QDate currDate = QDate::currentDate();
        QTime currTime = QTime::currentTime();
 #ifndef PWM_EMBEDDED
        header += currDate.toString("ddd MMMM d ").latin1();
        header += currTime.toString("hh:mm:ss ").latin1();
 #else
        QString dfs = KGlobal::locale()->dateFormatShort();
        bool ampm = KGlobal::locale()->use12Clock();
        KGlobal::locale()->setDateFormatShort("%A %B %d");
        KGlobal::locale()->setHore24Format(true);
        header += KGlobal::locale()->formatDate(currDate, true, KLocale::Userdefined).latin1();
        header += KGlobal::locale()->formatTime(currTime, true).latin1();
        KGlobal::locale()->setDateFormatShort(dfs);
        KGlobal::locale()->setHore24Format(!ampm);
 #endif
        header += tostr(currDate.year());
        header += "\n==============================\n\n";
 #ifndef PWM_EMBEDDED
        if (f.writeBlock(header.c_str(), header.length()) != (Q_LONG)header.length()) {
                unlockAll_tempoary(true);
                f.close();
                return e_writeFile;
        }
 #else
        if (f.writeBlock(header.c_str(), header.length()) != (long)header.length()) {
                unlockAll_tempoary(true);
                f.close();
                return e_writeFile;
        }
 #endif
        unsigned int i, numCat = numCategories();
        unsigned int j, numEnt;
        string exp;
        for (i = 0; i < numCat; ++i) {
                numEnt = numEntries(i);
                exp = "\n== Category: ";
                exp += dti.dta[i].name;
                exp += " ==\n";
 #ifndef PWM_EMBEDDED
                if (f.writeBlock(exp.c_str(), exp.length()) != (Q_LONG)exp.length()) {
                                unlockAll_tempoary(true);
                                f.close();
                                return e_writeFile;
                }
 #else
                if (f.writeBlock(exp.c_str(), exp.length()) != (long)exp.length()) {
                                unlockAll_tempoary(true);
                                f.close();
                                return e_writeFile;
                }
 #endif
                for (j = 0; j < numEnt; ++j) {
                        exp = "\n-- ";
                        exp += dti.dta[i].d[j].desc;
                        exp += " --\n";
                        exp += i18n("Username: ").latin1();
                        exp += dti.dta[i].d[j].name;
                        exp += "\n";
                        exp += i18n("Password: ").latin1();
                        exp += dti.dta[i].d[j].pw;
                        exp += "\n";
                        exp += i18n("Comment: ").latin1();
                        exp += dti.dta[i].d[j].comment;
                        exp += "\n";
                        exp += i18n("URL: ").latin1();
                        exp += dti.dta[i].d[j].url;
                        exp += "\n";
                        exp += i18n("Launcher: ").latin1();
                        exp += dti.dta[i].d[j].launcher;
                        exp += "\n";
 #ifndef PWM_EMBEDDED
                        if (f.writeBlock(exp.c_str(), exp.length()) != (Q_LONG)exp.length()) {
                                unlockAll_tempoary(true);
                                f.close();
                                return e_writeFile;
                        }
 #else
                        if (f.writeBlock(exp.c_str(), exp.length()) != (long)exp.length()) {
                                unlockAll_tempoary(true);
                                f.close();
                                return e_writeFile;
                        }
 #endif
                }
        }
        unlockAll_tempoary(true);
        f.close();
        return e_success;
 }
 PwMerror PwMDoc::importFromText(const QString *file, int format)
 {
        PWM_ASSERT(file);
        if (format == 0)
                return importText_PwM(file);
        else if (format == -1) {
                // probe for all formats
                if (importText_PwM(file) == e_success)
                        return e_success;
                dti.clear();
                emitDataChanged(this);
                // add next format here...
                return e_fileFormat;
        }
        return e_invalidArg;
 }
 PwMerror PwMDoc::importText_PwM(const QString *file)
 {
 #ifndef PWM_EMBEDDED
        PWM_ASSERT(file);
        FILE *f;
        int tmp;
        ssize_t ret;
        string curCat;
        unsigned int entriesRead = 0;
        PwMDataItem currItem;
        f = fopen(file->latin1(), "r");
        if (!f)
                return e_openFile;
        size_t ch_tmp_size = 1024;
        char *ch_tmp = (char*)malloc(ch_tmp_size);
        if (!ch_tmp) {
                fclose(f);
                return e_outOfMem;
        }
        // - check header
        if (getline(&ch_tmp, &ch_tmp_size, f) == -1) // skip first line.
                goto formatError;
        // check version-string and return version in "ch_tmp".
        if (fscanf(f, "PwM v%s", ch_tmp) != 1) {
                // header not recognized as PwM generated header
                goto formatError;
        }
        // set filepointer behind version-string-line previously checked
        if (getline(&ch_tmp, &ch_tmp_size, f) == -1)
                goto formatError;
        // skip next line containing the build-date
        if (getline(&ch_tmp, &ch_tmp_size, f) == -1)
                goto formatError;
        // read header termination line
        if (getline(&ch_tmp, &ch_tmp_size, f) == -1)
                goto formatError;
        if (strcmp(ch_tmp, "==============================\n"))
                goto formatError;
        // - read entries
        do {
                // find beginning of next category
                do {
                        tmp = fgetc(f);
                } while (tmp == '\n' && tmp != EOF);
                if (tmp == EOF)
                        break;
                // decrement filepos by one
                fseek(f, -1, SEEK_CUR);
                // read cat-name
                if (getline(&ch_tmp, &ch_tmp_size, f) == -1)
                        goto formatError;
                // check cat-name format
                if (memcmp(ch_tmp, "== Category: ", 13) != 0)
                        goto formatError;
                if (memcmp(ch_tmp + (strlen(ch_tmp) - 1 - 3), " ==", 3) != 0)
                        goto formatError;
                // copy cat-name
                curCat.assign(ch_tmp + 13, strlen(ch_tmp) - 1 - 16);
                do {
                        // find beginning of next entry
                        do {
                                tmp = fgetc(f);
                        } while (tmp == '\n' && tmp != EOF && tmp != '=');
                        if (tmp == EOF)
                                break;
                        if (tmp == '=') {
                                fseek(f, -1, SEEK_CUR);
                                break;
                        }
                        // decrement filepos by one
                        fseek(f, -1, SEEK_CUR);
                        // read desc-line
                        if (getline(&ch_tmp, &ch_tmp_size, f) == -1)
                                goto formatError;
                        // check desc-line format
                        if (memcmp(ch_tmp, "-- ", 3) != 0)
                                goto formatError;
                        if (memcmp(ch_tmp + (strlen(ch_tmp) - 1 - 3), " --", 3) != 0)
                                goto formatError;
                        // add desc-line
                        currItem.desc.assign(ch_tmp + 3, strlen(ch_tmp) - 1 - 6);
                        // read username-line
                        if ((ret = getline(&ch_tmp, &ch_tmp_size, f)) == -1)
                                goto formatError;
                        if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.name))
                                goto formatError;
                        // read pw-line
                        if ((ret = getline(&ch_tmp, &ch_tmp_size, f)) == -1)
                                goto formatError;
                        if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.pw))
                                goto formatError;
                        // read comment-line
                        if ((ret = getline(&ch_tmp, &ch_tmp_size, f)) == -1)
                                goto formatError;
                        if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.comment))
                                goto formatError;
                        // read URL-line
                        if ((ret = getline(&ch_tmp, &ch_tmp_size, f)) == -1)
                                goto formatError;
                        if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.url))
                                goto formatError;
                        // read launcher-line
                        if ((ret = getline(&ch_tmp, &ch_tmp_size, f)) == -1)
                                goto formatError;
                        if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.launcher))
                                goto formatError;
                        currItem.lockStat = true;
                        currItem.listViewPos = -1;
                        addEntry(curCat.c_str(), &currItem, true);
                        ++entriesRead;
                } while (1);
        } while (1);
        if (!entriesRead)
                goto formatError;
        free(ch_tmp);
        fclose(f);
        flagDirty();
        return e_success;
      formatError:
        free(ch_tmp);
        fclose(f);
        return e_fileFormat;
 #else
        PWM_ASSERT(file);
        QFile f(file->latin1());
        int tmp;
        ssize_t ret;
        string curCat;
        unsigned int entriesRead = 0;
        PwMDataItem currItem;
        bool res = f.open(IO_ReadOnly);
        if (res == false)
          return e_openFile;
        unsigned int ch_tmp_size = 1024;
        char *ch_tmp = (char*)malloc(ch_tmp_size);
        if (!ch_tmp) {
                f.close();
                return e_outOfMem;
        }
        // - check header
        if (f.readLine(ch_tmp, ch_tmp_size) == -1) // skip first line.
                goto formatError;
        //US read fileversion first, then check if ok.
        if (f.readLine(ch_tmp, ch_tmp_size) == -1)
                goto formatError;
        // check version-string and return version in "ch_tmp".
                //US if (fscanf(f, "PwM v%s", ch_tmp) != 1) {
                //US    // header not recognized as PwM generated header
                //US    goto formatError;
                //US}
        //US set filepointer behind version-string-line previously checked
        //US if (f.readLine(ch_tmp, ch_tmp_size) == -1)
                //US    goto formatError;
        // skip next line containing the build-date
        if (f.readLine(ch_tmp, ch_tmp_size) == -1)
                goto formatError;
        // read header termination line
        if (f.readLine(ch_tmp, ch_tmp_size) == -1)
                goto formatError;
        if (strcmp(ch_tmp, "==============================\n"))
                goto formatError;
        // - read entries
        do {
                // find beginning of next category
                do {
                        tmp = f.getch();
                } while (tmp == '\n' && tmp != EOF);
                if (tmp == EOF)
                        break;
                // decrement filepos by one
                f.at(f.at()-1);
                // read cat-name
                if (f.readLine(ch_tmp, ch_tmp_size) == -1)
                        goto formatError;
                // check cat-name format
                if (memcmp(ch_tmp, "== Category: ", 13) != 0)
                        goto formatError;
                if (memcmp(ch_tmp + (strlen(ch_tmp) - 1 - 3), " ==", 3) != 0)
                        goto formatError;
                // copy cat-name
                curCat.assign(ch_tmp + 13, strlen(ch_tmp) - 1 - 16);
                do {
                        // find beginning of next entry
                        do {
                                tmp = f.getch();
                        } while (tmp == '\n' && tmp != EOF && tmp != '=');
                        if (tmp == EOF)
                                break;
                        if (tmp == '=') {
                                f.at(f.at()-1);
                                break;
                        }
                        // decrement filepos by one
                        f.at(f.at()-1);
                        // read desc-line
                        if (f.readLine(ch_tmp, ch_tmp_size) == -1)
                                goto formatError;
                        // check desc-line format
                        if (memcmp(ch_tmp, "-- ", 3) != 0)
                                goto formatError;
                        if (memcmp(ch_tmp + (strlen(ch_tmp) - 1 - 3), " --", 3) != 0)
                                goto formatError;
                        // add desc-line
                        currItem.desc.assign(ch_tmp + 3, strlen(ch_tmp) - 1 - 6);
                        // read username-line
                        if ((ret = f.readLine(ch_tmp, ch_tmp_size)) == -1)
                                goto formatError;
                        if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.name))
                                goto formatError;
                        // read pw-line
                        if ((ret = f.readLine(ch_tmp, ch_tmp_size)) == -1)
                                goto formatError;
                        if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.pw))
                                goto formatError;
                        // read comment-line
                        if ((ret = f.readLine(ch_tmp, ch_tmp_size)) == -1)
                                goto formatError;
                        if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.comment))
                                goto formatError;
                        // read URL-line
                        if ((ret = f.readLine(ch_tmp, ch_tmp_size)) == -1)
                                goto formatError;
                        if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.url))
                                goto formatError;
                        // read launcher-line
                        if ((ret = f.readLine(ch_tmp, ch_tmp_size)) == -1)
                                goto formatError;
                        if (!textExtractEntry_PwM(ch_tmp, ret, &currItem.launcher))
                                goto formatError;
                        currItem.lockStat = true;
                        currItem.listViewPos = -1;
                        addEntry(curCat.c_str(), &currItem, true);
                        ++entriesRead;
                } while (1);
        } while (1);
        if (!entriesRead)
                goto formatError;
        free(ch_tmp);
        f.close();
        flagDirty();
        return e_success;
      formatError:
        free(ch_tmp);
        f.close();
        return e_fileFormat;
 #endif
 }
 bool PwMDoc::textExtractEntry_PwM(const char *in, ssize_t in_size, string *out)
 {
        PWM_ASSERT(in && out);
        ssize_t i = 0, len = in_size - 1;
        while (i < len) {
                if (in[i] == ':')
                        break;
                ++i;
        }
        i += 2;
        *out = "";
        out->append(in + i, in_size - i - 1);
        return true;
 }
 PwMerror PwMDoc::exportToGpasman(const QString *file)
 {
        PWM_ASSERT(file);
        GpasmanFile gp;
        int ret;
        if (!unlockAll_tempoary())
                return e_lock;
        QString gpmPassword;
        while (1) {
                gpmPassword = requestNewMpw(0);
                if (gpmPassword == "") {
                        unlockAll_tempoary(true);
                        return e_noPw;
                }
                if (gpmPassword.length() < 4) {
                        gpmPwLenErrMsgBox();
                } else {
                        break;
                }
        }
        ret = gp.save_init(file->latin1(), gpmPassword.latin1());
        if (ret != 1) {
                unlockAll_tempoary(true);
                return e_accessFile;
        }
        char *entry[4];
        unsigned int numCat = numCategories(), i;
        unsigned int numEntr, j;
        int descLen, nameLen, pwLen, commentLen;
        for (i = 0; i < numCat; ++i) {
                numEntr = numEntries(i);
                for (j = 0; j < numEntr; ++j) {
                        descLen = dti.dta[i].d[j].desc.length();
                        nameLen = dti.dta[i].d[j].name.length();
                        pwLen = dti.dta[i].d[j].pw.length();
                        commentLen = dti.dta[i].d[j].comment.length();
                        entry[0] = new char[descLen + 1];
                        entry[1] = new char[nameLen + 1];
                        entry[2] = new char[pwLen + 1];
                        entry[3] = new char[commentLen + 1];
                        strcpy(entry[0], descLen == 0 ? " " : dti.dta[i].d[j].desc.c_str());
                        strcpy(entry[1], nameLen == 0 ? " " : dti.dta[i].d[j].name.c_str());
                        strcpy(entry[2], pwLen == 0 ? " " : dti.dta[i].d[j].pw.c_str());
                        strcpy(entry[3], commentLen == 0 ? " " : dti.dta[i].d[j].comment.c_str());
                        entry[0][descLen == 0 ? descLen + 1 : descLen] = '\0';
                        entry[1][nameLen == 0 ? nameLen + 1 : nameLen] = '\0';
                        entry[2][pwLen == 0 ? pwLen + 1 : pwLen] = '\0';
                        entry[3][commentLen == 0 ? commentLen + 1 : commentLen] = '\0';
                        ret = gp.save_entry(entry);
                        if (ret == -1){
                                delete [] entry[0];
                                delete [] entry[1];
                                delete [] entry[2];
                                delete [] entry[3];
                                gp.save_finalize();
                                unlockAll_tempoary(true);
                                return e_writeFile;
                        }
                        delete [] entry[0];
                        delete [] entry[1];
                        delete [] entry[2];
                        delete [] entry[3];
                }
        }
        unlockAll_tempoary(true);
        if (gp.save_finalize() == -1)
                return e_writeFile;
        return e_success;
 }
 PwMerror PwMDoc::importFromGpasman(const QString *file)
 {
        PWM_ASSERT(file);
        QString pw = requestMpw(false);
        if (pw == "")
                return e_noPw;
        GpasmanFile gp;
        int ret, i;
        PwMerror ret2;
        char *entry[4];
        PwMDataItem tmpData;
        ret = gp.load_init(file->latin1(), pw.latin1());
        if (ret != 1)
                return e_accessFile;
        do {
                ret = gp.load_entry(entry);
                if(ret != 1)
                        break;
                tmpData.desc = entry[0];
                tmpData.name = entry[1];
                tmpData.pw = entry[2];
                tmpData.comment = entry[3];
                tmpData.lockStat = true;
                tmpData.listViewPos = -1;
                ret2 = addEntry(DEFAULT_CATEGORY, &tmpData, true);
                for (i = 0; i < 4; ++i)
                        free(entry[i]);
                if (ret2 == e_maxAllowedEntr) {
                        gp.load_finalize();
                        return e_maxAllowedEntr;
                }
        } while (1);
        gp.load_finalize();
        if (isDocEmpty())
                return e_wrongPw; // we assume this.
        flagDirty();
        return e_success;
 }
 //US: we use the stl sort algorythm to sort all elements in the order 
 //of its listViewPos (in the order 1,2,3,5,...,x,-1, -1, -1
 struct PwMDataItemListViewPosSort
 {
  bool operator()(PwMDataItem* rpStart, PwMDataItem* rpEnd)
  {
    //qDebug("pwMDoc::PwMDataItemListViewPosSort()");
    if ((rpEnd)->listViewPos < 0)
        return false;
    else
      return (rpStart)->listViewPos < (rpEnd)->listViewPos;
  }
 };
 void PwMDoc::ensureLvp()
 {
        if (isDocEmpty())
                return;
        //US ENH BUG: when using syncronizing, this way of sorting
        //is not sufficient, because there might be empty spaces
        // at the beginning. But the old algorythm only can add elements
        //to the end.The result are crashes because of list overflows
        //we need something to fill all gaps.
        vector<PwMDataItem*> sorted;
        vector< PwMDataItem*>::iterator sortedBegin,
                                        sortedEnd,
                                        sortedI;
        vector<PwMCategoryItem>::iterator catBegin = dti.dta.begin(),
                                          catEnd = dti.dta.end(),
                                          catI = catBegin;
        vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
        int lvpTop, tmpLvp;
        //qDebug("collect:"); 
        while (catI != catEnd) {
                lvpTop = -1;
                sorted.clear();
                entrBegin = catI->d.begin();
                entrEnd = catI->d.end();
                entrI = entrBegin;
                //US: we use the stl sort algorythm to sort all elements in the order 
                //of its listViewPos (in the order 1,2,2,3,5,...,x,-1, -1, -1
                while (entrI != entrEnd) {
                  //qDebug("found: %s, pos=%i", (*entrI).desc.c_str(), (*entrI).listViewPos);
                  sorted.push_back((PwMDataItem*)&(*entrI));
                  ++entrI;
                }
                sortedBegin = sorted.begin();
                sortedEnd = sorted.end();
                sort(sortedBegin, sortedEnd, PwMDataItemListViewPosSort());
                        //      qDebug("resort:"); 
                //now we have all sorted in a collection
                //Now start with the sorted and reset listviewpos.
                sortedBegin = sorted.begin();
                sortedEnd = sorted.end();
                sortedI = sortedBegin;
                while (sortedI != sortedEnd) {
                          //      qDebug("reset defined: %s, from pos=%i to pos=%i", (*sortedI)->desc.c_str(), (*sortedI)->listViewPos, lvpTop+1);
                  (*sortedI)->listViewPos = ++lvpTop;
                  ++sortedI;
                }
                /*/debug
                entrBegin = catI->d.begin();
                entrEnd = catI->d.end();
                entrI = entrBegin;
                while (entrI != entrEnd) {
                  qDebug("check: %s, pos=%i", (*entrI).desc.c_str(), (*entrI).listViewPos);
                  ++entrI;
                }
                */
                ++catI;
        }
 }
 QString PwMDoc::getTitle()
 {
        /* NOTE: We have to ensure, that the returned title
         *       is unique and not reused somewhere else while
         *       this document is valid (open).
         */
        QString title(getFilename());
        //US ENH: The whole filename on PDAs is too long. So use only the last characters
        if (QApplication::desktop()->width() < 640)
        {
          if (title.length() > 30)
            title = "..." + title.right(30);
        }
        if (title.isEmpty()) {
                if (unnamedNum == 0) {
                        unnamedNum = PwMDocList::getNewUnnamedNumber();
                        PWM_ASSERT(unnamedNum != 0);
                }
                title = DEFAULT_TITLE;
                title += " ";
                title += tostr(unnamedNum).c_str();
        }
        return title;
 }
 bool PwMDoc::tryDelete()
 {
 
        if (deleted)
                return true;
        int ret;
        if (isDirty()) {
                ret = dirtyAskSave(getTitle());
                if (ret == 0) { // save to disk
                        if (!saveDocUi(this))
                                goto out_ignore;
                } else if (ret == 1) { // don't save and delete
                        goto out_accept;
                } else { // cancel operation
                        goto out_ignore;
                }
        }
 out_accept:
        deleted = true;
        delete this;
        return true;
 out_ignore:
        return false;
 }
 #ifdef PWM_EMBEDDED
 //US ENH: this is the magic function that syncronizes the this doc with the remote doc
 //US it could have been defined as static, but I did not want to. 
 PwMerror PwMDoc::syncronize(KSyncManager* manager, PwMDoc* syncLocal , PwMDoc* syncRemote, int mode )
 {
  int addedPasswordsLocal = 0;
  int addedPasswordsRemote = 0;
  int deletedPasswordsRemote = 0;
  int deletedPasswordsLocal = 0;
  int changedLocal = 0;
  int changedRemote = 0;
  PwMSyncItem* syncItemLocal;
  PwMSyncItem* syncItemRemote;
  QString mCurrentSyncName = manager->getCurrentSyncName();
  QString mCurrentSyncDevice = manager->getCurrentSyncDevice();
  bool mSyncLauncher = true;
  bool fullDateRange = false;
  int take;
  //    local->resetTempSyncStat();
  QDateTime mLastSync = QDateTime::currentDateTime();
  QDateTime modifiedSync = mLastSync;
  unsigned int index;
  //Step 1. Find syncinfo in Local file and create if not existent.
  bool found = syncLocal->findSyncData(mCurrentSyncDevice, &index);
  if (found == false)
    {
      PwMSyncItem newSyncItemLocal;
      newSyncItemLocal.syncName = mCurrentSyncDevice.latin1();
      newSyncItemLocal.lastSyncDate = mLastSync;
      syncLocal->addSyncDataEntry(&newSyncItemLocal, true);
      found = syncLocal->findSyncData(mCurrentSyncDevice, &index);
      if (found == false) {
        qDebug("PwMDoc::syncronize : newly created local sync data could not be found");
        return e_syncError;
      }
            }
  syncItemLocal = syncLocal->getSyncDataEntry(index); 
  qDebug("Last Sync Local %s ", syncItemLocal->lastSyncDate.toString().latin1());
  //Step 2. Find syncinfo in remote file and create if not existent.
  found = syncRemote->findSyncData(mCurrentSyncName, &index);
  if (found == false)
    {
      qDebug("FULLDATE 1");
      fullDateRange = true;
      PwMSyncItem newSyncItemRemote;
      newSyncItemRemote.syncName = mCurrentSyncName.latin1();
      newSyncItemRemote.lastSyncDate = mLastSync;
      syncRemote->addSyncDataEntry(&newSyncItemRemote, true);
      found = syncRemote->findSyncData(mCurrentSyncName, &index);
      if (found == false) {
        qDebug("PwMDoc::syncronize : newly created remote sync data could not be found");
        return e_syncError;
      }
    }
  
  syncItemRemote = syncRemote->getSyncDataEntry(index); 
  qDebug("Last Sync Remote %s ", syncItemRemote->lastSyncDate.toString().latin1());
  //and remove the found entry here. We will reenter it later again.
  //US  syncRemote->delSyncDataEntry(index, true);
  if ( syncItemLocal->lastSyncDate == mLastSync ) {
    qDebug("FULLDATE 2");
    fullDateRange = true;
  }
  
  if ( ! fullDateRange  ) {
        if ( syncItemLocal->lastSyncDate != syncItemRemote->lastSyncDate ) {
            
            fullDateRange = true;
            qDebug("FULLDATE 3 %s %s", syncItemLocal->lastSyncDate.toString().latin1() , syncItemRemote->lastSyncDate.toString().latin1() );
        } 
    }
    // fullDateRange = true; // debug only!
    if ( fullDateRange )
        mLastSync = QDateTime::currentDateTime().addDays( -100*365);
    else
        mLastSync = syncItemLocal->lastSyncDate;
    qDebug("*************************** ");
    qDebug("mLastSync %s ",mLastSync.toString().latin1() );
    QStringList er = syncRemote->getIDEntryList(); 
    PwMDataItem* inRemote ;//= er.first();
    PwMDataItem* inLocal;
    unsigned int catLocal, indexLocal;
    unsigned int catRemote, indexRemote;
    QString uid;
    manager->showProgressBar(0, i18n("Syncing - close to abort!"), er.count());
    int modulo = (er.count()/10)+1;
    unsigned int incCounter = 0;
    while ( incCounter < er.count()) {
        if (manager->isProgressBarCanceled())
            return e_syncError;
        if ( incCounter % modulo == 0 )
          manager->showProgressBar(incCounter);
        uid = er[ incCounter ]; 
        qDebug("sync uid %s from remote file", uid.latin1());
        qApp->processEvents();
            inLocal = syncLocal->findEntryByID( uid, &catLocal, &indexLocal );
            inRemote = syncRemote->findEntryByID( uid, &catRemote, &indexRemote );
            PWM_ASSERT(inRemote);
            if ( inLocal != 0 ) { // maybe conflict - same uid in both files
                if ( (take = takePwMDataItem( inLocal, inRemote, mLastSync, mode, fullDateRange) ) ) {
                    qDebug("take %d %s ", take, inLocal->desc.c_str());
                    if ( take == 3 )
                        return e_syncError;
                    if ( take == 1  ) {// take local
                        inRemote->syncItem(*inLocal, mSyncLauncher);
                        ++changedRemote;
                    } else { // take == 2  take remote
                        inLocal->syncItem(*inRemote, mSyncLauncher);
                        ++changedLocal;
                    }
                }
            } else { //  no conflict
                    if ( inRemote->meta.update > mLastSync || mode == 5 ) {
                        inRemote->meta.update = modifiedSync;
                        //first check if we have a matching category in the local file
                        const string* remotecat = syncRemote->getCategory(catRemote);
                        syncLocal->addEntry(remotecat->c_str(), inRemote, true, false);
                        ++addedPasswordsLocal;
                    } else {
                        // pending checkExternSyncAddressee(addresseeRSyncSharp, inR);
                        syncRemote->delEntry(catRemote, indexRemote, true);
                        ++deletedPasswordsRemote; 
                    }
            }
        ++incCounter;
    }
    er.clear();
    QStringList el = syncLocal->getIDEntryList(); 
    modulo = (el.count()/10)+1;
    manager->showProgressBar(0, i18n("Add / remove addressees"), el.count());
    incCounter = 0;
    while ( incCounter < el.count()) {
        qApp->processEvents();
        if (manager->isProgressBarCanceled())
            return e_syncError;
        if ( incCounter % modulo == 0 )
          manager->showProgressBar(incCounter);
        uid = el[ incCounter ]; 
        qDebug("sync uid %s from local file", uid.latin1());
        inLocal = syncLocal->findEntryByID( uid, &catLocal, &indexLocal );
        inRemote = syncRemote->findEntryByID( uid, &catRemote, &indexRemote );
        PWM_ASSERT(inLocal);
        if ( inRemote == 0 ) { 
                if ( inLocal->meta.update < mLastSync && mode != 4 ) {
                    // pending checkExternSyncAddressee(addresseeLSyncSharp, inL);
                    syncLocal->delEntry(catLocal, indexLocal, true);
                    ++deletedPasswordsLocal; 
                } else {
                    if ( ! manager->mWriteBackExistingOnly ) {
                        ++addedPasswordsRemote; 
                        inLocal->meta.update = modifiedSync;
                        //first check if we have a matching category in the remote file
                        const string* localcat = syncLocal->getCategory(catLocal);
                        PwMDataItem newEntry;
                        newEntry = *inLocal; 
                        inRemote = &newEntry;
        
                        //USsyncRemote->insertAddressee( inRemote, false );
                        syncRemote->addEntry(localcat->c_str(), inRemote, true, false);
                    }
                }
        }
        ++incCounter;
    }
    el.clear();
    manager->hideProgressBar();
    // Now write the info back into the sync data space of the files
    mLastSync = QDateTime::currentDateTime().addSecs( 1 );
    // get rid of micro seconds
    QTime t =  mLastSync.time();
    mLastSync.setTime( QTime (t.hour (), t.minute (), t.second () )  );
   
    syncItemLocal->lastSyncDate = mLastSync;
    syncItemRemote->lastSyncDate = mLastSync;
    QString mes;
    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 ); 
    if ( manager->mShowSyncSummary ) {
        KMessageBox::information(0, mes, i18n("PWM/Pi Synchronization") );
    }
    qDebug( mes );
  return e_success;
 }
 int PwMDoc::takePwMDataItem( PwMDataItem* local,  PwMDataItem* remote, QDateTime lastSync, int mode , bool full )
 {
    // 0 equal
    // 1 take local
    // 2 take remote
    // 3 cancel 
    QDateTime localMod = local->meta.update;
    QDateTime remoteMod = remote->meta.update;
     if ( localMod == remoteMod )
       return 0;
        
    qDebug(" %d %d conflict on %s %s ", mode, full, local->desc.c_str(), remote->desc.c_str() );
    //qDebug("%s %d  %s %d", local->lastModified().toString().latin1() , localMod, remote->lastModified().toString().latin1(), remoteMod);  
    //qDebug("%d %d %d %d ", local->lastModified().time().second(), local->lastModified().time().msec(),  remote->lastModified().time().second(), remote->lastModified().time().msec() );
    //full = true; //debug only
    if ( full ) {
      bool equ = ( (*local) == (*remote) );
        if ( equ ) {
          //qDebug("equal ");
            if ( mode < SYNC_PREF_FORCE_LOCAL )
                return 0;
              
        }//else //debug only
          //qDebug("not equal %s %s ", local->desc.c_str(), remote->desc.c_str());
    }
    
    int result;
    bool localIsNew;
    //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()  );
    if ( full && mode < SYNC_PREF_NEWEST )
        mode = SYNC_PREF_ASK;
    switch( mode ) {
    case SYNC_PREF_LOCAL:
        if ( lastSync > remoteMod )
            return 1;
        if ( lastSync > localMod )
            return 2;
        return 1;
        break;
    case SYNC_PREF_REMOTE:
        if ( lastSync > remoteMod )
            return 1;
        if ( lastSync > localMod )
            return 2;
        return 2;
        break;
    case SYNC_PREF_NEWEST:
        if ( localMod > remoteMod )
            return 1;
        else
            return 2;
        break;
    case SYNC_PREF_ASK: 
        //qDebug("lsy %s  ---  lo %s  --- re %s ", lastSync.toString().latin1(), localMod.toString().latin1(), remoteMod.toString().latin1()  );
        if ( lastSync > remoteMod )
            return 1;
        if ( lastSync > localMod )
            return 2;
        localIsNew = localMod >= remoteMod;
        //qDebug("conflict! ************************************** ");
        {
          PwMDataItemChooser acd ( *local,*remote, localIsNew , 0/*this*/ );
            result = acd.executeD(localIsNew);
            return result;
        }
        break;
    case SYNC_PREF_FORCE_LOCAL:
        return 1;
        break;
    case SYNC_PREF_FORCE_REMOTE:
        return 2;
        break;
       
    default:
        // SYNC_PREF_TAKE_BOTH not implemented
        break;
    }
    return 0;
 }
 void PwMDoc::removeSyncInfo( QString syncProfile)
 {
-    qDebug("PwMDoc::not implemented: removeSyncInfo for profile %s ", syncProfile.latin1());
+    bool res, found;
+    unsigned int count, i;
+    if ( syncProfile.isEmpty() ) {
+      count = numSyncDataEntries();
+      for (i = count; count > 0; count-- ) {
+        res = delSyncDataEntry(i-1, false);
+        if (res == false) {
+          qDebug("PwMDoc::removeSyncInfo: could not remove syncprofile");
+        }
+      }
+    } else { 
+      found = findSyncData(syncProfile, &count);
+      if (found == true)
+        {
+          res = delSyncDataEntry(count, false);
+          if (res == false) {
+            qDebug("PwMDoc::removeSyncInfo: could not remove %s", syncProfile.latin1());
+          }
+                }
+    }
 }
 //this are the overwritten callbackmethods from the syncinterface
 bool PwMDoc::sync(KSyncManager* manager, QString filename, int mode)
 {
  QString mCurrentSyncDevice = manager->getCurrentSyncDevice();
  //1) unlock local file first if necessary (ask for password)
  if (this->isDeepLocked()) {
    PwMerror ret = this->deepLock(false);
    if (ret != e_success)
      return false;
  }
  //2)  construct and open a new doc on the stack(automatic cleanup of remote file).
  PwMDoc syncTarget(this, "synctarget");
  PwMDoc* pSyncTarget = &syncTarget;
  PwMerror err = pSyncTarget->openDoc(&filename, 1 /*== open with all entries locked*/);
  if (err == e_alreadyOpen) {
    PwMDocList::listItem li;
    if (getOpenDocList()->find(filename.latin1(), &li))
      pSyncTarget = li.doc;
    else {
      qDebug("PwmDoc::sync: sync failed. Error %i while opening file %s",err, filename.latin1());
      return false;
    }
  }
  else if (err != e_success) {
    qDebug("PwmDoc::sync: sync failed. Error %i while opening file %s",err, filename.latin1());
    return false;
  }
  qDebug("PWM file loaded %s,sync mode %d",filename.latin1(), mode );
  //3) unlock remote file first if necessary (ask for password)
  if (pSyncTarget->isDeepLocked()) {
    PwMerror ret = pSyncTarget->deepLock(false);
    if (ret != e_success)
      return false;
  }
  
  err = syncronize(manager, this, pSyncTarget, mode );
  if (err == e_success) {
            if ( manager->mWriteBackFile ){
      qDebug("Saving remote PWManager file");
      err = pSyncTarget->saveDoc(conf()->confGlobCompression());
      if (err != e_success) {
        qDebug("PwmDoc::sync: Sync failed. Error %i while storing file %s",err, filename.latin1());
        return false;
      }
    }
    flagDirty();
    return true;
  }
  else {
    return false;
  }
 }
 #endif
 bool PwMDoc::findSyncData(const QString &syncname, unsigned int *index)
 {
        vector<PwMSyncItem>::iterator i = dti.syncDta.begin(), 
                                      end = dti.syncDta.end();
        while (i != end) {
                if ((*i).syncName == syncname.latin1()) {
                        if (index) {
                                *index = i - dti.syncDta.begin();
                        }
                        return true;
                }
                ++i;
        }
        return false;
 };
 /** add new syncdataentry */
 PwMerror PwMDoc::addSyncDataEntry(PwMSyncItem *d, bool dontFlagDirty)
 {
        PWM_ASSERT(d);
        if (isDeepLocked()) {
                PwMerror ret;
                ret = deepLock(false);
                if (ret != e_success)
                        return e_lock;
        }
        unsigned int index;
        const QString tmp = d->syncName.c_str();
        bool exists = findSyncData(d->syncName.c_str(), &index);
        if (exists == true) {
                // DOH! We found this entry.
                return e_entryExists;
        }
        dti.syncDta.push_back(*d);
        if (!dontFlagDirty)
                flagDirty();
        return e_success;
 }
 /** delete syncdata entry */
 bool PwMDoc::delSyncDataEntry(unsigned int index, bool dontFlagDirty)
 {
        if (isDeepLocked())
                return false;
        if (index > dti.syncDta.size() - 1)
                return false;
        // delete entry
        dti.syncDta.erase(dti.syncDta.begin() + index);
        if (!dontFlagDirty)
                flagDirty();
        return true;
 }
 PwMDataItem* PwMDoc::findEntryByID(const QString &uid, unsigned int *category, unsigned int *index)
 {
  vector<PwMCategoryItem>::iterator catcounter = dti.dta.begin(),
                                  catend = dti.dta.end();
  vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
  while (catcounter != catend) {
    entrBegin = catcounter->d.begin();
    entrEnd = catcounter->d.end();
    entrI = entrBegin;
    while (entrI != entrEnd) {
      if ((*entrI).meta.uniqueid == uid.latin1()) {
        if (category)
          *category = catcounter - dti.dta.begin();
        if (index)
          *index = entrI - entrBegin;
        return &(*entrI);
      }
      ++entrI;
    }
    ++catcounter;
  }
  return 0;
 }
 QStringList PwMDoc::getIDEntryList()
 {
  QStringList results;
  vector<PwMCategoryItem>::iterator catcounter = dti.dta.begin(),
                                  catend = dti.dta.end();
  vector<PwMDataItem>::iterator entrBegin, entrEnd, entrI;
  while (catcounter != catend) {
    entrBegin = catcounter->d.begin();
    entrEnd = catcounter->d.end();
    entrI = entrBegin;
    while (entrI != entrEnd) {
      results.append( (*entrI).meta.uniqueid.c_str() );
      ++entrI;
    }
    ++catcounter;
  }
  return results;
 }
 #ifndef PWM_EMBEDDED
 #include "pwmdoc.moc"
 #endif
diff --git a/pwmanager/pwmanager/pwmdoc.h b/pwmanager/pwmanager/pwmdoc.h
index ef81dfc..138dd3d 100644
--- a/pwmanager/pwmanager/pwmdoc.h
+++ b/pwmanager/pwmanager/pwmdoc.h
@@ -1,823 +1,827 @@
 /***************************************************************************
 *                                                                         *
 *   copyright (C) 2003, 2004 by Michael Buesch                            *
 *   email: mbuesch@freenet.de                                             *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License version 2        *
 *   as published by the Free Software Foundation.                         *
 *                                                                         *
 ***************************************************************************/
 /***************************************************************************
 * copyright (C) 2004 by Ulf Schenk
 * This file is originaly based on version 1.1 of pwmanager
 * and was modified to run on embedded devices that run microkde
 *
 * $Id$
 **************************************************************************/  
 #ifndef __PWMDOC_H
 #define __PWMDOC_H
 #ifdef _WIN32_
 #define ssize_t unsigned int
 #endif
        #define PWM_FILE_VER    (static_cast<char>(0x05))
        #define PWM_HASH_SHA1   (static_cast<char>(0x01))
        #define PWM_HASH_SHA256         (static_cast<char>(0x02))
        #define PWM_HASH_SHA384         (static_cast<char>(0x03))
        #define PWM_HASH_SHA512         (static_cast<char>(0x04))
        #define PWM_HASH_MD5    (static_cast<char>(0x05))
        #define PWM_HASH_RMD160         (static_cast<char>(0x06))
        #define PWM_HASH_TIGER  (static_cast<char>(0x07))
        #define PWM_CRYPT_BLOWFISH(static_cast<char>(0x01))
        #define PWM_CRYPT_AES128(static_cast<char>(0x02))
        #define PWM_CRYPT_AES192(static_cast<char>(0x03))
        #define PWM_CRYPT_AES256(static_cast<char>(0x04))
        #define PWM_CRYPT_3DES  (static_cast<char>(0x05))
        #define PWM_CRYPT_TWOFISH(static_cast<char>(0x06))
        #define PWM_CRYPT_TWOFISH128(static_cast<char>(0x07))
        #define PWM_COMPRESS_NONE(static_cast<char>(0x00))
        #define PWM_COMPRESS_GZIP(static_cast<char>(0x01))
        #define PWM_COMPRESS_BZIP2(static_cast<char>(0x02))
        #define DEFAULT_MAX_ENTRIES(~(static_cast<unsigned int>(0)))
        #define FILE_ID_HEADER  "PWM_PASSWORD_FILE"
 #include "pwmexception.h"
 #include "pwmdocui.h"
 #include <qobject.h>
 #include <qtimer.h>
 #include <qdatetime.h>
 #include <kprocess.h>
 #ifndef PWM_EMBEDDED
 #include "configuration.h"
 #else
 #include <kapplication.h>
 #include <ksyncmanager.h>
 #endif
 #include <string>
 #include <vector>
 #include <utility>
 using std::vector;
 using std::string;
 using std::pair;
 /* used in findEntry() function */
        #define SEARCH_IN_DESC  (1)
        #define SEARCH_IN_NAME  (1 << 1)
        #define SEARCH_IN_PW    (1 << 2)
        #define SEARCH_IN_COMMENT(1 << 3)
        #define SEARCH_IN_URL   (1 << 4)
        #define SEARCH_IN_LAUNCHER(1 << 5)
        #define SEARCH_IN_ALL           (SEARCH_IN_DESC         | SEARCH_IN_NAME|  \
                                         SEARCH_IN_PW   | SEARCH_IN_COMMENT|  \
                                         SEARCH_IN_URL| SEARCH_IN_LAUNCHER)
 /** document deeplocked. Data is out for lunch to disk */
        #define DOC_STAT_DEEPLOCKED     (1)
 /** encrypted document on disk is dirty. data has to go to disk. */
        #define DOC_STAT_DISK_DIRTY     (1 << 1)
 /** we are using a chipcard to encrypt the data */
        #define DOC_STAT_USE_CHIPCARD   (1 << 2)
 /** use "currentPw" to unlock. (This flag is set/unset by a timer) */
        #define DOC_STAT_UNLOCK_WITHOUT_PW(1 << 3)
 class PwMDoc;
 class PwMView;
 class QFile;
 /* meta data for a PwMDataItem */
 struct PwMMetaData
 {
        PwMMetaData()
         : updateInt (0)
                { }
        /** creation date of the PwMDataItem to which
          * this meta data belongs.
          */
                QDateTimecreate;
        /** becomes valid on this date */
                QDateTimevalid;
        /** expire date */
                QDateTimeexpire;
        /** update date (last updated at this date) */
                QDateTimeupdate;
        /** update interval (in minutes). Time since the
          * last update to remind the user to update the item.
          * 0 disables.
          */
        unsigned long updateInt;
 
        //US ENH: enhancements of the filestructure
        /* each entry gets a unique id assigned  */
        string  uniqueid;
        void clear()
                {
                        create = QDateTime();
                        expire = QDateTime();
                        update = QDateTime();
                        updateInt = 0;
                        uniqueid = KApplication::randomString(8).latin1();
                }
        inline bool isValid() const
                {
                        if (valid.isNull())
                                return true;
                        return (valid < QDateTime::currentDateTime());
                }
        inline bool isExpired() const
                {
                        if (expire.isNull())
                                return false;
                        return (expire < QDateTime::currentDateTime());
                }
        inline bool isUpdateIntOver() const
                {
                        if (updateInt == 0 ||
                            update.isNull())
                                return false;
                        QDateTime d(update);
                        return (d.addSecs(updateInt * 60) < QDateTime::currentDateTime());
                }
 };
 struct PwMDataItem
 {
        PwMDataItem()
         : lockStat (true)
         , listViewPos (-1)
         , binary (false)
         , rev (0)
                { }
        /** password description */
                stringdesc;
        /** user-name */
                stringname;
        /** the password itself */
                stringpw;
        /** some comment */
                stringcomment;
        /** an URL string */
                stringurl;
        /** launcher. Can be executed as a system() command */
                stringlauncher;
        /** locking status. If locked (true), pw is not emitted through getEntry() */
                boollockStat;
        /** position of this item in main "list-view"
          * If -1, the position is not yet specified and should be appended to the list
          */
                intlistViewPos;
        /** does this entry contain binary data? */
        bool binary;
        /** meta data for this data item. */
        PwMMetaData meta;
        /** data revision counter. This counter can be used
          * to easily, efficiently determine if this data item
          * has changed since some time.
          * This counter is incremented on every update.
          */
        unsigned int rev;
        void clear(bool clearMeta = true)
        {
                /* NOTE: Don't use .clear() here to be
                 *       backward compatible with gcc-2 (Debian Woody)
                 */
                desc = "";
                name = "";
                pw = "";
                comment = "";
                url = "";
                launcher = "";
                lockStat = true;
                listViewPos = -1;
                binary = false;
                if (clearMeta)
                        meta.clear();
        }
  //US ENH: we need this operator to compare two items if we have no unique ids
  //available. Generaly this happens before the first sync
        bool PwMDataItem::operator==( const PwMDataItem &a ) const
        {
          //qDebug("oper==%s", a.desc.c_str());
          if ( desc != a.desc ) return false;
          if ( name != a.name ) return false;
          if ( pw != a.pw ) return false;
          if ( comment != a.comment ) return false;
          if ( url != a.url ) return false;
          if ( launcher != a.launcher ) return false;
          //all other field will not be checked.
          return true;
        }
  //US ENH: this sync method actually copies all values from the parameter like the =operator
  //does with two exceptions: listViewPos will not be changed, and the launcher only if required.
  bool PwMDataItem::syncItem(const PwMDataItem &a, bool syncLauncher=true )
  {
    desc = a.desc;
    name = a.name;
    pw = a.pw;
    comment = a.comment;
    url = a.url;
    if (syncLauncher == true)
      launcher = a.launcher;
    meta = a.meta;
    binary = a.binary;
    lockStat = a.lockStat;
    rev = a.rev;
    return true;
  }
 };
 struct PwMCategoryItem
 {
        /** all PwMDataItems (all passwords) within this category */
                vector<PwMDataItem>d;
        /** category name/description */
                string          name;
        //US ENH: enhancements of the filestructure
        /* each category stores the text for description,name and password */
        string  desc_text;
        string  name_text;
        string  pw_text;
 
        void clear()
        {
                d.clear();
                name = "";
                desc_text = "Description";
                name_text = "Username";
                pw_text = "Password";
        }
 };
 struct PwMSyncItem
 {
  string syncName;
  QDateTime lastSyncDate;
  
  void clear()
        {
                lastSyncDate = QDateTime();
                syncName = "";
        }
 };
 struct PwMItem
 {
  vector<PwMCategoryItem> dta;
  vector<PwMSyncItem> syncDta;
  void clear()
        {
                dta.clear();
                syncDta.clear(); 
        }
 };
 /** "Function Object" for sort()ing PwMDataItem::listViewPos */
 class dta_lvp_greater
 {
 public:
        bool operator() (const pair<unsigned int, unsigned int> &d1,
                         const pair<unsigned int, unsigned int> &d2)
        {
                return d1.second > d2.second;
        }
 };
 /** list of PwMDoc documents and it's IDs */
 class PwMDocList
 {
 public:
        struct listItem
        {
                /** document filename (known as ID, here) */
                string docId;
                /** pointer to the document class */
                PwMDoc *doc;
        };
        PwMDocList() {}
        /** add a new item to the list */
        void add(PwMDoc *doc, const string &id);
        /** changes the contents of an existing item */
        void edit(PwMDoc *doc, const string &newId);
        /** remove the given item */
        void del(PwMDoc *doc);
        /** get the item at index */
        listItem getAt(int index)
                        { return docList[index]; }
        /** find an entry with this id */
        bool find(const string &id, listItem *ret = 0);
        /** returns a copy of the list */
        const vector<listItem>* getList() const
                        { return &docList; }
        /** returns a new unique number to extend the name of
          * an unnamed document.
          */
        static unsigned int getNewUnnamedNumber()
                        { return unnamedDocCnt++; }
 protected:
        /* Hm, I think we shouldn't really use a "list" here, should we?
         * So I decided to actually use a vector.
         */
        vector<listItem> docList;
        /** This value is used to get a new number for yet unnamed
          * documents. It is incremented on every request. So it's
          * theoretically possible to overflow it, but... :)
          */
        static unsigned int unnamedDocCnt;
 };
 /** implements timers for the document */
 class DocTimer : public QObject
 {
        Q_OBJECT
 public:
        enum TimerIDs
        {
                id_mpwTimer,
                id_autoLockTimer,
                id_metaCheckTimer
        };
 public:
        DocTimer(PwMDoc *_doc);
        ~DocTimer();
        /** start the timer */
        void start(TimerIDs timer);
        /** stop the timer */
        void stop(TimerIDs timer);
        /** get the lock for a timer.
          * This lock is a recursive lock. When a lock is
          * held, the timer will be stopped and timeout is
          * guaranteed to not happen
          */
        void getLock(TimerIDs timer);
        /** put a recursive timer lock */
        void putLock(TimerIDs timer);
 protected slots:
        /** timeout slot for the mpw timer */
        void mpwTimeout();
        /** timeout slot for the autoLock timer */
        void autoLockTimeout();
        /** timeout slot for the metaCheck timer */
        void metaCheckTimeout();
 protected:
        /** pointer to the document associated with this timer. */
        PwMDoc *doc;
        /** timer object for mpw timer */
        QTimer *mpwTimer;
        /** timer object for the autoLock timer */
        QTimer *autoLockTimer;
        /** timer object for the metaCheck timer */
        QTimer *metaCheckTimer;
        /** lock counter for the mpw timer */
        unsigned int mpwLock;
        /** lock counter for the autoLock timer */
        unsigned int autoLockLock;
        /** lock counter for the metaCheck timer */
        unsigned int metaCheckLock;
 };
 /** Document class for PwM */
 //US ENH: derived from KSyncInterfaces, to get called by PwM when a sync is required.
 // But PwMDoc is handling the sync by itself.
 class PwMDoc : public PwMDocUi, public KSyncInterface
 {
        Q_OBJECT
        friend class DocTimer;
 public:
        /** construtor */
        PwMDoc(QObject* parent = 0, const char *name = 0);
        /** destructor */
        ~PwMDoc();
        /** returns a pointer to a list of all open documents */
        static PwMDocList* getOpenDocList()
                        { return &openDocList; }
        /** flag document dirty. dta changed */
        void flagDirty()
                {
                        setDocStatFlag(DOC_STAT_DISK_DIRTY);
                        emitDataChanged(this);
                }
        /** modified? */
        bool isDirty()
                        { return getDocStatFlag(DOC_STAT_DISK_DIRTY); }
        /** save document to disk */
        PwMerror saveDoc(char compress, const QString *file = 0);
        /** read document from file.
          * "openLocked is must be set to either of these values:
          *  0 == open with all entries unlocked
          *  1 == open with all entries locked
          *  2 == open deep-locked
          */
        PwMerror openDoc(const QString *file, int openLocked);
        /** export document to ascii-textfile */
        PwMerror exportToText(const QString *file);
        /** export document to gpasman / kpasman file */
        PwMerror exportToGpasman(const QString *file);
        /** import document from ascii-textfile */
        PwMerror importFromText(const QString *file, int format = -1);
        /** import document from gpasman / kpasman file */
        PwMerror importFromGpasman(const QString *file);
        /** add new entry */
        PwMerror addEntry(const QString &category, PwMDataItem *d,
                          bool dontFlagDirty = false, bool updateMeta = true);
        /** add new category. This function doesn't flag the document dirty! */
        PwMerror addCategory(const QString &category, unsigned int *categoryIndex,
                             bool checkIfExist = true);
        /** rename an existing category */
        bool renameCategory(const QString &category, const QString &newName);
        /** rename an existing category */
        bool renameCategory(unsigned int category, const QString &newName,
                            bool dontFlagDirty = false);
        /** delete an existing category */
        bool delCategory(const QString &category);
        /** delete an existing category */
        bool delCategory(unsigned int category, bool dontFlagDirty = false);
        /** returns a list of all category-names */
        void getCategoryList(vector<string> *list);
        /** returns a list of all category-names */
        void getCategoryList(QStringList *list);
        /** returns a list of all entry-descs in the given category */
        void getEntryList(const QString &category, QStringList *list);
        /** returns a list of all entry-descs in the given category */
        void getEntryList(const QString &category, vector<string> *list);
        /** returns a list of all entry-descs in the given category */
        void getEntryList(unsigned int category, vector<string> *list);
        /** returns a list of all entry-descs in the given category */
        void getEntryList(unsigned int category, QStringList *list);
        /** delete entry */
        bool delEntry(const QString &category, unsigned int index, bool dontFlagDirty = false);
        /** delete entry */
        bool delEntry(unsigned int category, unsigned int index, bool dontFlagDirty = false);
        /** edit entry */
        bool editEntry(const QString &oldCategory, const QString &newCategory,
                       unsigned int index, PwMDataItem *d, bool updateMeta = true);
        /** edit entry */
        bool editEntry(unsigned int oldCategory, const QString &newCategory,
                       unsigned int index, PwMDataItem *d, bool updateMeta = true);
        /** finds the category with the "name" and return it's index */
        bool findCategory(const QString &name, unsigned int *index);
        /** search for an entry "find" and check while searching only for
          * the data-fields specified by "searchIn". To set the "searchIn"
          * value, we may use one or more of the SEARCH_IN_* defines at
          * the top of this header-file. It returns the positions of all
          * matched entries in "foundPositions". If "breakAfterFound" is true,
          * the function terminates after the first occurence of the entry
          * and doesn't go on searching. So foundPositions->size() is never
          * > 1 if breakAfterFound is true.
          */
        void findEntry(unsigned int category, PwMDataItem find, unsigned int searchIn,
                       vector<unsigned int> *foundPositions, bool breakAfterFound = false,
                       bool caseSensitive = true, bool exactWordMatch = true,
                       bool sortByLvp = false);
        /** see the above funtion. This function allows to set the category by name. */
        void findEntry(const QString &category, PwMDataItem find, unsigned int searchIn,
                       vector<unsigned int> *foundPositions, bool breakAfterFound = false,
                       bool caseSensitive = true, bool exactWordMatch = true,
                       bool sortByLvp = false);
        /** returns number of entries */
        unsigned int numEntries(const QString &category);
        unsigned int numEntries(unsigned int category)
                        { return dti.dta[category].d.size(); }
        /** returns number of categories */
        unsigned int numCategories()
                        { return dti.dta.size(); }
        /** returns the name of the category at "index" */
        const string* getCategory(unsigned int index)
                        { return (&(dti.dta[index].name)); }
        /** returns the data of item at "index".
          * It unlocks the entry if it's locked and unlockIfLocked is true.
          * If the entry is locked, but unlockIfLocked is false, it'll not return
          * the pw.
          */
        bool getEntry(const QString &category, unsigned int index,
                      PwMDataItem *d, bool unlockIfLocked = false);
        bool getEntry(unsigned int category, unsigned int index,
                      PwMDataItem *d, bool unlockIfLocked = false);
        /** returns the comment-string by looking at the category
          * and the listViewPos
          */
        PwMerror getCommentByLvp(const QString &category, int listViewPos,
                                 string *foundComment);
        /** checks if a password is already available. (currentPw) */
        bool isPwAvailable()
                        { return (currentPw != ""); }
        /** un/lock entry at "index". If needed, ask for password. */
        bool lockAt(const QString &category, unsigned int index,
                    bool lock = true);
        bool lockAt(unsigned int category, unsigned int index,
                    bool lock = true);
        /** returns the lock-status at "index" */
        bool isLocked(const QString &category, unsigned int index);
        bool isLocked(unsigned int category, unsigned int index)
                        { return dti.dta[category].d[index].lockStat; }
        /** returns the deeplock status */
        bool isDeepLocked()
                        { return getDocStatFlag(DOC_STAT_DEEPLOCKED); }
        /** (un)lock all entries */
        bool lockAll(bool lock);
        /** unlocks all entries tempoarly.
          * 1st NOTE: Be very careful with this function! :)
          * 2nd NOTE: After you have called unlockAll_Tempoary(); ,
          *           please DON'T forget to call unlockAll_Tempoary(true);
          *           _before_ the user (or someone else) is able to change
          *           the document!
          * 3rd NOTE: Please DON'T change "dta" while the data is tempoary
          *           unlocked! This will cause corruption.
          */
        bool unlockAll_tempoary(bool revert = false);
        /** deep-(un)locks the document.
          * deep-locking writes all data to the file, deletes all data
          * in memory, but doesn't close the document.
          * deep-locking is only available, if the user previously saved
          * the doc to a file (with a password).
          * If "saveToFile" is false, it does NOT write the data to the file!
          */
        PwMerror deepLock(bool lock = true, bool saveToFile = true);
        /** is unlockable without pw? */
        bool unlockWoPw()
                        { return getDocStatFlag(DOC_STAT_UNLOCK_WITHOUT_PW); }
        /** get the "currentPassword" */
        const QString& getCurrentPw()
                        { return currentPw; }
        /** open a window and request the user to change the mpw */
        void changeCurrentPw();
        /** set the "listViewPos" variable of "dta" */
        void setListViewPos(const QString &category, unsigned int index,
                            int pos);
        /** set the "listViewPos" variable of "dta" */
        void setListViewPos(unsigned int category, unsigned int index,
                            int pos);
        /** get the "listViewPos" variable of "dta" */
        int getListViewPos(const QString &category, unsigned int index);
        /** set the maximum number of entries allowed */
        void setMaxNumEntries(unsigned int num = DEFAULT_MAX_ENTRIES)
                        { maxEntries = num; }
        /** get the maximum number of entries allowed */
        unsigned int getMaxNumEntries()
                        { return maxEntries; }
        /** ensure all listViewPos of all dta items are set. (are ! -1).
          * If there are some undefined entries, add them to the end of
          * the listViewPos(itions). */
        void ensureLvp();
        /** execute the "launcher" of this entry */
        bool execLauncher(const QString &category, unsigned int entryIndex);
        /** see above */
        bool execLauncher(unsigned int category, unsigned int entryIndex);
        /** open a browser with the URL-section of the given entry */
        bool goToURL(const QString &category, unsigned int entryIndex);
        /** see above */
        bool goToURL(unsigned int category, unsigned int entryIndex);
        /** returns true if there is no entry present in the document.
          * Note: The "default" Category is present everytime, so
          *       it's checked for it's entries.
          */
        bool isDocEmpty()
                {
                        if (numCategories() > 1)
                                return false;
                        if (numEntries(0))
                                return false;
                        return true;
                }
        /** returns the filename of this doc */
        const QString& getFilename()
                        { return filename; }
        /** returns the title of the doc */
        QString getTitle();
        /** sets the list-view-pointer hold in the doc */
        void setListViewPointer(PwMView *_listView)
                        { listView = _listView; }
        /** returns the list-view-pointer */
        PwMView * getListViewPointer()
                        { return listView; }
        /** try to delete the doc. The user may be asked to save
          * the data. The user may cancel the whole operation.
          * false is returned, then.
          */
        bool tryDelete();
        /** is the doc deleted? (with tryDelete() ) */
        bool isDeleted()
                        { return deleted; }
        /** returns the document timer object */
        DocTimer * timer()
                        { return _timer; }
        /** get a lock on the dataChanged signal.
          * If someone is holding a lock, the signal is not emitted.
          */
        void getDataChangedLock()
                        { ++dataChangedLock; }
        /** put the dataChanged lock */
        void putDataChangedLock()
                        { --dataChangedLock; }
        /** returns the revision count of the item at cat/index */
        unsigned int getEntryRevCnt(unsigned int category, unsigned int index)
                        { return dti.dta[category].d[index].rev; }
        /** returns a const pointer to the entries meta */
        const PwMMetaData * getEntryMeta(unsigned int category, unsigned int index)
                        { return &(dti.dta[category].d[index].meta); }
        /** is the entry at "category" "index" a binary entry? */
        bool isBinEntry(unsigned int category, unsigned int index)
                        { return dti.dta[category].d[index].binary; }
 public slots:
        /** wrapper for PwMTray */
        void _deepUnlock();
 signals:
        /** the data of the document has changed and must be updated
          * in all views.
          * NOTE: use emitDataChanged(PwMDoc *document) to emit this signal!
          */
        void dataChanged(PwMDoc *document);
        /** the document class is going to close. This signal may be
          * used to nofify all views, that the user closed the document,
          * so the views can go down, too.
          */
        void docClosed(PwMDoc *document);
        /** somebody just opened the document */
        void docOpened(PwMDoc *document);
        /** this document object just got created */
        void docCreated(PwMDoc *document);
 public:
        /** emit the dataChanged signal after checking for a lock */
        void emitDataChanged(PwMDoc *document)
                {
                        if (!dataChangedLock)
                                emit dataChanged(document);
                }
 protected:
        /** current file for this doc */
        QString filename;
 //US ENH: we need a place where we keep the syncentries. So I invented
 // struct PwMItem, that has a vector of PwMCategoryItem and vector of PwMSyncItem 
        /** holds all data */
        PwMItem dti;
        /** maximum number of entries */
        unsigned int maxEntries;
        /** currently used password to encrypt data */
        QString currentPw;
        /** current global document status flags */
        unsigned int curDocStat;
        /** browser process for goToURL() */
        KProcess browserProc;
        /** pointer to the list-view, using this document.
          * As there can only be one list-view per doc, we
          * don't need a list here.
          */
        PwMView *listView;
        /** unnamedNum is used to store the "unnamed counter"
          * for this document, while it's unnamed. If it's 0,
          * we have to get a new unique one.
          */
        unsigned int unnamedNum;
        /** is this doc going to be deleted (executing in destructor context) */
        bool deleted;
        /** document timer */
        DocTimer *_timer;
        /** lock counter for the "dataChanged" signal */
        unsigned int dataChangedLock;
        /** list of all open documents */
        static PwMDocList openDocList;
 protected:
        /** serialize "dta" and return it in "d". */
        bool serializeDta(string *d);
        /** de-serialize "d" and overwrite "dta" */
        bool deSerializeDta(const string *d, bool entriesLocked);
        /** write header to file */
        PwMerror writeFileHeader(char keyHash, char dataHash, char crypt, char compress,
                                 QString *pw, QFile *f);
        /** write data-hash to file */
        PwMerror writeDataHash(char dataHash, string *d, QFile *f);
        /** check header. Read header info and verify key-hash and filever.
          * returns length of header in "headerLength" */
        PwMerror checkHeader(char *cryptAlgo, QString *pw, char *compress,
                             unsigned int *headerLength, char *dataHashType,
                             string *dataHash, QFile *f);
        /** check the data-hash */
        PwMerror checkDataHash(char dataHashType, const string *dataHash, const string *dataStream);
        /** encrypt data "d" and write to "filename" */
        PwMerror encrypt(string *d, const QString *pw, QFile *f, char algo);
        /** read data from file beginning at "pos", decrypt and return it */
        PwMerror decrypt(string *d, unsigned int pos, const QString *pw, char algo, QFile *f);
        /** compress the data */
        bool compressDta(string *d, char algo);
        /** uncompress the data */
        bool decompressDta(string *d, char algo);
        /** internal import function for a text-file generated by PwM.
          * If this is not a valid PwM-exported file, it returns e_fileFormat */
        PwMerror importText_PwM(const QString *file);
        /** PwM-text-import helper function to extract the name/pw/comment out
          * of one entry-line */
        bool textExtractEntry_PwM(const char *in, ssize_t in_size, string *out);
        /** compare two strings */
        bool compareString(const string &s1, const string &s2, bool caseSensitive,
                           bool exactWordMatch);
        /** clears all document-data */
        void clearDoc();
        /** delete all empty categories */
        void delAllEmptyCat(bool dontFlagDirty);
        /** set a document status flag */
        void setDocStatFlag(unsigned int statFlag)
                        { curDocStat |= statFlag; }
        /** unset a document status flag */
        void unsetDocStatFlag(unsigned int statFlag)
                        { curDocStat &= ~statFlag; }
        /** get a document status flag */
        bool getDocStatFlag(unsigned int statFlag) const
                        { return (curDocStat & statFlag); }
        /** set the "currentPassword" */
        void setCurrentPw(const QString &pw)
                {
                        currentPw = pw;
                        setDocStatFlag(DOC_STAT_DISK_DIRTY);
                }
        /** make a backup-copy of the given file */
        bool backupFile(const QString &filePath);
        /** copy a file from src to dst */
        bool copyFile(const QString &src, const QString &dst);
 public:
 #ifdef PWM_EMBEDDED
        //US ENH: this is the magic function that syncronizes the local doc with the remote doc.
        PwMerror syncronize(KSyncManager* manager, PwMDoc* syncLocal, PwMDoc* syncRemote, int mode );
        //takePwMDataItem returns the following values
        // 0 equal
        // 1 take local
        // 2 take remote
        // 3 cancel 
        int takePwMDataItem( PwMDataItem* local,  PwMDataItem* remote, QDateTime lastSync, int mode , bool full );
        //the following methods are the overwritten callbackmethods from the syncinterface
        virtual bool sync(KSyncManager* manager, QString filename, int mode);
    virtual void removeSyncInfo( QString syncProfile);
 #endif
        //US ENH: helpermethods to return a whole category entry
        /** returns a pointer to the categoryitem */
        PwMCategoryItem* getCategoryEntry(unsigned int index)
                        { return &(dti.dta[index]); }
 private:
        //US ENH: helpermethods to access the sync data for a certain syncname.
        // It returns the syncdatas index
        bool findSyncData(const QString &syncname, unsigned int *index);
        /** add new syncdataentry */
        PwMerror addSyncDataEntry(PwMSyncItem *d, bool dontFlagDirty = false);
        /** returns a pointer to the syncdata */
        PwMSyncItem* getSyncDataEntry(unsigned int index)
                        { return &(dti.syncDta[index]); }
        /** delete entry */
        bool delSyncDataEntry(unsigned int index, bool dontFlagDirty = false);
+        /** returns number of categories */
+        unsigned int numSyncDataEntries()
+                        { return dti.syncDta.size(); }
        PwMDataItem* findEntryByID(const QString &uid, unsigned int *category, unsigned int *index);
        QStringList getIDEntryList(); 
 };
 #endif