Fixed nasty PwM/Pi file reading bug, when

the used hash algo of file is different then the global
hash algo.
CVS ----------------------------------------------------------------------

4 files changed, 46 insertions, 19 deletions

diff --git a/pwmanager/pwmanager/libgcryptif.cpp b/pwmanager/pwmanager/libgcryptif.cpp
index ff94bf6..15f6cef 100644
--- a/pwmanager/pwmanager/libgcryptif.cpp
+++ b/pwmanager/pwmanager/libgcryptif.cpp
@@ -1,454 +1,463 @@
 /***************************************************************************
  *                                                                         *
  *   copyright (C) 2004 by Michael Buesch                                  *
  *   email: mbuesch@freenet.de                                             *
  *                                                                         *
  *   hashPassphrase() is derived from GnuPG and is                         *
  *   Copyright (C) 1998, 1999, 2000, 2001, 2003                            *
  *   Free Software Foundation, Inc.                                        *
  *                                                                         *
  *   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$
  **************************************************************************/  
 
 #include "libgcryptif.h"
 
 #ifdef CONFIG_PWMANAGER_GCRY
 
 #include "pwmdoc.h"
 #include "randomizer.h"
 
 #include <gcrypt.h>
 
 #ifdef PWM_EMBEDDED
 #include <pwmprefs.h>
 #endif
 
 
 PwMerror LibGCryptIf::encrypt(unsigned char **outBuf,
 			      size_t *outBufLen,
 			      unsigned char *inBuf,
 			      size_t inBufLen,
 			      const unsigned char *key,
 			      size_t keylen,
-			      char _algo)
+			      char _algo,
+			      char _hashalgo //US BUG: pass _hashalgo because we need it in hashPassphrase
+			      )
 {
 	PwMerror ret = e_success;
 	gcry_error_t err;
 	gcry_cipher_hd_t handle;
 	size_t blklen;
 	size_t unpaddedLen = inBufLen;
 	size_t cipherKeylen;
 	unsigned char *hashedKey;
 	unsigned char salt[STRING2KEY_SALTLEN];
 	int algo = mapCipherId(_algo);
 
 	if (!inBufLen || !keylen)
 		return e_invalidArg;
 
 	// test if algo is ready for encryption
 	err = gcry_cipher_algo_info(algo,
 				    GCRYCTL_TEST_ALGO,
 				    0, 0);
 	if (err != GPG_ERR_NO_ERROR) {
 		printDebug(string("LibGCryptIf::doEncrypt(): GCRYCTL_TEST_ALGO failed: ")
 			   + gcry_strerror(err));
 		ret = e_cryptNotImpl;
 		goto out;
 	}
 	// get the algo block length
 	err = gcry_cipher_algo_info(algo,
 				    GCRYCTL_GET_BLKLEN,
 				    0,
 				    &blklen);
 	if (err != GPG_ERR_NO_ERROR) {
 		printDebug(string("LibGCryptIf::doEncrypt(): GCRYCTL_GET_BLKLEN failed: ")
 			   + gcry_strerror(err));
 		ret = e_cryptNotImpl;
 		goto out;
 	}
 	/* double check if we have enough space.
 	 * We have only 1024 extra bytes for padding and salt.
 	 */
 	BUG_ON(blklen > 1024 - STRING2KEY_SALTLEN);
 	// get the algo key length
 	err = gcry_cipher_algo_info(algo,
 				    GCRYCTL_GET_KEYLEN,
 				    0,
 				    &cipherKeylen);
 	if (err != GPG_ERR_NO_ERROR) {
 		printDebug(string("LibGCryptIf::doEncrypt(): GCRYCTL_GET_KEYLEN failed: ")
 			   + gcry_strerror(err));
 		ret = e_cryptNotImpl;
 		goto out;
 	}
 	// now open the algo and get a handle
 	err = gcry_cipher_open(&handle,
 			       algo,
 			       GCRY_CIPHER_MODE_CBC,
 			       0);
 	if (err != GPG_ERR_NO_ERROR) {
 		printDebug(string("LibGCryptIf::doEncrypt(): gcry_cipher_open() failed: ")
 			   + gcry_strerror(err));
 		ret = e_cryptNotImpl;
 		goto out;
 	}
 	// hash the "key" to a fixed size hash matching "cipherKeylen"
 	hashedKey = new unsigned char[cipherKeylen];
-	hashPassphrase(key, keylen, salt, hashedKey, cipherKeylen, true);
+	hashPassphrase(key, keylen, salt, hashedKey, cipherKeylen, true, _hashalgo);
 	// so now set the hashed key
 	err = gcry_cipher_setkey(handle, hashedKey, cipherKeylen);
 	if (err != GPG_ERR_NO_ERROR) {
 		printDebug(string("LibGCryptIf::doEncrypt(): gcry_cipher_setkey() failed: ")
 			   + gcry_strerror(err));
 		ret = e_cryptNotImpl;
 		delete [] hashedKey;
 		goto out_close;
 	}
 	delete [] hashedKey;
 	/* allocate a buffer for the encrypted data.
 	 * The size of the buffer is the inBuf length, but blklen
 	 * aligned and plus the length of the salt, that is appended.
 	 */
 	*outBufLen = getBufLen(unpaddedLen, blklen) + STRING2KEY_SALTLEN;
 	*outBuf = new unsigned char[*outBufLen];
 	padData(inBuf, unpaddedLen, blklen);
 	// encrypt the padded data
 	err = gcry_cipher_encrypt(handle,
 				  *outBuf,
 				  *outBufLen - STRING2KEY_SALTLEN,
 				  inBuf,
 				  *outBufLen - STRING2KEY_SALTLEN);
 	if (err != GPG_ERR_NO_ERROR) {
 		printDebug(string("LibGCryptIf::doEncrypt(): gcry_cipher_encrypt() failed: ")
 			   + gcry_strerror(err));
 		ret = e_cryptNotImpl;
 		goto out_delete;
 	}
 	// append the salt to the encrypted data
 	memcpy(*outBuf + *outBufLen - STRING2KEY_SALTLEN, salt, STRING2KEY_SALTLEN);
 	goto out_close;
 out_delete:
 	delete [] *outBuf;
 out_close:
 	gcry_cipher_close(handle);
 out:
 	return ret;
 }
 
 PwMerror LibGCryptIf::decrypt(unsigned char **outBuf,
 			      size_t *outBufLen,
 			      const unsigned char *inBuf,
 			      size_t inBufLen,
 			      const unsigned char *key,
 			      size_t keylen,
-			      char _algo)
+			      char _algo,
+			      char _hashalgo //US BUG: pass _hashalgo because we need it in hashPassphrase
+)
 {
 	PwMerror ret = e_success;
 	gcry_error_t err;
 	gcry_cipher_hd_t handle;
 	size_t cipherKeylen;
 	unsigned char *hashedKey;
 	unsigned char salt[STRING2KEY_SALTLEN];
 	int algo = mapCipherId(_algo);
 
 	if (!inBufLen || !keylen)
 		return e_invalidArg;
 
 	// test if algo is ready for encryption
 	err = gcry_cipher_algo_info(algo,
 				    GCRYCTL_TEST_ALGO,
 				    0, 0);
 	if (err != GPG_ERR_NO_ERROR) {
 		printDebug(string("LibGCryptIf::doDecrypt(): GCRYCTL_TEST_ALGO failed: ")
 			   + gcry_strerror(err));
 		ret = e_cryptNotImpl;
 		goto out;
 	}
 	// get algo key length
 	err = gcry_cipher_algo_info(algo,
 				    GCRYCTL_GET_KEYLEN,
 				    0,
 				    &cipherKeylen);
 	if (err != GPG_ERR_NO_ERROR) {
 		printDebug(string("LibGCryptIf::doDecrypt(): GCRYCTL_GET_KEYLEN failed: ")
 			   + gcry_strerror(err));
 		ret = e_cryptNotImpl;
 		goto out;
 	}
 	// extract the salt of the encrypted data buffer
 	memcpy(salt, inBuf + inBufLen - STRING2KEY_SALTLEN, STRING2KEY_SALTLEN);
 	// open the algo and get a handle
 	err = gcry_cipher_open(&handle,
 			       algo,
 			       GCRY_CIPHER_MODE_CBC,
 			       0);
 	if (err != GPG_ERR_NO_ERROR) {
 		printDebug(string("LibGCryptIf::doDecrypt(): gcry_cipher_open() failed: ")
 			   + gcry_strerror(err));
 		ret = e_cryptNotImpl;
 		goto out;
 	}
 	// hash the "key" to a fixed size hash matching "cipherKeylen"
 	hashedKey = new unsigned char[cipherKeylen];
-	hashPassphrase(key, keylen, salt, hashedKey, cipherKeylen, false);
+	hashPassphrase(key, keylen, salt, hashedKey, cipherKeylen, false, _hashalgo);
 	// so now set the hashed key
 	err = gcry_cipher_setkey(handle, hashedKey, cipherKeylen);
 	if (err != GPG_ERR_NO_ERROR) {
 		printDebug(string("LibGCryptIf::doDecrypt(): gcry_cipher_setkey() failed: ")
 			   + gcry_strerror(err));
 		ret = e_cryptNotImpl;
 		delete [] hashedKey;
 		goto out_close;
 	}
 	delete [] hashedKey;
 	*outBufLen = inBufLen - STRING2KEY_SALTLEN;
 	*outBuf = new unsigned char[*outBufLen];
 	// decrypt the data
 	err = gcry_cipher_decrypt(handle,
 				  *outBuf,
 				  *outBufLen,
 				  inBuf,
 				  *outBufLen);
 	if (err != GPG_ERR_NO_ERROR) {
 		printDebug(string("LibGCryptIf::doEncrypt(): gcry_cipher_encrypt() failed: ")
 			   + gcry_strerror(err));
 		ret = e_cryptNotImpl;
 		goto out_delete;
 	}
 	// remove all random padding
 	unpadData(*outBuf, outBufLen);
 	goto out_close;
 out_delete:
 	delete [] *outBuf;
 out_close:
 	gcry_cipher_close(handle);
 out:
 	return ret;
 }
 
 PwMerror LibGCryptIf::hash(unsigned char **outBuf,
 			   size_t *outBufLen,
 			   const unsigned char *inBuf,
 			   size_t inBufLen,
 			   char _algo)
 {
 	PwMerror ret = e_success;
 	unsigned int hashLen;
 	int algo = mapHashId(_algo);
 
 	hashLen = gcry_md_get_algo_dlen(algo);
 	*outBufLen = hashLen;
 	*outBuf = new unsigned char[*outBufLen];
 	gcry_md_hash_buffer(algo,
 			    *outBuf,
 			    inBuf,
 			    inBufLen);
 	return ret;
 }
 
 unsigned int LibGCryptIf::hashLength(char _algo)
 {
 	unsigned int ret;
 	int algo = mapHashId(_algo);
 	ret = gcry_md_get_algo_dlen(algo);
 	return ret;
 }
 
 int LibGCryptIf::mapCipherId(char algo)
 {
 	switch (algo) {
 	case PWM_CRYPT_AES128:
 		return GCRY_CIPHER_AES;
 	case PWM_CRYPT_AES192:
 		return GCRY_CIPHER_AES192;
 	case PWM_CRYPT_AES256:
 		return GCRY_CIPHER_AES256;
 	case PWM_CRYPT_3DES:
 		return GCRY_CIPHER_3DES;
 	case PWM_CRYPT_TWOFISH:
 		return GCRY_CIPHER_TWOFISH;
 	case PWM_CRYPT_TWOFISH128:
 		return GCRY_CIPHER_TWOFISH128;
 	default:
 		BUG();
 	}
 	return GCRY_CIPHER_NONE;
 }
 
 int LibGCryptIf::mapHashId(char algo)
 {
 	switch (algo) {
 	case PWM_HASH_SHA1:
 		return GCRY_MD_SHA1;
 	case PWM_HASH_SHA256:
 		return GCRY_MD_SHA256;
 	case PWM_HASH_SHA384:
 		return GCRY_MD_SHA384;
 	case PWM_HASH_SHA512:
 		return GCRY_MD_SHA512;
 	case PWM_HASH_MD5:
 		return GCRY_MD_MD5;
 	case PWM_HASH_RMD160:
 		return GCRY_MD_RMD160;
 	case PWM_HASH_TIGER:
 		return GCRY_MD_TIGER;
 	default:
 		BUG();
 	}
 	return GCRY_MD_NONE;
 }
 
 bool LibGCryptIf::hashPassphrase(const unsigned char *pw,
 				 size_t pwlen,
 				 unsigned char *salt,
 				 unsigned char *key,
 				 size_t keylen,
-				 bool create)
+				 bool create,
+				 char _hashalgo //US BUG: pass _hashalgo because we need it in hashPassphrase
+)
 {
 	DEK dek;
 	STRING2KEY s2k;
 	bool ret;
 
 	dek.keylen = keylen;
 	s2k.mode = 1;
-	s2k.hash_algo = mapHashId(conf()->confGlobHashAlgo());
+	//US bug: do not use the global hash algo here. Use the passed ago instead. The hashalgo stored in the file can
+	// be different from the one in the configuration.
+	s2k.hash_algo = mapHashId(_hashalgo //conf()->confGlobHashAlgo()
+				  );
 	s2k.count = 0;
 	if (!create)
 		memcpy(s2k.salt, salt, STRING2KEY_SALTLEN);
 	ret = doHashPassphrase(&dek,
 			       pw,
 			       pwlen,
 			       &s2k,
 			       create);
 	if (!ret)
 		goto out;
 	memcpy(key, dek.key, dek.keylen);
 	if (create)
 		memcpy(salt, s2k.salt, STRING2KEY_SALTLEN);
 out:
 	return ret;
 }
 
 
 bool LibGCryptIf::doHashPassphrase(DEK *dek,
 				   const unsigned char *pw,
 				   size_t pwlen,
 				   STRING2KEY *s2k,
 				   bool create)
 {
 	// This function is derived from GnuPG-1.2.5-rc2
 	gcry_md_hd_t md;
 	gcry_error_t err;
 	bool ret = true;
 	size_t pass, i;
 	size_t used = 0;
 
 	PWM_ASSERT(s2k->hash_algo);
 	BUG_ON(!(dek->keylen > 0 && dek->keylen <= array_size(dek->key)));
 
 	err = gcry_md_open(&md, s2k->hash_algo, 0);
 	if (err != GPG_ERR_NO_ERROR) {
 		ret = false;
 		goto out;
 	}
 	for (pass = 0; used < dek->keylen; pass++) {
 		if (pass) {
 			gcry_md_reset(md);
 			for (i = 0; i < pass; i++) // preset the hash context
 			gcry_md_putc(md, 0);
 		}
 		if (s2k->mode == 1 || s2k->mode == 3) {
 			size_t len2 = pwlen + 8;
 			size_t count = len2;
 
 			if (create && !pass) {
 				Randomizer *rnd = Randomizer::obj();
 				const unsigned int salt_len = 8;
 				string rndBuf(rnd->genRndBuf(salt_len));
 				memcpy(s2k->salt, rndBuf.c_str(), salt_len);
 				if (s2k->mode == 3)
 					s2k->count = 96; // 65536 iterations
 			}
 			if (s2k->mode == 3) {
 				count = (16ul + (s2k->count & 15)) << ((s2k->count >> 4) + 6);
 				if (count < len2)
 					count = len2;
 			}
 			// a little bit complicated because we need a ulong for count
 			while (count > len2) { // maybe iterated+salted
 				gcry_md_write(md, s2k->salt, 8);
 				gcry_md_write(md, pw, pwlen);
 				count -= len2;
 			}
 			if (count < 8) {
 				gcry_md_write(md, s2k->salt, count);
 			} else {
 				gcry_md_write(md, s2k->salt, 8);
 				count -= 8;
 				gcry_md_write(md, pw, count);
 			}
 		} else
 			gcry_md_write(md, pw, pwlen);
 		gcry_md_final(md);
 		i = gcry_md_get_algo_dlen(s2k->hash_algo);
 		if (i > dek->keylen - used)
 			i = dek->keylen - used;
 		memcpy(dek->key+used, gcry_md_read(md, s2k->hash_algo), i);
 		used += i;
 	}
 	gcry_md_close(md);
 out:
 	return ret;
 }
 
 void LibGCryptIf::padData(unsigned char *buf,
 			  size_t bufLen,
 			  size_t boundary)
 {
 	size_t numPadBytes = boundary - ((bufLen + 1) % boundary);
 	buf[bufLen] = static_cast<char>(0x01);
 	size_t i = 0;
 	Randomizer *rnd = Randomizer::obj();
 	char c;
 	unsigned char *b;
 	while (i < numPadBytes) {
 		c = rnd->genRndChar();
 		if (c == static_cast<char>(0x01))
 			continue;
 		b = buf + bufLen + 1 + i;
 		*b = c;
 		++i;
 	}
 }
 
 void LibGCryptIf::unpadData(const unsigned char *buf,
 		 	    size_t *bufLen)
 {
 	size_t pos;
 	BUG_ON(*bufLen % 8);
 	pos = *bufLen - 1;
 	while (buf[pos] != static_cast<char>(0x01)) {
-        qDebug("pos %d %d %d", pos, buf[pos],   static_cast<char>(0x01)     );
+	  //qDebug("pos %d %d %d", pos, buf[pos],   static_cast<char>(0x01)     );
 		BUG_ON(!pos);
         //LR BUG we should terminte the loop if p == 0
         if ( pos == 0 )
             break;
 		--pos;
 	}
 	*bufLen = pos;
-    qDebug("ente ");
+	//qDebug("ente ");
 }
 
 #endif // CONFIG_PWMANAGER_GCRY
 
diff --git a/pwmanager/pwmanager/libgcryptif.h b/pwmanager/pwmanager/libgcryptif.h
index 1a7b658..9a987a2 100644
--- a/pwmanager/pwmanager/libgcryptif.h
+++ b/pwmanager/pwmanager/libgcryptif.h
@@ -1,171 +1,177 @@
 /***************************************************************************
  *                                                                         *
  *   copyright (C) 2004 by Michael Buesch                                  *
  *   email: mbuesch@freenet.de                                             *
  *                                                                         *
  *   hashPassphrase() is derived from GnuPG and is                         *
  *   Copyright (C) 1998, 1999, 2000, 2001, 2003                            *
  *   Free Software Foundation, Inc.                                        *
  *                                                                         *
  *   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 __LIBGCRYPTIF_H
 #define __LIBGCRYPTIF_H
 
 #include "pwmexception.h"
 
 //#undef CONFIG_PWMANAGER_GCRY // for debugging only.
 #ifdef CONFIG_PWMANAGER_GCRY
 
 #include <stddef.h>
 #include <sys/types.h>
 #ifndef _WIN32_
 #include <stdint.h>
 #else
 #define  uint8_t Q_UINT8
 #define  byte Q_UINT8
 #define  uint32_t Q_UINT32
 #endif
 #define STRING2KEY_SALTLEN	8
 
 /** interface class for the libgcrypt cipher and hash algorithms
   * NOTE: Always allocate 1024 extra bytes for the inBuf (for padding)
   */
 class LibGCryptIf
 {
 protected:
 	struct STRING2KEY
 	{
 		int  mode;
 		int hash_algo;
 		uint8_t salt[STRING2KEY_SALTLEN];
 		uint32_t  count;
 	};
 	struct DEK
 	{
 		size_t keylen;
 		uint8_t key[32]; // this is the largest used keylen (256 bit)
 	};
 
 public:
 	LibGCryptIf() { }
 	/** is libgcrypt available? */
 	static bool available()
 			{ return true; }
 	/** encrypt data. _algo is the PWM_CRYPT_* ID
 	  * of the algorithm.
 	  */
 	PwMerror encrypt(unsigned char **outBuf,
 			 size_t *outBufLen,
 			 unsigned char *inBuf,
 			 size_t inBufLen,
 			 const unsigned char *key,
 			 size_t keylen,
-			 char _algo);
+			 char _algo,
+			 char _hashalgo //US BUG: pass _hashalgo because we need it in hashPassphrase
+);
 	/** decrypt data. _algo is the PWM_CRYPT_* ID
 	  * of the algorithm.
 	  */
 	PwMerror decrypt(unsigned char **outBuf,
 			 size_t *outBufLen,
 			 const unsigned char *inBuf,
 			 size_t inBufLen,
 			 const unsigned char *key,
 			 size_t keylen,
-			 char _algo);
+			 char _algo,
+			 char _hashalgo //US BUG: pass _hashalgo because we need it in hashPassphrase
+);
 	/** hash data. _algo is the PWM_HASH_* ID of the hash */
 	PwMerror hash(unsigned char **outBuf,
 		      size_t *outBufLen,
 		      const unsigned char *inBuf,
 		      size_t inBufLen,
 		      char _algo);
 	/** returns the length of the hash. _algo is the PWM_HASH_*
 	  * id of the hash. returns 0 on error.
 	  */
 	unsigned int hashLength(char _algo);
 
 protected:
 	/** returns the total buffer length */
 	size_t getBufLen(size_t inBufLen, size_t boundary)
 		{
 			return ((boundary - (inBufLen % boundary)) + inBufLen);
 		}
 	/** pad the data up to the given boundary.
 	  * "buf" has to be big enough!
 	  */
 	void padData(unsigned char *buf,
 		     size_t bufLen,
 		     size_t boundary);
 	/** unpad the data */
 	void unpadData(const unsigned char *buf,
 		       size_t *bufLen);
 	/** maps the PWM_CRYPT_* ID of an algorithm
 	  * to the libgcrypt GCRY_CIPHER_* ID
 	  */
 	int mapCipherId(char algo);
 	/** maps the PWM_HASH_* ID of an algorithm
 	  * to the libgcrypt GCRY_MD_* ID
 	  */
 	int mapHashId(char algo);
 	/** hash a passphrase to a cipher key */
 	bool hashPassphrase(const unsigned char *pw,
 			    size_t pwlen,
 			    unsigned char *salt,
 			    unsigned char *key,
 			    size_t keylen,
-			    bool create);
+			    bool create, 
+			 char _hashalgo //US BUG: pass _hashalgo because we need it in hashPassphrase
+);
 	/** hash a passphrase to a cipher key */
 	bool doHashPassphrase(DEK *dek,
 			      const unsigned char *pw,
 			      size_t pwlen,
 			      STRING2KEY *s2k,
 			      bool create);
 };
 
 
 #else // CONFIG_PWMANAGER_GCRY
 /** libgcrypt is not installed. This is a NOP wrapper. */
 class LibGCryptIf
 {
 public:
 	LibGCryptIf() { }
 	static bool available()
 			{ return false; }
 	PwMerror encrypt(unsigned char **,
 			 size_t *,
 			 unsigned char *,
 			 size_t,
 			 const unsigned char *,
 			 size_t,
 			 char)
 			{ return e_cryptNotImpl; }
 	PwMerror decrypt(unsigned char **,
 			 size_t *,
 			 const unsigned char *,
 			 size_t,
 			 const unsigned char *,
 			 size_t,
 			 char)
 			{ return e_cryptNotImpl; }
 	PwMerror hash(unsigned char **,
 		      size_t *,
 		      const unsigned char *,
 		      size_t,
 		      char)
 			{ return e_hashNotImpl; }
 	unsigned int hashLength(char)
 			{ return 0; }
 };
 #endif // CONFIG_PWMANAGER_GCRY
 #endif // __LIBGCRYPTIF_H
diff --git a/pwmanager/pwmanager/pwmdoc.cpp b/pwmanager/pwmanager/pwmdoc.cpp
index 17cb74a..a740d6d 100644
--- a/pwmanager/pwmanager/pwmdoc.cpp
+++ b/pwmanager/pwmanager/pwmdoc.cpp
@@ -1,3474 +1,3482 @@
 /***************************************************************************
  *                                                                         *
  *   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$
  **************************************************************************/  
 
 #include "pwmdoc.h"
 #include "pwmview.h"
 #include "blowfish.h"
 #include "sha1.h"
 #include "globalstuff.h"
 #include "gpasmanfile.h"
 #include "serializer.h"
 #include "compressgzip.h"
 //US#include "compressbzip2.h"
 #include "randomizer.h"
 #include "pwminit.h"
 #include "libgcryptif.h"
 #ifdef PWM_EMBEDDED
 #include "pwmprefs.h"
 #include "kglobal.h"
 #endif
 
 #include <kmessagebox.h>
 #include <libkcal/syncdefines.h>
 
 
 #ifdef CONFIG_KWALLETIF
 # include "kwalletemu.h"
 #endif // CONFIG_KWALLETIF
 
 #include <qdatetime.h>
 #include <qsize.h>
 #include <qfileinfo.h>
 #include <qfile.h>
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <string.h>
 //US#include <iostream>
 #include <algorithm>
 #include <sys/types.h>
 #include <sys/stat.h>
 #ifndef _WIN32_
 #include <unistd.h>
 #include <stdint.h>
 #endif
 
 #ifdef PWM_EMBEDDED
 #ifndef Q_LONG
 #define Q_LONG long
 #endif
 
 #ifndef Q_ULONG
 #define Q_ULONG unsigned long
 #endif
 #endif //PWM_EMBEDDED
 
 
 //TODO: reset to its normal value.
 #define META_CHECK_TIMER_INTERVAL	10/*300*/ /* sek */
 
 using namespace std;
 
 
 void PwMDocList::add(PwMDoc *doc, const string &id)
 {
 #ifdef PWM_DEBUG
 	// check for existance of object in debug mode only.
 	vector<listItem>::iterator begin = docList.begin(),
 				   end = docList.end(),
 				   i = begin;
 	while (i != end) {
 		if (i->doc == doc) {
 			BUG();
 			return;
 		}
 		++i;
 	}
 #endif
 	listItem newItem;
 	newItem.doc = doc;
 	newItem.docId = id;
 	docList.push_back(newItem);
 }
 
 void PwMDocList::edit(PwMDoc *doc, const string &newId)
 {
 	vector<listItem>::iterator begin = docList.begin(),
 				   end = docList.end(),
 				   i = begin;
 	while (i != end) {
 		if (i->doc == doc) {
 			i->docId = newId;
 			return;
 		}
 		++i;
 	}
 }
 
 void PwMDocList::del(PwMDoc *doc)
 {
 	vector<listItem>::iterator begin = docList.begin(),
 				   end = docList.end(),
 				   i = begin;
 	while (i != end) {
 		if (i->doc == doc) {
 			docList.erase(i);
 			return;
 		}
 		++i;
 	}
 }
 
 bool PwMDocList::find(const string &id, listItem *ret)
 {
 	vector<listItem>::iterator begin = docList.begin(),
 				   end = docList.end(),
 				   i = begin;
 	while (i != end) {
 		if (i->docId == id) {
 			if (ret)
 				*ret = *i;
 			return true;
 		}
 		++i;
 	}
 	return false;
 }
 
 
 
 DocTimer::DocTimer(PwMDoc *_doc)
  : doc (_doc)
  , mpwLock (0)
  , autoLockLock (0)
  , metaCheckLock (0)
 {
 	mpwTimer = new QTimer;
 	autoLockTimer = new QTimer;
 	metaCheckTimer = new QTimer;
 	connect(mpwTimer, SIGNAL(timeout()),
 		this, SLOT(mpwTimeout()));
 	connect(autoLockTimer, SIGNAL(timeout()),
 		this, SLOT(autoLockTimeout()));
 	connect(metaCheckTimer, SIGNAL(timeout()),
 		this, SLOT(metaCheckTimeout()));
 }
 
 DocTimer::~DocTimer()
 {
 	delete mpwTimer;
 	delete autoLockTimer;
 	delete metaCheckTimer;
 }
 
 void DocTimer::start(TimerIDs timer)
 {
 	switch (timer) {
 		case id_mpwTimer:
 			if (mpwTimer->isActive())
 				mpwTimer->stop();
 			doc->setDocStatFlag(DOC_STAT_UNLOCK_WITHOUT_PW);
 			mpwTimer->start(conf()->confGlobPwTimeout() * 1000, true);
 			break;
 		case id_autoLockTimer:
 			if (autoLockTimer->isActive())
 				autoLockTimer->stop();
 			if (conf()->confGlobLockTimeout() > 0)
 				autoLockTimer->start(conf()->confGlobLockTimeout() * 1000, true);
 			break;
 		case id_metaCheckTimer:
 			if (metaCheckTimer->isActive())
 				metaCheckTimer->stop();
 			metaCheckTimer->start(META_CHECK_TIMER_INTERVAL * 1000, true);
 			break;
 	}
 }
 
 void DocTimer::stop(TimerIDs timer)
 {
 	switch (timer) {
 		case id_mpwTimer:
 			mpwTimer->stop();
 			break;
 		case id_autoLockTimer:
 			autoLockTimer->stop();
 			break;
 		case id_metaCheckTimer:
 			metaCheckTimer->stop();
 			break;
 	}
 }
 
 void DocTimer::getLock(TimerIDs timer)
 {
 	switch (timer) {
 		case id_mpwTimer:
 			++mpwLock;
 			break;
 		case id_autoLockTimer:
 			++autoLockLock;
 			break;
 		case id_metaCheckTimer:
 			++metaCheckLock;
 			break;
 	}
 }
 
 void DocTimer::putLock(TimerIDs timer)
 {
 	switch (timer) {
 		case id_mpwTimer:
 			if (mpwLock)
 				--mpwLock;
 			break;
 		case id_autoLockTimer:
 			if (autoLockLock)
 				--autoLockLock;
 			break;
 		case id_metaCheckTimer:
 			if (metaCheckLock)
 				--metaCheckLock;
 			break;
 	}
 }
 
 void DocTimer::mpwTimeout()
 {
 	if (mpwLock) {
 		mpwTimer->start(1000, true);
 		return;
 	}
 	doc->unsetDocStatFlag(DOC_STAT_UNLOCK_WITHOUT_PW);
 }
 
 void DocTimer::autoLockTimeout()
 {
 	if (autoLockLock) {
 		autoLockTimer->start(1000, true);
 		return;
 	}
 	if (conf()->confGlobAutoDeepLock() &&
 	    doc->filename != QString::null &&
 	    doc->filename != "") {
 		doc->deepLock(true);
 	} else {
 		doc->lockAll(true);
 	}
 }
 
 void DocTimer::metaCheckTimeout()
 {
 	if (metaCheckLock) {
 		// check again in one second.
 		metaCheckTimer->start(1000, true);
 		return;
 	}
 	if (doc->isDeepLocked()) {
 		metaCheckTimer->start(META_CHECK_TIMER_INTERVAL * 1000, true);
 		return;
 	}
 	if (doc->isDocEmpty()) {
 		metaCheckTimer->start(META_CHECK_TIMER_INTERVAL * 1000, true);
 		return;
 	}
 #ifdef CONFIG_KWALLETIF
 	KWalletEmu *kwlEmu = doc->init->kwalletEmu();
 	if (kwlEmu)
 		kwlEmu->suspendDocSignals();
 #endif // CONFIG_KWALLETIF
 	/* We simply trigger all views to update their
 	 * displayed values. This way they have a chance
 	 * to get notified when some meta changes over time.
 	 * (for example an entry expired).
 	 * The _view_ is responsive for not updating its
 	 * contents if nothing really changed!
 	 */
 	emit doc->dataChanged(doc);
 #ifdef CONFIG_KWALLETIF
 	if (kwlEmu)
 		kwlEmu->resumeDocSignals();
 #endif // CONFIG_KWALLETIF
 	metaCheckTimer->start(META_CHECK_TIMER_INTERVAL * 1000, true);
 }
 
 
 
 PwMDocList PwMDoc::openDocList;
 unsigned int PwMDocList::unnamedDocCnt = 1;
 
 PwMDoc::PwMDoc(QObject *parent, const char *name)
  : PwMDocUi(parent, name)
  , dataChangedLock (0)
 {
 	deleted = false;
 	unnamedNum = 0;
 	getOpenDocList()->add(this, getTitle().latin1());
 	curDocStat = 0;
 	setMaxNumEntries();
 	_timer = new DocTimer(this);
 	timer()->start(DocTimer::id_mpwTimer);
 	timer()->start(DocTimer::id_autoLockTimer);
 	timer()->start(DocTimer::id_metaCheckTimer);
 	addCategory(DEFAULT_CATEGORY, 0, false);
 	listView = 0;
 	emit docCreated(this);
 }
 
 PwMDoc::~PwMDoc()
 {
 	emit docClosed(this);
 	getOpenDocList()->del(this);
 	delete _timer;
 }
 
 PwMerror PwMDoc::saveDoc(char compress, const QString *file)
 {
 	PwMerror ret, e;
 	string serialized;
 	QFile f;
 	QString tmpFileMoved(QString::null);
 	bool wasDeepLocked;
 	QString savedFilename(filename);
 
 	if (!file) {
 		if (filename == "")
 			return e_filename;
 		if (isDeepLocked()) {
 		  /* We don't need to save any data.
 		   * It's already all on disk, because
 		   * we are deeplocked.
 		   */
 		  unsetDocStatFlag(DOC_STAT_DISK_DIRTY);
 		  ret = e_success;
           return ret;
 		}
  	} else {
 		if (*file == "" && filename == "")
 			return e_filename;
 		if (*file != "")
 			filename = *file;
 	}
 
 	wasDeepLocked = isDeepLocked();
 	if (wasDeepLocked) {
 	  /* We are deeplocked. That means all data is already
 	   * on disk. BUT we need to do saving procedure,
 	   * because *file != savedFilename.
 	   * Additionally we need to tempoarly restore
 	   * the old "filename", because deepLock() references it.
 	   */
 	  QString newFilename(filename);
 	  filename = savedFilename;
 	  getDataChangedLock();
 	  e = deepLock(false);
 	  putDataChangedLock();
 	  filename = newFilename;
 	  switch (e) {
 	     case e_success:
 	       break;
 	     case e_wrongPw:
 	     case e_noPw:
 	       emitDataChanged(this);
 	       return e;
 	     default:
 	       emitDataChanged(this);
 	       return e_openFile;
 	  }
 	}
 
 	if (!isPwAvailable()) {
 		/* password is not available. This means, the
 		 * document wasn't saved, yet.
 		 */
 		bool useChipcard = getDocStatFlag(DOC_STAT_USE_CHIPCARD);
 		QString pw(requestNewMpw(&useChipcard));
 		if (pw != "") {
 			currentPw = pw;
 		} else {
 			return e_noPw;
 		}
 		if (useChipcard) {
 			setDocStatFlag(DOC_STAT_USE_CHIPCARD);
 		} else {
 			unsetDocStatFlag(DOC_STAT_USE_CHIPCARD);
 		}
 	}
 
 	int _cryptAlgo = conf()->confGlobCryptAlgo();
 	int _hashAlgo = conf()->confGlobHashAlgo();
 
 	// sanity check for the selected algorithms
 	if (_cryptAlgo < PWM_CRYPT_BLOWFISH ||
 	    _cryptAlgo > PWM_CRYPT_TWOFISH128) {
 		printWarn("Invalid Crypto-Algorithm selected! "
 			  "Config-file seems to be corrupt. "
 			  "Falling back to Blowfish.");
 		_cryptAlgo = PWM_CRYPT_BLOWFISH;
 	}
 	if (_hashAlgo < PWM_HASH_SHA1 ||
 	    _hashAlgo > PWM_HASH_TIGER) {
 		printWarn("Invalid Hash-Algorithm selected! "
 			  "Config-file seems to be corrupt. "
 			  "Falling back to SHA1.");
 		_hashAlgo = PWM_HASH_SHA1;
 	}
 	char cryptAlgo = static_cast<char>(_cryptAlgo);
 	char hashAlgo = static_cast<char>(_hashAlgo);
 
 	if (conf()->confGlobMakeFileBackup()) {
 		if (!backupFile(filename))
 			return e_fileBackup;
 	}
 	if (QFile::exists(filename)) {
 		/* Move the existing file to some tmp file.
 		 * When saving file succeeds, delete tmp file. Otherwise
 		 * move tmp file back. See below.
 		 */
 		Randomizer *rnd = Randomizer::obj();
 		char rnd_buf[5];
 		sprintf(rnd_buf, "%X%X%X%X", rnd->genRndChar() & 0xFF, rnd->genRndChar() & 0xFF,
 			rnd->genRndChar() & 0xFF, rnd->genRndChar() & 0xFF);
 		tmpFileMoved = filename + "." + rnd_buf + ".mv";
 		if (!copyFile(filename, tmpFileMoved))
 			return e_openFile;
 		if (!QFile::remove(filename)) {
 			printWarn(string("removing orig file ")
 				  + filename.latin1()
 				  + " failed!");
 		}
 	}
 	f.setName(filename);
 	if (!f.open(IO_ReadWrite)) {
 		ret = e_openFile;
 		goto out_moveback;
 	}
 	e = writeFileHeader(hashAlgo, hashAlgo,
 			    cryptAlgo, compress,
 			    &currentPw, &f);
 	if (e == e_hashNotImpl) {
 		printDebug("PwMDoc::saveDoc(): writeFileHeader() failed: e_hashNotImpl");
 		f.close();
 		ret = e_hashNotImpl;
 		goto out_moveback;
 	} else if (e != e_success) {
 		printDebug("PwMDoc::saveDoc(): writeFileHeader() failed");
 		f.close();
 		ret = e_writeHeader;
 		goto out_moveback;
 	}
 	if (!serializeDta(&serialized)) {
 		printDebug("PwMDoc::saveDoc(): serializeDta() failed");
 		f.close();
 		ret = e_serializeDta;
 		goto out_moveback;
 	}
 	e = writeDataHash(hashAlgo, &serialized, &f);
 	if (e == e_hashNotImpl) {
 		printDebug("PwMDoc::saveDoc(): writeDataHash() failed: e_hashNotImpl");
 		f.close();
 		ret = e_hashNotImpl;
 		goto out_moveback;
 	} else if (e != e_success) {
 		printDebug("PwMDoc::saveDoc(): writeDataHash() failed");
 		f.close();
 		ret = e_writeHeader;
 		goto out_moveback;
 	}
 	if (!compressDta(&serialized, compress)) {
 		printDebug("PwMDoc::saveDoc(): compressDta() failed");
 		f.close();
 		ret = e_enc;
 		goto out_moveback;
 	}
-	e = encrypt(&serialized, &currentPw, &f, cryptAlgo);
+	e = encrypt(&serialized, &currentPw, &f, cryptAlgo, hashAlgo);
 	if (e == e_weakPw) {
 		printDebug("PwMDoc::saveDoc(): encrypt() failed: e_weakPw");
 		f.close();
 		ret = e_weakPw;
 		goto out_moveback;
 	} else if (e == e_cryptNotImpl) {
 		printDebug("PwMDoc::saveDoc(): encrypt() failed: e_cryptNotImpl");
 		f.close();
 		ret = e_cryptNotImpl;
 		goto out_moveback;
 	} else if (e != e_success) {
 		printDebug("PwMDoc::saveDoc(): encrypt() failed");
 		f.close();
 		ret = e_enc;
 		goto out_moveback;
 	}
 	unsetDocStatFlag(DOC_STAT_DISK_DIRTY);
 	f.close();
 #ifndef _WIN32_
 	if (chmod(filename.latin1(),
 		  conf()->confGlobFilePermissions())) {
 		printWarn(string("chmod failed: ") + strerror(errno));
 	}
 #endif
 	openDocList.edit(this, getTitle().latin1());
 	if (wasDeepLocked) {
 	  /* Do _not_ save the data with the deepLock()
 	   * call, because this will recurse
 	   * into saveDoc()
 	   */
 	  deepLock(true, false);
 	  /* We don't check return value here, because
 	   * it won't fail. See NOTE in deepLock()
 	   */
 	}	
 	if (tmpFileMoved != QString::null) {
 		// now remove the moved file.
 		if (!QFile::remove(tmpFileMoved)) {
 			printWarn(string("removing file ")
 				  + tmpFileMoved.latin1()
 				  + " failed!");
 		}
 	}
 	ret = e_success;
 	printDebug(string("writing file { name: ")
 		   + filename.latin1() + "   compress: "
 		   + tostr(static_cast<int>(compress)) + "   cryptAlgo: "
 		   + tostr(static_cast<int>(cryptAlgo)) + "   hashAlgo: "
 		   + tostr(static_cast<int>(hashAlgo))
 		   + " }");
 	goto out;
 out_moveback:
 	if (tmpFileMoved != QString::null) {
 		if (copyFile(tmpFileMoved, filename)) {
 			if (!QFile::remove(tmpFileMoved)) {
 				printWarn(string("removing tmp file ")
 					  + filename.latin1()
 					  + " failed!");
 			}
 		} else {
 			printWarn(string("couldn't copy file ")
 				  + tmpFileMoved.latin1()
 				  + " back to "
 				  + filename.latin1());
 		}
 	}
 out:
 	return ret;
 }
 
 PwMerror PwMDoc::openDoc(const QString *file, int openLocked)
 {
 	PWM_ASSERT(file);
 	PWM_ASSERT(openLocked == 0 || openLocked == 1 || openLocked == 2);
 	string decrypted, dataHash;
 	PwMerror ret;
 	char cryptAlgo, dataHashType, compress;
 	unsigned int headerLen;
 
 	if (*file == "")
 		return e_readFile;
 	filename = *file;
 	/* check if this file is already open.
 	 * This does not catch symlinks!
 	 */
 	if (!isDeepLocked()) {
 		if (getOpenDocList()->find(filename.latin1()))
 			return e_alreadyOpen;
 	}
 	QFile f(filename);
 
 	if (openLocked == 2) {
 		// open deep-locked
 		if (!QFile::exists(filename))
 			return e_openFile;
 		if (deepLock(true, false) != e_success)
 			return e_openFile;
 		goto out_success;
 	}
 
 	if (!f.open(IO_ReadOnly))
 		return e_openFile;
 
 	ret = checkHeader(&cryptAlgo, &currentPw, &compress, &headerLen,
 			  &dataHashType, &dataHash, &f);
 	if (ret != e_success) {
 		printDebug("PwMDoc::openDoc(): checkHeader() failed");
 		f.close();
 		if (ret == e_wrongPw) {
 			wrongMpwMsgBox(getDocStatFlag(DOC_STAT_USE_CHIPCARD));
 			return ret;
 		} else if (ret == e_noPw ||
 			   ret == e_fileVer ||
 			   ret == e_fileFormat ||
 			   ret == e_hashNotImpl) {
 			return ret;
 		} else
 			return e_readFile;
 	}
-	ret = decrypt(&decrypted, headerLen, &currentPw, cryptAlgo, &f);
+	ret = decrypt(&decrypted, headerLen, &currentPw, cryptAlgo, dataHashType, &f);
 	if (ret == e_cryptNotImpl) {
 		printDebug("PwMDoc::openDoc(): decrypt() failed: e_cryptNotImpl");
 		f.close();
 		return e_cryptNotImpl;
 	} else if (ret != e_success) {
 		printDebug("PwMDoc::openDoc(): decrypt() failed");
 		f.close();
 		return e_readFile;
 	}
 	if (!decompressDta(&decrypted, compress)) {
 		printDebug("PwMDoc::openDoc(): decompressDta() failed");
 		f.close();
 		return e_fileCorrupt;
 	}
 	ret = checkDataHash(dataHashType, &dataHash, &decrypted);
 	if (ret == e_hashNotImpl) {
 		printDebug("PwMDoc::openDoc(): checkDataHash() failed: e_hashNotImpl");
 		f.close();
 		return e_hashNotImpl;
 	} else if (ret != e_success) {
 		printDebug("PwMDoc::openDoc(): checkDataHash() failed");
 		f.close();
 		return e_fileCorrupt;
 	}
 	if (!deSerializeDta(&decrypted, openLocked == 1)) {
 		printDebug("PwMDoc::openDoc(): deSerializeDta() failed");
 		f.close();
 		return e_readFile;
 	}
 	f.close();
 	timer()->start(DocTimer::id_mpwTimer);
 	timer()->start(DocTimer::id_autoLockTimer);
 out_success:
 	openDocList.edit(this, getTitle().latin1());
 	emit docOpened(this);
 	return e_success;
 }
 
 PwMerror PwMDoc::writeFileHeader(char keyHash, char dataHash, char crypt, char compress,
 				 QString *pw, QFile *f)
 {
 	PWM_ASSERT(pw);
 	PWM_ASSERT(f);
 	//US ENH: or maybe a bug: checking here for listView does not make sense because we do not check anywhere else
 	//Wenn I sync, I open a doc without a view => listView is 0 => Assertion 
 	//US	PWM_ASSERT(listView);
 	if (f->writeBlock(FILE_ID_HEADER, strlen(FILE_ID_HEADER)) !=
 	    static_cast<Q_LONG>(strlen(FILE_ID_HEADER))) {
 		return e_writeFile;
 	}
 	if (f->putch(PWM_FILE_VER) == -1 ||
 	    f->putch(keyHash) == -1 ||
 	    f->putch(dataHash) == -1 ||
 	    f->putch(crypt) == -1 ||
 	    f->putch(compress) == -1 ||
 	    f->putch((getDocStatFlag(DOC_STAT_USE_CHIPCARD)) ?
 		     (static_cast<char>(0x01)) : (static_cast<char>(0x00))) == -1) {
 		return e_writeFile;
 	}
 
 	// write bytes of NUL-data. These bytes are reserved for future-use.
 	const int bufSize = 64;
 	char tmp_buf[bufSize];
 	memset(tmp_buf, 0x00, bufSize);
 	if (f->writeBlock(tmp_buf, bufSize) != bufSize)
 		return e_writeFile;
 
 	switch (keyHash) {
 	case PWM_HASH_SHA1: {
 		const int hashlen = SHA1_HASH_LEN_BYTE;
 		Sha1 hash;
 		hash.sha1_write(reinterpret_cast<const byte *>(pw->latin1()), pw->length());
 		string ret = hash.sha1_read();
 		if (f->writeBlock(ret.c_str(), hashlen) != hashlen)
 			return e_writeFile;
 		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 *>(pw->latin1()),
 			      pw->length(),
 			      keyHash);
 		if (err != e_success)
 			return e_hashNotImpl;
 		if (f->writeBlock(reinterpret_cast<const char *>(buf), hashLen)
 		    != static_cast<Q_LONG>(hashLen)) {
 			delete [] buf;
 			return e_hashNotImpl;
 		}
 		delete [] buf;
 		break;
 	} 
 	default: {
 		return e_hashNotImpl;
 	} }
 	return e_success;
 }
 
 PwMerror PwMDoc::checkHeader(char *cryptAlgo, QString *pw, char *compress,
 			     unsigned int *headerLength, char *dataHashType,
 			     string *dataHash, QFile *f)
 {
 	PWM_ASSERT(cryptAlgo);
 	PWM_ASSERT(pw);
 	PWM_ASSERT(headerLength);
 	PWM_ASSERT(dataHashType);
 	PWM_ASSERT(dataHash);
 	PWM_ASSERT(f);
 	int tmpRet;
 	// check "magic" header
 	const char magicHdr[] = FILE_ID_HEADER;
 	const int hdrLen = array_size(magicHdr) - 1;
 	char tmp[hdrLen];
 	if (f->readBlock(tmp, hdrLen) != hdrLen)
 		return e_readFile;
 	if (memcmp(tmp, magicHdr, hdrLen) != 0)
 		return e_fileFormat;
 	// read and check file ver
 	int fileV = f->getch();
 	if (fileV == -1)
 		return e_fileFormat;
 	if (fileV != PWM_FILE_VER)
 		return e_fileVer;
 	// read hash hash type
 	int keyHash = f->getch();
 	if (keyHash == -1)
 		return e_fileFormat;
 	// read data hash type
 	tmpRet = f->getch();
 	if (tmpRet == -1)
 		return e_fileFormat;
 	*dataHashType = tmpRet;
 	// read crypt algo
 	tmpRet = f->getch();
 	if (tmpRet == -1)
 		return e_fileFormat;
 	*cryptAlgo = tmpRet;
 	// get compression-algo
 	tmpRet = f->getch();
 	if (tmpRet == -1)
 		return e_fileFormat;
 	*compress = tmpRet;
 	// get the MPW-flag
 	int mpw_flag = f->getch();
 	if (mpw_flag == -1)
 		return e_fileFormat;
 	if (mpw_flag == 0x01)
 		setDocStatFlag(DOC_STAT_USE_CHIPCARD);
 	else
 		unsetDocStatFlag(DOC_STAT_USE_CHIPCARD);
 	// skip the "RESERVED"-bytes
 	if (!(f->at(f->at() + 64)))
 		return e_fileFormat;
 
 	*pw = requestMpw(getDocStatFlag(DOC_STAT_USE_CHIPCARD));
 	if (*pw == "") {
 		/* the user didn't give a master-password
 		 * or didn't insert a chipcard
 		 */
 		return e_noPw;
 	}
 	// verify key-hash
 	switch (keyHash) {
 	case PWM_HASH_SHA1: {
 		// read hash from header
 		const int hashLen = SHA1_HASH_LEN_BYTE;
 		string readHash;
 		int i;
 		for (i = 0; i < hashLen; ++i)
 			readHash.push_back(f->getch());
 		Sha1 hash;
 		hash.sha1_write(reinterpret_cast<const byte *>(pw->latin1()), pw->length());
 		string ret = hash.sha1_read();
 		if (ret != readHash)
 			return e_wrongPw;	// hash doesn't match (wrong key)
 		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 *>(pw->latin1()),
 			      pw->length(),
 			      keyHash);
 		if (err != e_success)
 			return e_hashNotImpl;
 		string calcHash(reinterpret_cast<const char *>(buf),
 				static_cast<string::size_type>(hashLen));
 		delete [] buf;
 		// read hash from header
 		string readHash;
 		size_t i;
 		for (i = 0; i < hashLen; ++i)
 			readHash.push_back(f->getch());
 		if (calcHash != readHash)
 			return e_wrongPw;	// hash doesn't match (wrong key)
 		break;
 	} 
 	default: {
 		return e_hashNotImpl;
 	} }
 	// read the data-hash from the file
 	unsigned int hashLen, i;
 	switch (*dataHashType) {
 	case PWM_HASH_SHA1:
 		hashLen = SHA1_HASH_LEN_BYTE;
 		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;
 		hashLen = gc.hashLength(*dataHashType);
 		if (hashLen == 0)
 			return e_hashNotImpl;
 		break;
 	} 
 	default:
 		return e_hashNotImpl;
 	}
 	*dataHash = "";
 	for (i = 0; i < hashLen; ++i) {
 		tmpRet = f->getch();
 		if (tmpRet == -1)
 			return e_fileFormat;
 		dataHash->push_back(static_cast<char>(tmpRet));
 	}
 	*headerLength = f->at();
 #ifndef PWM_EMBEDDED
 	printDebug(string("opening file { compress: ")
 		   + tostr(static_cast<int>(*compress)) + "   cryptAlgo: "
 		   + tostr(static_cast<int>(*cryptAlgo)) + "   keyHashAlgo: "
 		   + tostr(static_cast<int>(keyHash))
 		   + " }");
 #else
 	printDebug(string("opening file { compress: ")
 		   + tostr((int)(*compress)) + "   cryptAlgo: "
 		   + tostr((int)(*cryptAlgo)) + "   keyHashAlgo: "
 		   + tostr((int)(keyHash))
 		   + " }");
 #endif
 
 	return e_success;
 }
 
 PwMerror PwMDoc::writeDataHash(char dataHash, string *d, QFile *f)
 {
 	PWM_ASSERT(d);
 	PWM_ASSERT(f);
 
 	switch (dataHash) {
 	case PWM_HASH_SHA1: {
 		const int hashLen = SHA1_HASH_LEN_BYTE;
 		Sha1 h;
 		h.sha1_write(reinterpret_cast<const byte *>(d->c_str()), d->size());
 		string hRet = h.sha1_read();
 		if (f->writeBlock(hRet.c_str(), hashLen) != hashLen)
 		    	return e_writeFile;
 		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 *>(d->c_str()),
 			      d->size(),
 			      dataHash);
 		if (err != e_success)
 			return e_hashNotImpl;
 		if (f->writeBlock(reinterpret_cast<const char *>(buf), hashLen)
 		    != static_cast<Q_LONG>(hashLen)) {
 			delete [] buf;
 			return e_hashNotImpl;
 		}
 		delete [] buf;
 		break;
 	} 
 	default: {
 		return e_hashNotImpl;
 	} }
 
 	return e_success;
 }
 
 bool PwMDoc::backupFile(const QString &filePath)
 {
 	QFileInfo fi(filePath);
 	if (!fi.exists())
 		return true; // Yes, true is correct.
 	QString pathOnly(fi.dirPath(true));
 	QString nameOnly(fi.fileName());
 	QString backupPath = pathOnly
 			   + "/~"
 			   + nameOnly
 			   + ".backup";
 	return copyFile(filePath, backupPath);
 }
 
 bool PwMDoc::copyFile(const QString &src, const QString &dst)
 {
 	QFileInfo fi(src);
 	if (!fi.exists())
 		return false;
 	if (QFile::exists(dst)) {
 		if (!QFile::remove(dst))
 			return false;
 	}
 	QFile srcFd(src);
 	if (!srcFd.open(IO_ReadOnly))
 		return false;
 	QFile dstFd(dst);
 	if (!dstFd.open(IO_ReadWrite)) {
 		srcFd.close();
 		return false;
 	}
 	const int tmpBuf_size = 512;
 	char tmpBuf[tmpBuf_size];
 	Q_LONG bytesRead, bytesWritten;
 
 	while (!srcFd.atEnd()) {
 		bytesRead = srcFd.readBlock(tmpBuf,
 				  static_cast<Q_ULONG>(tmpBuf_size));
 		if (bytesRead == -1) {
 			srcFd.close();
 			dstFd.close();
 			return false;
 		}
 		bytesWritten = dstFd.writeBlock(tmpBuf,
 				     static_cast<Q_ULONG>(bytesRead));
 		if (bytesWritten != bytesRead) {
 			srcFd.close();
 			dstFd.close();
 			return false;
 		}
 	}
 	srcFd.close();
 	dstFd.close();
 	return true;
 }
 
 PwMerror PwMDoc::addEntry(const QString &category, PwMDataItem *d,
 			  bool dontFlagDirty, bool updateMeta)
 {
 	PWM_ASSERT(d);
 	unsigned int cat = 0;
 
 	if (isDeepLocked()) {
 		PwMerror ret;
 		ret = deepLock(false);
 		if (ret != e_success)
 			return e_lock;
 	}
 
 	addCategory(category, &cat);
 
 	if (numEntries(category) >= maxEntries)
 		return e_maxAllowedEntr;
 
 	vector<unsigned int> foundPositions;
 	/* historically this was:
 	 *	const int searchIn = SEARCH_IN_DESC | SEARCH_IN_NAME |
 	 *			     SEARCH_IN_URL | SEARCH_IN_LAUNCHER;
 	 * But for now we only search in desc.
 	 * That's a tweak to be KWallet compatible. But it should not add
 	 * usability-drop onto PwManager, does it?
 	 * (And yes, "int" was a bug. Correct is "unsigned int")
 	 */
 	const unsigned int searchIn = SEARCH_IN_DESC;
 	findEntry(cat, *d, searchIn, &foundPositions, true);
 	if (foundPositions.size()) {
 		// DOH! We found this entry.
 		return e_entryExists;
 	}
 
 	d->listViewPos = -1;
 	d->lockStat = conf()->confGlobNewEntrLockStat();
 	if (updateMeta) {
 		d->meta.create = QDateTime::currentDateTime();
 		d->meta.update = d->meta.create;
 	}
 	dti.dta[cat].d.push_back(*d);
 
 	delAllEmptyCat(true);
 
 	if (!dontFlagDirty)
 		flagDirty();
 	return e_success;
 }
 
 PwMerror PwMDoc::addCategory(const QString &category, unsigned int *categoryIndex,
 			     bool checkIfExist)
 {
 	if (isDeepLocked()) {
 		PwMerror ret;
 		ret = deepLock(false);
 		if (ret != e_success)
 			return e_lock;
 	}
 	if (checkIfExist) {
 		if (findCategory(category, categoryIndex))
 			return e_categoryExists;
 	}
 	PwMCategoryItem item;
 	//US ENH: clear item to initialize with default values, or create a constructor
 	item.clear();
 
 	item.name = category.latin1();
 	dti.dta.push_back(item);
 	if (categoryIndex)
 		*categoryIndex = dti.dta.size() - 1;
 	return e_success;
 }
 
 bool PwMDoc::delEntry(const QString &category, unsigned int index, bool dontFlagDirty)
 {
 	unsigned int cat = 0;
 
 	if (!findCategory(category, &cat)) {
 		BUG();
 		return false;
 	}
 
 	return delEntry(cat, index, dontFlagDirty);
 }
 
 bool PwMDoc::delEntry(unsigned int category, unsigned int index, bool dontFlagDirty)
 {
 	if (isDeepLocked())
 		return false;
 	if (index > dti.dta[category].d.size() - 1)
 		return false;
 	getDataChangedLock();
 	if (!lockAt(category, index, false)) {
 		putDataChangedLock();
 		return false;
 	}
 	putDataChangedLock();
 	int lvPos = dti.dta[category].d[index].listViewPos;
 
 	// delete entry
 	dti.dta[category].d.erase(dti.dta[category].d.begin() + index);
 
 	unsigned int i, entries = numEntries(category);
 	if (!entries) {
 		// no more entries in this category, so
 		// we can delete it, too.
 		BUG_ON(!delCategory(category));
 		// delCategory() flags it dirty, so we need not to do so.
 		return true;
 	}
 	for (i = 0; i < entries; ++i) {
 		// decrement all listViewPositions that are greater than the deleted.
 		if (dti.dta[category].d[i].listViewPos > lvPos)
 			--dti.dta[category].d[i].listViewPos;
 	}
 
 	if (!dontFlagDirty)
 		flagDirty();
 	return true;
 }
 
 bool PwMDoc::editEntry(const QString &oldCategory, const QString &newCategory,
 		       unsigned int index, PwMDataItem *d, bool updateMeta)
 {
 	PWM_ASSERT(d);
 	unsigned int oldCat = 0;
 
 	if (!findCategory(oldCategory, &oldCat)) {
 		BUG();
 		return false;
 	}
 
 	return editEntry(oldCat, newCategory, index, d, updateMeta);
 }
 
 bool PwMDoc::editEntry(unsigned int oldCategory, const QString &newCategory,
 		       unsigned int index, PwMDataItem *d, bool updateMeta)
 {
 	if (isDeepLocked())
 		return false;
 	if (updateMeta) {
 		d->meta.update = QDateTime::currentDateTime();
 		if (d->meta.create.isNull()) {
 			d->meta.create = d->meta.update;
 		}
 	}
 	if (dti.dta[oldCategory].name != newCategory.latin1()) {
 		// the user changed the category.
 		PwMerror ret;
 		d->rev = 0;
 		ret = addEntry(newCategory, d, true, false);
 		if (ret != e_success)
 			return false;
 		if (!delEntry(oldCategory, index, true))
 			return false;
 	} else {
 		d->rev = dti.dta[oldCategory].d[index].rev + 1; // increment revision counter.
 		dti.dta[oldCategory].d[index] = *d;
 	}
 	flagDirty();
 	return true;
 }
 
 unsigned int PwMDoc::numEntries(const QString &category)
 {
 	unsigned int cat = 0;
 
 	if (!findCategory(category, &cat)) {
 		BUG();
 		return 0;
 	}
 
 	return numEntries(cat);
 }
 
 bool PwMDoc::serializeDta(string *d)
 {
 	PWM_ASSERT(d);
 	Serializer ser;
 	if (!ser.serialize(dti))
 		return false;
 	d->assign(ser.getXml());
 	if (!d->size())
 		return false;
 	return true;
 }
 
 bool PwMDoc::deSerializeDta(const string *d, bool entriesLocked)
 {
 	PWM_ASSERT(d);
 #ifndef PWM_EMBEDDED
 	try {
 
 		Serializer ser(d->c_str());
 		ser.setDefaultLockStat(entriesLocked);
 		if (!ser.deSerialize(&dti))
 			return false;
 	} catch (PwMException) {
 		return false;
 	}
 #else
 	Serializer ser(d->c_str());
 	ser.setDefaultLockStat(entriesLocked);
 	if (!ser.deSerialize(&dti))
 	  return false;
 #endif
 
 	emitDataChanged(this);
 	return true;
 }
 
 bool PwMDoc::getEntry(const QString &category, unsigned int index,
 		      PwMDataItem * d, bool unlockIfLocked)
 {
 	PWM_ASSERT(d);
 	unsigned int cat = 0;
 
 	if (!findCategory(category, &cat)) {
 		BUG();
 		return false;
 	}
 
 	return getEntry(cat, index, d, unlockIfLocked);
 }
 
 bool PwMDoc::getEntry(unsigned int category, unsigned int index,
 		      PwMDataItem *d, bool unlockIfLocked)
 {
 	if (index > dti.dta[category].d.size() - 1)
 		return false;
 
 	bool locked = isLocked(category, index);
 	if (locked) {
 		/* this entry is locked. We don't return a password,
 		 * until it's unlocked by the user by inserting
 		 * chipcard or entering the mpw
 		 */
 		if (unlockIfLocked) {
 			if (!lockAt(category, index, false)) {
 				return false;
 			}
 			locked = false;
 		}
 	}
 
 	*d = dti.dta[category].d[index];
 	if (locked)
 		d->pw = LOCKED_STRING.latin1();
 
 	return true;
 }
 
 PwMerror PwMDoc::getCommentByLvp(const QString &category, int listViewPos,
 				 string *foundComment)
 {
 	PWM_ASSERT(foundComment);
 	unsigned int cat = 0;
 
 	if (!findCategory(category, &cat))
 		return e_invalidArg;
 
 	unsigned int i, entries = numEntries(cat);
 	for (i = 0; i < entries; ++i) {
 		if (dti.dta[cat].d[i].listViewPos == listViewPos) {
 			*foundComment = dti.dta[cat].d[i].comment;
 			if (dti.dta[cat].d[i].binary)
 				return e_binEntry;
 			return e_normalEntry;
 		}
 	}
 	BUG();
 	return e_generic;
 }
 
 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)
+PwMerror PwMDoc::encrypt(string *d, const QString *pw, QFile *f, char algo,
+				 char hashalgo //US BUG: pass _hashalgo because we need it in hashPassphrase
+)
 {
 	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);
+				 algo,
+				 hashalgo //US BUG: pass _hashalgo because we need it in hashPassphrase
+				 );
 		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)
+			 char algo, 
+			 char hashalgo, //US BUG: pass _hashalgo because we need it in hashPassphrase
+			 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);
+				 algo,
+				 hashalgo //US BUG: pass _hashalgo because we need it in hashPassphrase
+);
 		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)
 {
     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) {
diff --git a/pwmanager/pwmanager/pwmdoc.h b/pwmanager/pwmanager/pwmdoc.h
index 138dd3d..9fcdda7 100644
--- a/pwmanager/pwmanager/pwmdoc.h
+++ b/pwmanager/pwmanager/pwmdoc.h
@@ -1,827 +1,831 @@
 /***************************************************************************
  *                                                                         *
  *   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.
 	  */
 	QDateTime	create;
 	/** becomes valid on this date */
 	QDateTime	valid;
 	/** expire date */
 	QDateTime	expire;
 	/** update date (last updated at this date) */
 	QDateTime	update;
 	/** 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 */
 	string	desc;
 	/** user-name */
 	string	name;
 	/** the password itself */
 	string	pw;
 	/** some comment */
 	string	comment;
 	/** an URL string */
 	string	url;
 	/** launcher. Can be executed as a system() command */
 	string	launcher;
 	/** locking status. If locked (true), pw is not emitted through getEntry() */
 	bool	lockStat;
 	/** position of this item in main "list-view"
 	  * If -1, the position is not yet specified and should be appended to the list
 	  */
 	int	listViewPos;
 	/** 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);
+	PwMerror encrypt(string *d, const QString *pw, QFile *f, char algo,
+				 char _hashalgo //US BUG: pass _hashalgo because we need it in hashPassphrase
+);
 	/** 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);
+	PwMerror decrypt(string *d, unsigned int pos, const QString *pw, char algo, 
+		 char _hashalgo, //US BUG: pass _hashalgo because we need it in hashPassphrase
+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