replaced Q_UINT with quint

git-svn-id: https://svn.code.sf.net/p/keepassx/code/trunk@80 b624d157-de02-0410-bad0-e51aec6abb33

changelog

@@ -1,9 +1,14 @@
 ---------------
     0.2.1
 ---------------
--Auto-Type
--Custom Icons Extension
+-added AutoType feature
+-added custom icons feature
+-new command line option for manual language selection (-lang <LOCALE-CODE>)
 -when saving an attachment the original filename is adopted by the file dialog
+-fixed strange sorting behavior of entries (Bug #7083)
+-sorting by dates now works as expected
+-the 'Expires' column and the detailed entry view now also show the string 'never' for entries which don't expire
+-entry view now gets updated after changing the column setup
 ---------------
     0.2.0
 ---------------

src/Database.h

@@ -42,10 +42,10 @@ class CEntry{
 public:
 CEntry();
 ~CEntry();
-Q_UINT8 ID[16];
-Q_UINT32 sID;
-Q_UINT32 GroupID;
-Q_UINT32 ImageID;
+quint8 ID[16];
+quint32 sID;
+quint32 GroupID;
+quint32 ImageID;
 quint32 OldImgID;
 QString Title;
 QString URL;
@@ -58,8 +58,8 @@ KpxDateTime LastMod;
 KpxDateTime LastAccess;
 KpxDateTime Expire;
 QByteArray BinaryData;
-/*Q_UINT32 PasswordLength;*/
-bool ReadEntryField(Q_UINT16 FieldType, Q_UINT32 FieldSize, Q_UINT8 *pData);
+/*quint32 PasswordLength;*/
+bool ReadEntryField(quint16 FieldType, quint32 FieldSize, quint8 *pData);
 bool operator==(const CEntry&) const;
 };
 
@@ -68,17 +68,17 @@ class CGroup{
 public:
 CGroup();
 ~CGroup();
-Q_UINT32 ID;
-Q_UINT32 ImageID;
+quint32 ID;
+quint32 ImageID;
 quint32 OldImgID;
 QString Name;
 QDateTime Creation;
 QDateTime LastMod;
 QDateTime LastAccess;
 QDateTime Expire;
-Q_UINT16 Level;
-Q_UINT32 Flags;
-bool ReadGroupField(Q_UINT16 FieldType, Q_UINT32 FieldSize, Q_UINT8 *pData);
+quint16 Level;
+quint32 Flags;
+bool ReadGroupField(quint16 FieldType, quint32 FieldSize, quint8 *pData);
 bool operator==(const CGroup&) const;
 
 bool 	  UI_ItemIsExpanded;
@@ -132,16 +132,17 @@ public:
  virtual int	   numIcons()=0;
  virtual void	   addIcon(const QPixmap& icon)=0;
  virtual void	   removeIcon(int Id)=0;
+ virtual void	   replaceIcon(int Id,const QPixmap& icon)=0;
 
- Q_UINT32 CryptoAlgorithmus;
- Q_UINT32 KeyEncRounds;
+ quint32 CryptoAlgorithmus;
+ quint32 KeyEncRounds;
  QFile* file;
  bool modflag;
  int SearchGroupID;
 
 protected:
- Q_UINT8 MasterKey[32];
- Q_UINT8 TransformedMasterKey[32];
+ quint8 MasterKey[32];
+ quint8 TransformedMasterKey[32];
 
 };
 

src/PwManager.cpp

@@ -70,11 +70,11 @@ return ids;
 
 bool PwDatabase::openDatabase(QString filename, QString& err){
 unsigned long total_size,crypto_size;
-Q_UINT32 Signature1,Signature2,Version,NumGroups,NumEntries,Flags;
-Q_UINT8 TrafoRandomSeed[32];
-Q_UINT8 FinalRandomSeed[16];
-Q_UINT8 ContentsHash[32];
-Q_UINT8 EncryptionIV[16];
+quint32 Signature1,Signature2,Version,NumGroups,NumEntries,Flags;
+quint8 TrafoRandomSeed[32];
+quint8 FinalRandomSeed[16];
+quint8 ContentsHash[32];
+quint8 EncryptionIV[16];
 
 file=new QFile(filename);
 if(!file->open(QIODevice::ReadWrite)){
@@ -122,7 +122,7 @@ else {
  }
 
 transformKey(MasterKey,TransformedMasterKey,TrafoRandomSeed,KeyEncRounds);
-Q_UINT8 FinalKey[32];
+quint8 FinalKey[32];
 sha256_context sha32;
 sha256_starts(&sha32);
 sha256_update(&sha32,FinalRandomSeed, 16);
@@ -138,15 +138,15 @@ if(CryptoAlgorithmus == ALGO_AES)
 			{err=tr("AES-Init Failed");
 			 return false;}
 		// Decrypt! The first bytes aren't encrypted (that's the header)
-		crypto_size = (unsigned long)aes.padDecrypt((Q_UINT8 *)buffer + DB_HEADER_SIZE,
-			total_size  - DB_HEADER_SIZE, (Q_UINT8 *)buffer + DB_HEADER_SIZE);
+		crypto_size = (unsigned long)aes.padDecrypt((quint8 *)buffer + DB_HEADER_SIZE,
+			total_size  - DB_HEADER_SIZE, (quint8 *)buffer + DB_HEADER_SIZE);
 	}
 else if(CryptoAlgorithmus == ALGO_TWOFISH)
 	{
 		CTwofish twofish;
 		if(twofish.init(FinalKey, 32, EncryptionIV) != true){return false;}
-		crypto_size = (unsigned long)twofish.padDecrypt((Q_UINT8 *)buffer + DB_HEADER_SIZE,
-			total_size - DB_HEADER_SIZE, (Q_UINT8 *)buffer + DB_HEADER_SIZE);
+		crypto_size = (unsigned long)twofish.padDecrypt((quint8 *)buffer + DB_HEADER_SIZE,
+			total_size - DB_HEADER_SIZE, (quint8 *)buffer + DB_HEADER_SIZE);
 	}
 
 if((crypto_size > 2147483446) || (!crypto_size && NumGroups)){err=tr("Decryption failed.\nThe key is wrong or the file is damaged."); return false;}
@@ -163,8 +163,8 @@ return false;}
 
 unsigned long tmp_id=0;
 unsigned long pos = DB_HEADER_SIZE;
-Q_UINT16 FieldType;
-Q_UINT32 FieldSize;
+quint16 FieldType;
+quint32 FieldSize;
 char* pField;
 bool bRet;
 CGroup group;
@@ -185,7 +185,7 @@ CGroup group;
 		 err=tr("Unexpected error: Offset is out of range. [G2]");
 		return false;}
 
-		bRet = group.ReadGroupField(FieldType, FieldSize, (Q_UINT8 *)pField);
+		bRet = group.ReadGroupField(FieldType, FieldSize, (quint8 *)pField);
 		if((FieldType == 0xFFFF) && (bRet == true)){
 			Groups << group;
 			CurGroup++;} // Now and ONLY now the counter gets increased
@@ -215,7 +215,7 @@ CEntry entry;
 		 err=tr("Unexpected error: Offset is out of range. [E2]");
 		 return false; }
 
-		bRet = entry.ReadEntryField(FieldType,FieldSize,(Q_UINT8*)pField);
+		bRet = entry.ReadEntryField(FieldType,FieldSize,(quint8*)pField);
 
 		if((FieldType == 0xFFFF) && (bRet == true)){			
 			entry.sID=tmp_id++;
@@ -252,7 +252,7 @@ return false; //unknown MetaStreams
 }
 
 bool PwDatabase::parseCustomIconsMetaStream(const QByteArray& dta){
-Q_UINT32 NumIcons,NumEntries,NumGroups,offset;
+quint32 NumIcons,NumEntries,NumGroups,offset;
 memcpyFromLEnd32(&NumIcons,dta.data());
 memcpyFromLEnd32(&NumEntries,dta.data()+4);
 memcpyFromLEnd32(&NumGroups,dta.data()+8);
@@ -260,7 +260,7 @@ offset=12;
 CustomIcons.clear();
 for(int i=0;i<NumIcons;i++){
 	CustomIcons << QPixmap();
-	Q_UINT32 Size;
+	quint32 Size;
 	memcpyFromLEnd32(&Size,dta.data()+offset);
 	if(offset+Size > dta.size()){
 		CustomIcons.clear();
@@ -275,7 +275,7 @@ for(int i=0;i<NumIcons;i++){
 		return false;}
 }
 for(int i=0;i<NumEntries;i++){
-	Q_UINT32 Entry,Icon;
+	quint32 Entry,Icon;
 	memcpyFromLEnd32(&Entry,dta.data()+offset);
 	offset+=4;
 	memcpyFromLEnd32(&Icon,dta.data()+offset);
@@ -284,7 +284,7 @@ for(int i=0;i<NumEntries;i++){
 	Entries[Entry].ImageID=Icon;
 }
 for(int i=0;i<NumGroups;i++){
-	Q_UINT32 Group,Icon;
+	quint32 Group,Icon;
 	memcpyFromLEnd32(&Group,dta.data()+offset);
 	offset+=4;
 	memcpyFromLEnd32(&Icon,dta.data()+offset);
@@ -303,19 +303,19 @@ e->Additional="KPX_CUSTOM_ICONS";
 e->URL="$";
 e->ImageID=0;
 int Size=12;
-Q_UINT32 NumEntries=Entries.size();
-Q_UINT32 NumGroups=Groups.size();
+quint32 NumEntries=Entries.size();
+quint32 NumGroups=Groups.size();
 Size+=8*(NumEntries+NumGroups);
 Size+=CustomIcons.size()*1000; // 1KB 
 e->BinaryData.reserve(Size);
 e->BinaryData.resize(12);
-Q_UINT32 NumIcons=CustomIcons.size();
+quint32 NumIcons=CustomIcons.size();
 
 memcpyToLEnd32(e->BinaryData.data(),&NumIcons);
 memcpyToLEnd32(e->BinaryData.data()+4,&NumEntries);
 memcpyToLEnd32(e->BinaryData.data()+8,&NumGroups);
 for(int i=0;i<CustomIcons.size();i++){
-	Q_UINT32 ImgSize;
+	quint32 ImgSize;
 	char ImgSizeBin[4];
 	QByteArray png;
 	png.reserve(1000);
@@ -326,17 +326,17 @@ for(int i=0;i<CustomIcons.size();i++){
 	e->BinaryData.append(QByteArray::fromRawData(ImgSizeBin,4));
 	e->BinaryData.append(png);
 }
-for(Q_UINT32 i=0;i<Entries.size();i++){
+for(quint32 i=0;i<Entries.size();i++){
 		char Bin[8];
 		memcpyToLEnd32(Bin,&i);
-		Q_UINT32 id=Entries[i].ImageID;
+		quint32 id=Entries[i].ImageID;
 		memcpyToLEnd32(Bin+4,&id);
 		e->BinaryData.append(QByteArray::fromRawData(Bin,8));
 }
-for(Q_UINT32 i=0;i<Groups.size();i++){
+for(quint32 i=0;i<Groups.size();i++){
 		char Bin[8];
 		memcpyToLEnd32(Bin,&i);
-		Q_UINT32 id=Groups[i].ImageID;
+		quint32 id=Groups[i].ImageID;
 		memcpyToLEnd32(Bin+4,&id);
 		e->BinaryData.append(QByteArray::fromRawData(Bin,8));
 }
@@ -367,30 +367,37 @@ if(id >= CustomIcons.size()) return;
 CustomIcons.removeAt(id); // .isNull()==true
 for(int i=0;i<Entries.size();i++){
 	if(Entries[i].ImageID == id+BUILTIN_ICONS)
-		Entries[i].ImageID=0;
+		Entries[i].ImageID=Entries[i].OldImgID;
 	if(Entries[i].ImageID>id+BUILTIN_ICONS)
 		Entries[i].ImageID--;
 }
 for(int i=0;i<Groups.size();i++){
 	if(Groups[i].ImageID == id+BUILTIN_ICONS)
-		Groups[i].ImageID=0;
+		Groups[i].ImageID=Groups[i].OldImgID;
 	if(Groups[i].ImageID>id+BUILTIN_ICONS)
 		Groups[i].ImageID--;
 }
+emit modified();
+}
+
+void PwDatabase::replaceIcon(int id,const QPixmap& icon){
+if(id<BUILTIN_ICONS)return;
+CustomIcons[id-BUILTIN_ICONS]=icon;
+emit modified();
 }
 
-void PwDatabase::transformKey(Q_UINT8* src,Q_UINT8* dst,Q_UINT8* KeySeed,int rounds){
-Q_UINT8* tmp=new Q_UINT8[32];
+void PwDatabase::transformKey(quint8* src,quint8* dst,quint8* KeySeed,int rounds){
+quint8* tmp=new quint8[32];
 Rijndael rijndael;
 sha256_context sha2;
-if(rijndael.init(Rijndael::ECB, Rijndael::Encrypt, (const Q_UINT8 *)KeySeed,
+if(rijndael.init(Rijndael::ECB, Rijndael::Encrypt, (const quint8 *)KeySeed,
                  Rijndael::Key32Bytes, 0) != RIJNDAEL_SUCCESS){
   _ERROR
   exit(1);}
 
 memcpy(tmp,src,32);
 for(int i=0;i<rounds;i++){
- rijndael.blockEncrypt((const Q_UINT8 *)tmp, 256, (Q_UINT8 *)tmp);
+ rijndael.blockEncrypt((const quint8 *)tmp, 256, (quint8 *)tmp);
 }
 
 sha256_starts(&sha2);
@@ -518,10 +525,10 @@ return &Entries.back();
 
 
 bool PwDatabase::CalcMasterKeyByFileAndPw(QString filename, QString& Password){
-Q_UINT8* FileKey;
-Q_UINT8* PasswordKey;
-PasswordKey=new Q_UINT8[32];
-FileKey=new Q_UINT8[32];
+quint8* FileKey;
+quint8* PasswordKey;
+PasswordKey=new quint8[32];
+FileKey=new quint8[32];
 sha256_context sha32;
 /////////////////////////
 QFile file(filename);
@@ -605,8 +612,8 @@ entry->GroupID=dst->ID;
 
 CEntry* PwDatabase::cloneEntry(CEntry* entry){
 CEntry *Dolly=addEntry();
-Q_UINT8 ID[16];
-Q_UINT32 sid=Dolly->sID;
+quint8 ID[16];
+quint32 sid=Dolly->sID;
 memcpy(ID,Dolly->ID,16);
 *Dolly=*entry;
 Dolly->sID=sid;
@@ -615,7 +622,7 @@ return Dolly;
 }
 
 
-bool CGroup::ReadGroupField(Q_UINT16 FieldType, Q_UINT32 FieldSize, Q_UINT8 *pData)
+bool CGroup::ReadGroupField(quint16 FieldType, quint32 FieldSize, quint8 *pData)
 {
 
 	switch(FieldType)
@@ -668,7 +675,7 @@ void PwDatabase::newDatabase(){
 	file=new QFile();
 }
 
-bool CEntry::ReadEntryField(Q_UINT16 FieldType, Q_UINT32 FieldSize, Q_UINT8 *pData){
+bool CEntry::ReadEntryField(quint16 FieldType, quint32 FieldSize, quint8 *pData){
 
 
 switch(FieldType)
@@ -743,11 +750,11 @@ return true;
 
 bool PwDatabase::saveDatabase(){
 CGroup SearchGroup;
-Q_UINT32 NumGroups,NumEntries,Signature1,Signature2,Flags,Version;
-Q_UINT8 TrafoRandomSeed[32];
-Q_UINT8 FinalRandomSeed[16];
-Q_UINT8 ContentsHash[32];
-Q_UINT8 EncryptionIV[16];
+quint32 NumGroups,NumEntries,Signature1,Signature2,Flags,Version;
+quint8 TrafoRandomSeed[32];
+quint8 FinalRandomSeed[16];
+quint8 ContentsHash[32];
+quint8 EncryptionIV[16];
 
 Q_ASSERT(file);
 if(!(file->openMode() & QIODevice::WriteOnly)){
@@ -812,8 +819,8 @@ getRandomBytes(FinalRandomSeed,1,16,false);
 getRandomBytes(TrafoRandomSeed,1,32,false);
 getRandomBytes(EncryptionIV,1,16,false);
 
-Q_UINT16 FieldType;
-Q_UINT32 FieldSize;
+quint16 FieldType;
+quint32 FieldSize;
 int pos=DB_HEADER_SIZE; // Skip the header, it will be written later
 
 for(int i=0; i < Groups.size(); i++){
@@ -1059,7 +1066,7 @@ memcpy(buffer+56,ContentsHash,32);
 memcpy(buffer+88,TrafoRandomSeed,32);
 memcpyToLEnd32(buffer+120,&KeyEncRounds);
 transformKey(MasterKey,TransformedMasterKey,TrafoRandomSeed,KeyEncRounds);
-Q_UINT8 FinalKey[32];
+quint8 FinalKey[32];
 sha256_starts(&context);
 sha256_update(&context,FinalRandomSeed, 16);
 sha256_update(&context,TransformedMasterKey, 32);
@@ -1074,18 +1081,18 @@ Rijndael aes;
 	_ERROR
 	delete [] buffer;
 	return false;}
-EncryptedPartSize = (unsigned long)aes.padEncrypt((Q_UINT8*)buffer+DB_HEADER_SIZE,
+EncryptedPartSize = (unsigned long)aes.padEncrypt((quint8*)buffer+DB_HEADER_SIZE,
 						  pos - DB_HEADER_SIZE,
-						  (Q_UINT8*)buffer+DB_HEADER_SIZE);
+						  (quint8*)buffer+DB_HEADER_SIZE);
 }else if(CryptoAlgorithmus == ALGO_TWOFISH){
 CTwofish twofish;
 if(twofish.init(FinalKey, 32, EncryptionIV) == false){
 _ERROR
 delete [] buffer;
 return false;}
-EncryptedPartSize = (unsigned long)twofish.padEncrypt((Q_UINT8*)buffer+DB_HEADER_SIZE,
+EncryptedPartSize = (unsigned long)twofish.padEncrypt((quint8*)buffer+DB_HEADER_SIZE,
 						      pos - DB_HEADER_SIZE,
-						      (Q_UINT8*)buffer+DB_HEADER_SIZE);
+						      (quint8*)buffer+DB_HEADER_SIZE);
 }
 if((EncryptedPartSize > 2147483446) || (!EncryptedPartSize && Groups.size())){
 _ERROR
@@ -1186,14 +1193,14 @@ for(int i=0;i<db->numGroups();i++){
 }
 }
 
-bool PwDatabase::isGroupIdInUse(Q_UINT32 id){
+bool PwDatabase::isGroupIdInUse(quint32 id){
 for(int i=0;i<Groups.size();i++)
  if(Groups[i].ID==id)return true;
 
 return false;
 }
 
-bool PwDatabase::isEntrySidInUse(Q_UINT32 sid){
+bool PwDatabase::isEntrySidInUse(quint32 sid){
 for(int i=0;i<Entries.size();i++)
  if(Entries[i].sID==sid)return true;
 
@@ -1214,8 +1221,8 @@ return true;
 }
 
 
-Q_UINT32 PwDatabase::getNewGroupId(){
-Q_UINT32 id;
+quint32 PwDatabase::getNewGroupId(){
+quint32 id;
 bool used;
 while(1){
 used=false;
@@ -1227,8 +1234,8 @@ if(used==false)break;}
 return id;
 }
 
-Q_UINT32 PwDatabase::getNewEntrySid(){
-Q_UINT32 sid;
+quint32 PwDatabase::getNewEntrySid(){
+quint32 sid;
 while(1){
 getRandomBytes(&sid,4,1,false);
 if(!sid)continue;
@@ -1241,7 +1248,7 @@ bool PwDatabase::convHexToBinaryKey(char* HexKey, char* dst){
 QString hex=QString::fromAscii(HexKey,64);
 for(int i=0; i<64; i+=2){
 	bool err;
-	Q_UINT8 bin;
+	quint8 bin;
 	bin=hex.mid(i,2).toUInt(&err,16);
 	if(!err){
 		qWarning("Invalid Hex Key\n");
@@ -1370,7 +1377,7 @@ void PwDatabase::setEntry(unsigned long index,CEntry& entry){
 int PwDatabase::numEntries(){
 	return Entries.size();}
 
-void memcpyFromLEnd32(Q_UINT32* dst,const char* src){
+void memcpyFromLEnd32(quint32* dst,const char* src){
 
 if(QSysInfo::ByteOrder==QSysInfo::BigEndian){
   memcpy(((char*)dst)+3,src+0,1);
@@ -1382,7 +1389,7 @@ else
   memcpy(dst,src,4);
 }
 
-void memcpyFromLEnd16(Q_UINT16* dst,const char* src){
+void memcpyFromLEnd16(quint16* dst,const char* src){
 
 if(QSysInfo::ByteOrder==QSysInfo::BigEndian){
   memcpy(((char*)dst)+1,src+0,1);
@@ -1392,7 +1399,7 @@ else
   memcpy(dst,src,2);
 }
 
-void memcpyToLEnd32(char* dst,const Q_UINT32* src){
+void memcpyToLEnd32(char* dst,const quint32* src){
 
 if(QSysInfo::ByteOrder==QSysInfo::BigEndian){
   memcpy(dst+0,((char*)src)+3,1);
@@ -1404,7 +1411,7 @@ else
   memcpy(dst,src,4);
 }
 
-void memcpyToLEnd16(char* dst,const Q_UINT16* src){
+void memcpyToLEnd16(char* dst,const quint16* src){
 
 if(QSysInfo::ByteOrder==QSysInfo::BigEndian){
   memcpy(dst+0,((char*)src)+1,1);
@@ -1417,9 +1424,9 @@ else
 const QDateTime Date_Never(QDate(2999,12,28),QTime(23,59,59));
 
 QDateTime dateFromPackedStruct5(const unsigned char* pBytes){
-Q_UINT32 dw1, dw2, dw3, dw4, dw5;
-dw1 = (Q_UINT32)pBytes[0]; dw2 = (Q_UINT32)pBytes[1]; dw3 = (Q_UINT32)pBytes[2];
-dw4 = (Q_UINT32)pBytes[3]; dw5 = (Q_UINT32)pBytes[4];
+quint32 dw1, dw2, dw3, dw4, dw5;
+dw1 = (quint32)pBytes[0]; dw2 = (quint32)pBytes[1]; dw3 = (quint32)pBytes[2];
+dw4 = (quint32)pBytes[3]; dw5 = (quint32)pBytes[4];
 int y = (dw1 << 6) | (dw2 >> 2);
 int mon = ((dw2 & 0x00000003) << 2) | (dw3 >> 6);
 int d = (dw3 >> 1) & 0x0000001F;
@@ -1431,11 +1438,11 @@ return QDateTime(QDate(y,mon,d),QTime(h,min,s));
 
 
 void dateToPackedStruct5(const QDateTime& d,unsigned char* pBytes){
-pBytes[0] = (Q_UINT8)(((Q_UINT32)d.date().year() >> 6) & 0x0000003F);
-pBytes[1] = (Q_UINT8)((((Q_UINT32)d.date().year() & 0x0000003F) << 2) | (((Q_UINT32)d.date().month() >> 2) & 0x00000003));
-pBytes[2] = (Q_UINT8)((((Q_UINT32)d.date().month() & 0x00000003) << 6) | (((Q_UINT32)d.date().day() & 0x0000001F) << 1) | (((Q_UINT32)d.time().hour() >> 4) & 0x00000001));
-pBytes[3] = (Q_UINT8)((((Q_UINT32)d.time().hour() & 0x0000000F) << 4) | (((Q_UINT32)d.time().minute() >> 2) & 0x0000000F));
-pBytes[4] = (Q_UINT8)((((Q_UINT32)d.time().minute() & 0x00000003) << 6) | ((Q_UINT32)d.time().second() & 0x0000003F));
+pBytes[0] = (quint8)(((quint32)d.date().year() >> 6) & 0x0000003F);
+pBytes[1] = (quint8)((((quint32)d.date().year() & 0x0000003F) << 2) | (((quint32)d.date().month() >> 2) & 0x00000003));
+pBytes[2] = (quint8)((((quint32)d.date().month() & 0x00000003) << 6) | (((quint32)d.date().day() & 0x0000001F) << 1) | (((quint32)d.time().hour() >> 4) & 0x00000001));
+pBytes[3] = (quint8)((((quint32)d.time().hour() & 0x0000000F) << 4) | (((quint32)d.time().minute() >> 2) & 0x0000000F));
+pBytes[4] = (quint8)((((quint32)d.time().minute() & 0x00000003) << 6) | ((quint32)d.time().second() & 0x0000003F));
 }
 
 

src/PwManager.h

@@ -84,6 +84,7 @@ public:
  int	   numIcons();
  void	   addIcon(const QPixmap& icon);
  void	   removeIcon(int Id);
+ void	   replaceIcon(int Id,const QPixmap& icon);
 
  QList<CGroup>Groups;
  QList<CEntry>Entries;
@@ -92,12 +93,12 @@ private:
  bool parseMetaStream(const CEntry& Entry);
  bool parseCustomIconsMetaStream(const QByteArray& data);
  void createCustomIconsMetaStream(CEntry* dst);
- void transformKey(Q_UINT8* src,Q_UINT8* dst,Q_UINT8* seed,int rounds);
+ void transformKey(quint8* src,quint8* dst,quint8* seed,int rounds);
  bool readHeader(char* raw);
- bool isGroupIdInUse(Q_UINT32 GroupID);
- bool isEntrySidInUse(Q_UINT32 sID);
- Q_UINT32 getNewGroupId();
- Q_UINT32 getNewEntrySid();
+ bool isGroupIdInUse(quint32 GroupID);
+ bool isEntrySidInUse(quint32 sID);
+ quint32 getNewGroupId();
+ quint32 getNewEntrySid();
  bool convHexToBinaryKey(char* HexKey, char* dst);
  QStringList Errors;
  QList<QPixmap> CustomIcons;
@@ -110,10 +111,10 @@ void modified();
 
 
 
- void memcpyFromLEnd32(Q_UINT32* dst,const char* src);
- void memcpyFromLEnd16(Q_UINT16* dst,const char* src);
- void memcpyToLEnd32(char* src,const Q_UINT32* dst);
- void memcpyToLEnd16(char* src,const Q_UINT16* dst);
+ void memcpyFromLEnd32(quint32* dst,const char* src);
+ void memcpyFromLEnd16(quint16* dst,const char* src);
+ void memcpyToLEnd32(char* src,const quint32* dst);
+ void memcpyToLEnd16(char* src,const quint16* dst);
  QDateTime dateFromPackedStruct5(const unsigned char* pBytes);
  void dateToPackedStruct5(const QDateTime& datetime, unsigned char* dst);
 

src/crypto/blowfish.h

@@ -25,10 +25,10 @@ using std::string;
 #define BLOWFISH_ROUNDS		16
 #define CIPHER_ALGO_BLOWFISH	4	/* blowfish 128 bit key */
 
-#define uint8_t Q_UINT8
-#define uint16_t Q_UINT16
-#define uint32_t Q_UINT32
-#define byte Q_UINT8
+#define uint8_t quint8
+#define uint16_t quint16
+#define uint32_t quint32
+#define byte quint8
 
 /** blowfish encryption algorithm.
   * Derived from libgcrypt-1.1.12

src/crypto/rijndael.cpp

@@ -40,7 +40,7 @@
 #include "rijndael.h"
 
 
-static Q_UINT8 S[256]=
+static quint8 S[256]=
 {
 	 99, 124, 119, 123, 242, 107, 111, 197,  48,   1, 103,  43, 254, 215, 171, 118,
 	202, 130, 201, 125, 250,  89,  71, 240, 173, 212, 162, 175, 156, 164, 114, 192,
@@ -61,7 +61,7 @@ static Q_UINT8 S[256]=
 };
 
 
-static Q_UINT8 T1[256][4]=
+static quint8 T1[256][4]=
 {
 	0xc6,0x63,0x63,0xa5, 0xf8,0x7c,0x7c,0x84, 0xee,0x77,0x77,0x99, 0xf6,0x7b,0x7b,0x8d,
 	0xff,0xf2,0xf2,0x0d, 0xd6,0x6b,0x6b,0xbd, 0xde,0x6f,0x6f,0xb1, 0x91,0xc5,0xc5,0x54,
@@ -129,7 +129,7 @@ static Q_UINT8 T1[256][4]=
 	0x7b,0xb0,0xb0,0xcb, 0xa8,0x54,0x54,0xfc, 0x6d,0xbb,0xbb,0xd6, 0x2c,0x16,0x16,0x3a
 };
 
-static Q_UINT8 T2[256][4]=
+static quint8 T2[256][4]=
 {
 	0xa5,0xc6,0x63,0x63, 0x84,0xf8,0x7c,0x7c, 0x99,0xee,0x77,0x77, 0x8d,0xf6,0x7b,0x7b,
 	0x0d,0xff,0xf2,0xf2, 0xbd,0xd6,0x6b,0x6b, 0xb1,0xde,0x6f,0x6f, 0x54,0x91,0xc5,0xc5,
@@ -197,7 +197,7 @@ static Q_UINT8 T2[256][4]=
 	0xcb,0x7b,0xb0,0xb0, 0xfc,0xa8,0x54,0x54, 0xd6,0x6d,0xbb,0xbb, 0x3a,0x2c,0x16,0x16
 };
 
-static Q_UINT8 T3[256][4]=
+static quint8 T3[256][4]=
 {
 	0x63,0xa5,0xc6,0x63, 0x7c,0x84,0xf8,0x7c, 0x77,0x99,0xee,0x77, 0x7b,0x8d,0xf6,0x7b,
 	0xf2,0x0d,0xff,0xf2, 0x6b,0xbd,0xd6,0x6b, 0x6f,0xb1,0xde,0x6f, 0xc5,0x54,0x91,0xc5,
@@ -265,7 +265,7 @@ static Q_UINT8 T3[256][4]=
 	0xb0,0xcb,0x7b,0xb0, 0x54,0xfc,0xa8,0x54, 0xbb,0xd6,0x6d,0xbb, 0x16,0x3a,0x2c,0x16
 };
 
-static Q_UINT8 T4[256][4]=
+static quint8 T4[256][4]=
 {
 	0x63,0x63,0xa5,0xc6, 0x7c,0x7c,0x84,0xf8, 0x77,0x77,0x99,0xee, 0x7b,0x7b,0x8d,0xf6,
 	0xf2,0xf2,0x0d,0xff, 0x6b,0x6b,0xbd,0xd6, 0x6f,0x6f,0xb1,0xde, 0xc5,0xc5,0x54,0x91,
@@ -333,7 +333,7 @@ static Q_UINT8 T4[256][4]=
 	0xb0,0xb0,0xcb,0x7b, 0x54,0x54,0xfc,0xa8, 0xbb,0xbb,0xd6,0x6d, 0x16,0x16,0x3a,0x2c
 };
 
-static Q_UINT8 T5[256][4]=
+static quint8 T5[256][4]=
 {
 	0x51,0xf4,0xa7,0x50, 0x7e,0x41,0x65,0x53, 0x1a,0x17,0xa4,0xc3, 0x3a,0x27,0x5e,0x96,
 	0x3b,0xab,0x6b,0xcb, 0x1f,0x9d,0x45,0xf1, 0xac,0xfa,0x58,0xab, 0x4b,0xe3,0x03,0x93,
@@ -401,7 +401,7 @@ static Q_UINT8 T5[256][4]=
 	0x7b,0xcb,0x84,0x61, 0xd5,0x32,0xb6,0x70, 0x48,0x6c,0x5c,0x74, 0xd0,0xb8,0x57,0x42
 };
 
-static Q_UINT8 T6[256][4]=
+static quint8 T6[256][4]=
 {
 	0x50,0x51,0xf4,0xa7, 0x53,0x7e,0x41,0x65, 0xc3,0x1a,0x17,0xa4, 0x96,0x3a,0x27,0x5e,
 	0xcb,0x3b,0xab,0x6b, 0xf1,0x1f,0x9d,0x45, 0xab,0xac,0xfa,0x58, 0x93,0x4b,0xe3,0x03,
@@ -469,7 +469,7 @@ static Q_UINT8 T6[256][4]=
 	0x61,0x7b,0xcb,0x84, 0x70,0xd5,0x32,0xb6, 0x74,0x48,0x6c,0x5c, 0x42,0xd0,0xb8,0x57
 };
 
-static Q_UINT8 T7[256][4]=
+static quint8 T7[256][4]=
 {
 	0xa7,0x50,0x51,0xf4, 0x65,0x53,0x7e,0x41, 0xa4,0xc3,0x1a,0x17, 0x5e,0x96,0x3a,0x27,
 	0x6b,0xcb,0x3b,0xab, 0x45,0xf1,0x1f,0x9d, 0x58,0xab,0xac,0xfa, 0x03,0x93,0x4b,0xe3,
@@ -537,7 +537,7 @@ static Q_UINT8 T7[256][4]=
 	0x84,0x61,0x7b,0xcb, 0xb6,0x70,0xd5,0x32, 0x5c,0x74,0x48,0x6c, 0x57,0x42,0xd0,0xb8
 };
 
-static Q_UINT8 T8[256][4]=
+static quint8 T8[256][4]=
 {
 	0xf4,0xa7,0x50,0x51, 0x41,0x65,0x53,0x7e, 0x17,0xa4,0xc3,0x1a, 0x27,0x5e,0x96,0x3a,
 	0xab,0x6b,0xcb,0x3b, 0x9d,0x45,0xf1,0x1f, 0xfa,0x58,0xab,0xac, 0xe3,0x03,0x93,0x4b,
@@ -605,7 +605,7 @@ static Q_UINT8 T8[256][4]=
 	0xcb,0x84,0x61,0x7b, 0x32,0xb6,0x70,0xd5, 0x6c,0x5c,0x74,0x48, 0xb8,0x57,0x42,0xd0
 };
 
-static Q_UINT8 S5[256]=
+static quint8 S5[256]=
 {
 	0x52,0x09,0x6a,0xd5,
 	0x30,0x36,0xa5,0x38,
@@ -673,7 +673,7 @@ static Q_UINT8 S5[256]=
 	0x55,0x21,0x0c,0x7d
 };
 
-static Q_UINT8 U1[256][4]=
+static quint8 U1[256][4]=
 {
 	0x00,0x00,0x00,0x00, 0x0e,0x09,0x0d,0x0b, 0x1c,0x12,0x1a,0x16, 0x12,0x1b,0x17,0x1d,
 	0x38,0x24,0x34,0x2c, 0x36,0x2d,0x39,0x27, 0x24,0x36,0x2e,0x3a, 0x2a,0x3f,0x23,0x31,
@@ -741,7 +741,7 @@ static Q_UINT8 U1[256][4]=
 	0x9f,0x5d,0x80,0xbe, 0x91,0x54,0x8d,0xb5, 0x83,0x4f,0x9a,0xa8, 0x8d,0x46,0x97,0xa3
 };
 
-static Q_UINT8 U2[256][4]=
+static quint8 U2[256][4]=
 {
 	0x00,0x00,0x00,0x00, 0x0b,0x0e,0x09,0x0d, 0x16,0x1c,0x12,0x1a, 0x1d,0x12,0x1b,0x17,
 	0x2c,0x38,0x24,0x34, 0x27,0x36,0x2d,0x39, 0x3a,0x24,0x36,0x2e, 0x31,0x2a,0x3f,0x23,
@@ -809,7 +809,7 @@ static Q_UINT8 U2[256][4]=
 	0xbe,0x9f,0x5d,0x80, 0xb5,0x91,0x54,0x8d, 0xa8,0x83,0x4f,0x9a, 0xa3,0x8d,0x46,0x97
 };
 
-static Q_UINT8 U3[256][4]=
+static quint8 U3[256][4]=
 {
 	0x00,0x00,0x00,0x00, 0x0d,0x0b,0x0e,0x09, 0x1a,0x16,0x1c,0x12, 0x17,0x1d,0x12,0x1b,
 	0x34,0x2c,0x38,0x24, 0x39,0x27,0x36,0x2d, 0x2e,0x3a,0x24,0x36, 0x23,0x31,0x2a,0x3f,
@@ -877,7 +877,7 @@ static Q_UINT8 U3[256][4]=
 	0x80,0xbe,0x9f,0x5d, 0x8d,0xb5,0x91,0x54, 0x9a,0xa8,0x83,0x4f, 0x97,0xa3,0x8d,0x46
 };
 
-static Q_UINT8 U4[256][4]=
+static quint8 U4[256][4]=
 {
 	0x00,0x00,0x00,0x00, 0x09,0x0d,0x0b,0x0e, 0x12,0x1a,0x16,0x1c, 0x1b,0x17,0x1d,0x12,
 	0x24,0x34,0x2c,0x38, 0x2d,0x39,0x27,0x36, 0x36,0x2e,0x3a,0x24, 0x3f,0x23,0x31,0x2a,
@@ -945,7 +945,7 @@ static Q_UINT8 U4[256][4]=
 	0x5d,0x80,0xbe,0x9f, 0x54,0x8d,0xb5,0x91, 0x4f,0x9a,0xa8,0x83, 0x46,0x97,0xa3,0x8d
 };
 
-static Q_UINT32 rcon[30]=
+static quint32 rcon[30]=
 {
 	0x01, 0x02, 0x04, 0x08, 0x10, 0x20,
 	0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8,
@@ -970,7 +970,7 @@ Rijndael::~Rijndael()
 	// nothing here
 }
 
-int Rijndael::init(Mode mode,Direction dir,const Q_UINT8 * key,KeyLength keyLen,Q_UINT8 * initVector)
+int Rijndael::init(Mode mode,Direction dir,const quint8 * key,KeyLength keyLen,quint8 * initVector)
 {
 	// Not initialized yet
 	m_state = Invalid;
@@ -999,7 +999,7 @@ int Rijndael::init(Mode mode,Direction dir,const Q_UINT8 * key,KeyLength keyLen,
 		}
 	}
 
-	Q_UINT32 uKeyLenInBytes;
+	quint32 uKeyLenInBytes;
 
 	// And check the key length
 	switch(keyLen)
@@ -1025,9 +1025,9 @@ int Rijndael::init(Mode mode,Direction dir,const Q_UINT8 * key,KeyLength keyLen,
 
 	if(!key) return RIJNDAEL_BAD_KEY;
 
-	Q_UINT8 keyMatrix[_MAX_KEY_COLUMNS][4];
+	quint8 keyMatrix[_MAX_KEY_COLUMNS][4];
 
-	for(Q_UINT32 i = 0;i < uKeyLenInBytes;i++)keyMatrix[i >> 2][i & 3] = key[i];
+	for(quint32 i = 0;i < uKeyLenInBytes;i++)keyMatrix[i >> 2][i & 3] = key[i];
 
 	keySched(keyMatrix);
 
@@ -1038,10 +1038,10 @@ int Rijndael::init(Mode mode,Direction dir,const Q_UINT8 * key,KeyLength keyLen,
 	return RIJNDAEL_SUCCESS;
 }
 
-int Rijndael::blockEncrypt(const Q_UINT8 *input,int inputLen,Q_UINT8 *outBuffer)
+int Rijndael::blockEncrypt(const quint8 *input,int inputLen,quint8 *outBuffer)
 {
 	int i, k, numBlocks;
-	Q_UINT8 block[16], iv[4][4];
+	quint8 block[16], iv[4][4];
 
 	if(m_state != Valid) return RIJNDAEL_NOT_INITIALIZED;
 	if(m_direction != Encrypt) return RIJNDAEL_BAD_DIRECTION;
@@ -1060,18 +1060,18 @@ int Rijndael::blockEncrypt(const Q_UINT8 *input,int inputLen,Q_UINT8 *outBuffer)
 			}
 		break;
 		case CBC:
-			((Q_UINT32*)block)[0] = ((Q_UINT32*)m_initVector)[0] ^ ((Q_UINT32*)input)[0];
-			((Q_UINT32*)block)[1] = ((Q_UINT32*)m_initVector)[1] ^ ((Q_UINT32*)input)[1];
-			((Q_UINT32*)block)[2] = ((Q_UINT32*)m_initVector)[2] ^ ((Q_UINT32*)input)[2];
-			((Q_UINT32*)block)[3] = ((Q_UINT32*)m_initVector)[3] ^ ((Q_UINT32*)input)[3];
+			((quint32*)block)[0] = ((quint32*)m_initVector)[0] ^ ((quint32*)input)[0];
+			((quint32*)block)[1] = ((quint32*)m_initVector)[1] ^ ((quint32*)input)[1];
+			((quint32*)block)[2] = ((quint32*)m_initVector)[2] ^ ((quint32*)input)[2];
+			((quint32*)block)[3] = ((quint32*)m_initVector)[3] ^ ((quint32*)input)[3];
 			encrypt(block,outBuffer);
 			input += 16;
 			for(i = numBlocks - 1;i > 0;i--)
 			{
-				((Q_UINT32*)block)[0] = ((Q_UINT32*)outBuffer)[0] ^ ((Q_UINT32*)input)[0];
-				((Q_UINT32*)block)[1] = ((Q_UINT32*)outBuffer)[1] ^ ((Q_UINT32*)input)[1];
-				((Q_UINT32*)block)[2] = ((Q_UINT32*)outBuffer)[2] ^ ((Q_UINT32*)input)[2];
-				((Q_UINT32*)block)[3] = ((Q_UINT32*)outBuffer)[3] ^ ((Q_UINT32*)input)[3];
+				((quint32*)block)[0] = ((quint32*)outBuffer)[0] ^ ((quint32*)input)[0];
+				((quint32*)block)[1] = ((quint32*)outBuffer)[1] ^ ((quint32*)input)[1];
+				((quint32*)block)[2] = ((quint32*)outBuffer)[2] ^ ((quint32*)input)[2];
+				((quint32*)block)[3] = ((quint32*)outBuffer)[3] ^ ((quint32*)input)[3];
 				outBuffer += 16;
 				encrypt(block,outBuffer);
 				input += 16;
@@ -1081,19 +1081,19 @@ int Rijndael::blockEncrypt(const Q_UINT8 *input,int inputLen,Q_UINT8 *outBuffer)
 #if STRICT_ALIGN
 			memcpy(iv,m_initVector,16);
 #else  /* !STRICT_ALIGN */
-			*((Q_UINT32*)iv[0]) = *((Q_UINT32*)(m_initVector   ));
-			*((Q_UINT32*)iv[1]) = *((Q_UINT32*)(m_initVector + 4));
-			*((Q_UINT32*)iv[2]) = *((Q_UINT32*)(m_initVector + 8));
-			*((Q_UINT32*)iv[3]) = *((Q_UINT32*)(m_initVector +12));
+			*((quint32*)iv[0]) = *((quint32*)(m_initVector   ));
+			*((quint32*)iv[1]) = *((quint32*)(m_initVector + 4));
+			*((quint32*)iv[2]) = *((quint32*)(m_initVector + 8));
+			*((quint32*)iv[3]) = *((quint32*)(m_initVector +12));
 #endif /* ?STRICT_ALIGN */
 			for(i = numBlocks; i > 0; i--)
 			{
 				for(k = 0; k < 128; k++)
 				{
-					*((Q_UINT32*) block    ) = *((Q_UINT32*)iv[0]);
-					*((Q_UINT32*)(block+ 4)) = *((Q_UINT32*)iv[1]);
-					*((Q_UINT32*)(block+ 8)) = *((Q_UINT32*)iv[2]);
-					*((Q_UINT32*)(block+12)) = *((Q_UINT32*)iv[3]);
+					*((quint32*) block    ) = *((quint32*)iv[0]);
+					*((quint32*)(block+ 4)) = *((quint32*)iv[1]);
+					*((quint32*)(block+ 8)) = *((quint32*)iv[2]);
+					*((quint32*)(block+12)) = *((quint32*)iv[3]);
 					encrypt(block,block);
 					outBuffer[k/8] ^= (block[0] & 0x80) >> (k & 7);
 					iv[0][0] = (iv[0][0] << 1) | (iv[0][1] >> 7);
@@ -1123,10 +1123,10 @@ int Rijndael::blockEncrypt(const Q_UINT8 *input,int inputLen,Q_UINT8 *outBuffer)
 	return 128 * numBlocks;
 }
 
-int Rijndael::padEncrypt(const Q_UINT8 *input, int inputOctets, Q_UINT8 *outBuffer)
+int Rijndael::padEncrypt(const quint8 *input, int inputOctets, quint8 *outBuffer)
 {
 	int i, numBlocks, padLen;
-	Q_UINT8 block[16], *iv;
+	quint8 block[16], *iv;
 
 	if(m_state != Valid) return RIJNDAEL_NOT_INITIALIZED;
 	if(m_direction != Encrypt) return RIJNDAEL_NOT_INITIALIZED;
@@ -1154,10 +1154,10 @@ int Rijndael::padEncrypt(const Q_UINT8 *input, int inputOctets, Q_UINT8 *outBuff
 			iv = m_initVector;
 			for(i = numBlocks; i > 0; i--)
 			{
-				((Q_UINT32*)block)[0] = ((Q_UINT32*)input)[0] ^ ((Q_UINT32*)iv)[0];
-				((Q_UINT32*)block)[1] = ((Q_UINT32*)input)[1] ^ ((Q_UINT32*)iv)[1];
-				((Q_UINT32*)block)[2] = ((Q_UINT32*)input)[2] ^ ((Q_UINT32*)iv)[2];
-				((Q_UINT32*)block)[3] = ((Q_UINT32*)input)[3] ^ ((Q_UINT32*)iv)[3];
+				((quint32*)block)[0] = ((quint32*)input)[0] ^ ((quint32*)iv)[0];
+				((quint32*)block)[1] = ((quint32*)input)[1] ^ ((quint32*)iv)[1];
+				((quint32*)block)[2] = ((quint32*)input)[2] ^ ((quint32*)iv)[2];
+				((quint32*)block)[3] = ((quint32*)input)[3] ^ ((quint32*)iv)[3];
 				encrypt(block, outBuffer);
 				iv = outBuffer;
 				input += 16;
@@ -1169,7 +1169,7 @@ int Rijndael::padEncrypt(const Q_UINT8 *input, int inputOctets, Q_UINT8 *outBuff
 				block[i] = input[i] ^ iv[i];
 			}
 			for (i = 16 - padLen; i < 16; i++) {
-				block[i] = (Q_UINT8)padLen ^ iv[i];
+				block[i] = (quint8)padLen ^ iv[i];
 			}
 			encrypt(block,outBuffer);
 		break;
@@ -1181,10 +1181,10 @@ int Rijndael::padEncrypt(const Q_UINT8 *input, int inputOctets, Q_UINT8 *outBuff
 	return 16*(numBlocks + 1);
 }
 
-int Rijndael::blockDecrypt(const Q_UINT8 *input, int inputLen, Q_UINT8 *outBuffer)
+int Rijndael::blockDecrypt(const quint8 *input, int inputLen, quint8 *outBuffer)
 {
 	int i, k, numBlocks;
-	Q_UINT8 block[16], iv[4][4];
+	quint8 block[16], iv[4][4];
 
 	if(m_state != Valid) return RIJNDAEL_NOT_INITIALIZED;
 	if((m_mode != CFB1) && (m_direction == Encrypt)) return RIJNDAEL_BAD_DIRECTION;
@@ -1207,26 +1207,26 @@ int Rijndael::blockDecrypt(const Q_UINT8 *input, int inputLen, Q_UINT8 *outBuffe
 #if STRICT_ALIGN
 			memcpy(iv,m_initVector,16);
 #else
-			*((Q_UINT32*)iv[0]) = *((Q_UINT32*)(m_initVector  ));
-			*((Q_UINT32*)iv[1]) = *((Q_UINT32*)(m_initVector+ 4));
-			*((Q_UINT32*)iv[2]) = *((Q_UINT32*)(m_initVector+ 8));
-			*((Q_UINT32*)iv[3]) = *((Q_UINT32*)(m_initVector+12));
+			*((quint32*)iv[0]) = *((quint32*)(m_initVector  ));
+			*((quint32*)iv[1]) = *((quint32*)(m_initVector+ 4));
+			*((quint32*)iv[2]) = *((quint32*)(m_initVector+ 8));
+			*((quint32*)iv[3]) = *((quint32*)(m_initVector+12));
 #endif
 			for (i = numBlocks; i > 0; i--)
 			{
 				decrypt(input, block);
-				((Q_UINT32*)block)[0] ^= *((Q_UINT32*)iv[0]);
-				((Q_UINT32*)block)[1] ^= *((Q_UINT32*)iv[1]);
-				((Q_UINT32*)block)[2] ^= *((Q_UINT32*)iv[2]);
-				((Q_UINT32*)block)[3] ^= *((Q_UINT32*)iv[3]);
+				((quint32*)block)[0] ^= *((quint32*)iv[0]);
+				((quint32*)block)[1] ^= *((quint32*)iv[1]);
+				((quint32*)block)[2] ^= *((quint32*)iv[2]);
+				((quint32*)block)[3] ^= *((quint32*)iv[3]);
 #if STRICT_ALIGN
 				memcpy(iv, input, 16);
 				memcpy(outBuf, block, 16);
 #else
-				*((Q_UINT32*)iv[0]) = ((Q_UINT32*)input)[0]; ((Q_UINT32*)outBuffer)[0] = ((Q_UINT32*)block)[0];
-				*((Q_UINT32*)iv[1]) = ((Q_UINT32*)input)[1]; ((Q_UINT32*)outBuffer)[1] = ((Q_UINT32*)block)[1];
-				*((Q_UINT32*)iv[2]) = ((Q_UINT32*)input)[2]; ((Q_UINT32*)outBuffer)[2] = ((Q_UINT32*)block)[2];
-				*((Q_UINT32*)iv[3]) = ((Q_UINT32*)input)[3]; ((Q_UINT32*)outBuffer)[3] = ((Q_UINT32*)block)[3];
+				*((quint32*)iv[0]) = ((quint32*)input)[0]; ((quint32*)outBuffer)[0] = ((quint32*)block)[0];
+				*((quint32*)iv[1]) = ((quint32*)input)[1]; ((quint32*)outBuffer)[1] = ((quint32*)block)[1];
+				*((quint32*)iv[2]) = ((quint32*)input)[2]; ((quint32*)outBuffer)[2] = ((quint32*)block)[2];
+				*((quint32*)iv[3]) = ((quint32*)input)[3]; ((quint32*)outBuffer)[3] = ((quint32*)block)[3];
 #endif
 				input += 16;
 				outBuffer += 16;
@@ -1236,19 +1236,19 @@ int Rijndael::blockDecrypt(const Q_UINT8 *input, int inputLen, Q_UINT8 *outBuffe
 #if STRICT_ALIGN
 			memcpy(iv, m_initVector, 16);
 #else
-			*((Q_UINT32*)iv[0]) = *((Q_UINT32*)(m_initVector));
-			*((Q_UINT32*)iv[1]) = *((Q_UINT32*)(m_initVector+ 4));
-			*((Q_UINT32*)iv[2]) = *((Q_UINT32*)(m_initVector+ 8));
-			*((Q_UINT32*)iv[3]) = *((Q_UINT32*)(m_initVector+12));
+			*((quint32*)iv[0]) = *((quint32*)(m_initVector));
+			*((quint32*)iv[1]) = *((quint32*)(m_initVector+ 4));
+			*((quint32*)iv[2]) = *((quint32*)(m_initVector+ 8));
+			*((quint32*)iv[3]) = *((quint32*)(m_initVector+12));
 #endif
 			for(i = numBlocks; i > 0; i--)
 			{
 				for(k = 0; k < 128; k++)
 				{
-					*((Q_UINT32*) block    ) = *((Q_UINT32*)iv[0]);
-					*((Q_UINT32*)(block+ 4)) = *((Q_UINT32*)iv[1]);
-					*((Q_UINT32*)(block+ 8)) = *((Q_UINT32*)iv[2]);
-					*((Q_UINT32*)(block+12)) = *((Q_UINT32*)iv[3]);
+					*((quint32*) block    ) = *((quint32*)iv[0]);
+					*((quint32*)(block+ 4)) = *((quint32*)iv[1]);
+					*((quint32*)(block+ 8)) = *((quint32*)iv[2]);
+					*((quint32*)(block+12)) = *((quint32*)iv[3]);
 					encrypt(block, block);
 					iv[0][0] = (iv[0][0] << 1) | (iv[0][1] >> 7);
 					iv[0][1] = (iv[0][1] << 1) | (iv[0][2] >> 7);
@@ -1278,11 +1278,11 @@ int Rijndael::blockDecrypt(const Q_UINT8 *input, int inputLen, Q_UINT8 *outBuffe
 	return 128*numBlocks;
 }
 
-int Rijndael::padDecrypt(const Q_UINT8 *input, int inputOctets, Q_UINT8 *outBuffer)
+int Rijndael::padDecrypt(const quint8 *input, int inputOctets, quint8 *outBuffer)
 {
 	int i, numBlocks, padLen;
-	Q_UINT8 block[16];
-	Q_UINT32 iv[4];
+	quint8 block[16];
+	quint32 iv[4];
 
 	if(m_state != Valid) return RIJNDAEL_NOT_INITIALIZED;
 	if(m_direction != Decrypt) return RIJNDAEL_BAD_DIRECTION;
@@ -1317,10 +1317,10 @@ int Rijndael::padDecrypt(const Q_UINT8 *input, int inputOctets, Q_UINT8 *outBuff
 			for (i = numBlocks - 1; i > 0; i--)
 			{
 				decrypt(input, block);
-				((Q_UINT32*)block)[0] ^= iv[0];
-				((Q_UINT32*)block)[1] ^= iv[1];
-				((Q_UINT32*)block)[2] ^= iv[2];
-				((Q_UINT32*)block)[3] ^= iv[3];
+				((quint32*)block)[0] ^= iv[0];
+				((quint32*)block)[1] ^= iv[1];
+				((quint32*)block)[2] ^= iv[2];
+				((quint32*)block)[3] ^= iv[3];
 				memcpy(iv, input, 16);
 				memcpy(outBuffer, block, 16);
 				input += 16;
@@ -1328,10 +1328,10 @@ int Rijndael::padDecrypt(const Q_UINT8 *input, int inputOctets, Q_UINT8 *outBuff
 			}
 			/* last block */
 			decrypt(input, block);
-			((Q_UINT32*)block)[0] ^= iv[0];
-			((Q_UINT32*)block)[1] ^= iv[1];
-			((Q_UINT32*)block)[2] ^= iv[2];
-			((Q_UINT32*)block)[3] ^= iv[3];
+			((quint32*)block)[0] ^= iv[0];
+			((quint32*)block)[1] ^= iv[1];
+			((quint32*)block)[2] ^= iv[2];
+			((quint32*)block)[3] ^= iv[3];
 			padLen = block[15];
 			if((padLen <= 0) || (padLen > 16)) return RIJNDAEL_CORRUPTED_DATA;
 			for(i = 16 - padLen; i < 16; i++)
@@ -1354,7 +1354,7 @@ int Rijndael::padDecrypt(const Q_UINT8 *input, int inputOctets, Q_UINT8 *outBuff
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
-void Rijndael::keySched(Q_UINT8 key[_MAX_KEY_COLUMNS][4])
+void Rijndael::keySched(quint8 key[_MAX_KEY_COLUMNS][4])
 {
 	int j,rconpointer = 0;
 
@@ -1362,13 +1362,13 @@ void Rijndael::keySched(Q_UINT8 key[_MAX_KEY_COLUMNS][4])
 	// The number of calculations depends on keyBits and blockBits
 	int uKeyColumns = m_uRounds - 6;
 
-	Q_UINT8 tempKey[_MAX_KEY_COLUMNS][4];
+	quint8 tempKey[_MAX_KEY_COLUMNS][4];
 
 	// Copy the input key to the temporary key matrix
 
 	for(j = 0;j < uKeyColumns;j++)
 	{
-		*((Q_UINT32*)(tempKey[j])) = *((Q_UINT32*)(key[j]));
+		*((quint32*)(tempKey[j])) = *((quint32*)(key[j]));
 	}
 
 	int r = 0;
@@ -1379,7 +1379,7 @@ void Rijndael::keySched(Q_UINT8 key[_MAX_KEY_COLUMNS][4])
 	{
 		for(;(j < uKeyColumns) && (t < 4); j++, t++)
 		{
-			*((Q_UINT32*)m_expandedKey[r][t]) = *((Q_UINT32*)tempKey[j]);
+			*((quint32*)m_expandedKey[r][t]) = *((quint32*)tempKey[j]);
 		}
 
 
@@ -1402,12 +1402,12 @@ void Rijndael::keySched(Q_UINT8 key[_MAX_KEY_COLUMNS][4])
 		{
 			for(j = 1; j < uKeyColumns; j++)
 			{
-				*((Q_UINT32*)tempKey[j]) ^= *((Q_UINT32*)tempKey[j-1]);
+				*((quint32*)tempKey[j]) ^= *((quint32*)tempKey[j-1]);
 			}
 		} else {
 			for(j = 1; j < uKeyColumns/2; j++)
 			{
-				*((Q_UINT32*)tempKey[j]) ^= *((Q_UINT32*)tempKey[j-1]);
+				*((quint32*)tempKey[j]) ^= *((quint32*)tempKey[j-1]);
 			}
 			tempKey[uKeyColumns/2][0] ^= S[tempKey[uKeyColumns/2 - 1][0]];
 			tempKey[uKeyColumns/2][1] ^= S[tempKey[uKeyColumns/2 - 1][1]];
@@ -1415,14 +1415,14 @@ void Rijndael::keySched(Q_UINT8 key[_MAX_KEY_COLUMNS][4])
 			tempKey[uKeyColumns/2][3] ^= S[tempKey[uKeyColumns/2 - 1][3]];
 			for(j = uKeyColumns/2 + 1; j < uKeyColumns; j++)
 			{
-				*((Q_UINT32*)tempKey[j]) ^= *((Q_UINT32*)tempKey[j-1]);
+				*((quint32*)tempKey[j]) ^= *((quint32*)tempKey[j-1]);
 			}
 		}
 		for(j = 0; (j < uKeyColumns) && (r <= (int)m_uRounds); )
 		{
 			for(; (j < uKeyColumns) && (t < 4); j++, t++)
 			{
-				*((Q_UINT32*)m_expandedKey[r][t]) = *((Q_UINT32*)tempKey[j]);
+				*((quint32*)m_expandedKey[r][t]) = *((quint32*)tempKey[j]);
 			}
 			if(t == 4)
 			{