summaryrefslogtreecommitdiffstats
path: root/kgpg/kgpginterface.cpp
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commit2bda8f7717adf28da4af0d34fb82f63d2868c31d (patch)
tree8d927b7b47a90c4adb646482a52613f58acd6f8c /kgpg/kgpginterface.cpp
downloadtdeutils-2bda8f7717adf28da4af0d34fb82f63d2868c31d.tar.gz
tdeutils-2bda8f7717adf28da4af0d34fb82f63d2868c31d.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdeutils@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'kgpg/kgpginterface.cpp')
-rw-r--r--kgpg/kgpginterface.cpp2166
1 files changed, 2166 insertions, 0 deletions
diff --git a/kgpg/kgpginterface.cpp b/kgpg/kgpginterface.cpp
new file mode 100644
index 0000000..5286c3c
--- /dev/null
+++ b/kgpg/kgpginterface.cpp
@@ -0,0 +1,2166 @@
+/***************************************************************************
+ kgpginterface.cpp - description
+ -------------------
+ begin : Mon Jul 8 2002
+ copyright : (C) 2002 by Jean-Baptiste Mardelle
+ email : bj@altern.org
+ ***************************************************************************/
+
+/***************************************************************************
+ * *
+ * This program is free software; you can redistribute it and/or modify *
+ * it under the terms of the GNU General Public License as published by *
+ * the Free Software Foundation; either version 2 of the License, or *
+ * (at your option) any later version. *
+ * *
+ ***************************************************************************/
+
+#include <stdio.h>
+
+#include <qdialog.h>
+#include <qclipboard.h>
+#include <qlayout.h>
+#include <qregexp.h>
+#include <qstring.h>
+#include <qlabel.h>
+#include <qapplication.h>
+#include <kio/netaccess.h>
+#include <qcheckbox.h>
+
+#include <kmessagebox.h>
+#include <klocale.h>
+#include <kpassdlg.h>
+#include <kmdcodec.h>
+#include <klineedit.h>
+#include <kcharsets.h>
+#include <kpassivepopup.h>
+#include <kiconloader.h>
+#include <kaction.h>
+#include <qtextcodec.h>
+#include <kprocess.h>
+#include <kprocio.h>
+#include <kconfig.h>
+#include <qfile.h>
+#include <kled.h>
+#include <kdebug.h>
+#include <ktempfile.h>
+
+#include "kgpginterface.h"
+#include "listkeys.h"
+#include "detailedconsole.h"
+
+KgpgInterface::KgpgInterface()
+{}
+
+
+int KgpgInterface::getGpgVersion()
+{
+FILE *fp;
+ QString readResult,gpgString;
+ char buffer[200];
+ bool readLine=true;
+
+ QString gpgcmd="gpg --version";
+
+ fp = popen(QFile::encodeName(gpgcmd), "r");
+ while ( fgets( buffer, sizeof(buffer), fp)) {
+ readResult=buffer;
+ if (readLine) {
+ gpgString=readResult.stripWhiteSpace().section(' ',-1);
+ readLine=false;
+ }
+ }
+ pclose(fp);
+ return (100*gpgString.section('.',0,0).toInt()+10*gpgString.section('.',1,1).toInt()+gpgString.section('.',2,2).toInt());
+}
+
+void KgpgInterface::updateIDs(QString txtString)
+{
+ int cut=txtString.find(' ',22,false);
+ txtString.remove(0,cut);
+ if (txtString.find("(",0,false)!=-1)
+ txtString=txtString.section('(',0,0)+txtString.section(')',-1);
+ txtString.replace(QRegExp("<"),"&lt;");
+ if (userIDs.find(txtString)==-1)
+ {
+ if (!userIDs.isEmpty())
+ userIDs+=i18n(" or ");
+ userIDs+=txtString;
+ }
+}
+
+void KgpgInterface::KgpgEncryptFile(QStringList encryptKeys,KURL srcUrl,KURL destUrl, QStringList Options, bool symetrical)
+{
+ sourceFile=srcUrl;
+ message=QString::null;
+
+ KProcIO *proc=new KProcIO(QTextCodec::codecForLocale());
+ *proc<<"gpg"<<"--no-tty"<<"--no-secmem-warning"<<"--status-fd=2"<<"--command-fd=0"<<"--utf8-strings";
+ for ( QStringList::Iterator it = Options.begin(); it != Options.end(); ++it )
+ if (!QFile::encodeName(*it).isEmpty()) *proc<< QFile::encodeName(*it);
+
+ *proc<<"--output"<<QFile::encodeName(destUrl.path());
+
+ if (!symetrical) {
+ *proc<<"-e";
+ for ( QStringList::Iterator it = encryptKeys.begin(); it != encryptKeys.end(); ++it )
+ *proc<<"--recipient"<< *it;
+ } else //////////// symetrical encryption, prompt for password
+ *proc<<"-c";
+
+ *proc<<QFile::encodeName(srcUrl.path());
+
+ ///////// when process ends, update dialog infos
+ QObject::connect(proc, SIGNAL(processExited(KProcess *)),this,SLOT(encryptfin(KProcess *)));
+ QObject::connect(proc,SIGNAL(readReady(KProcIO *)),this,SLOT(readencprocess(KProcIO *)));
+ proc->start(KProcess::NotifyOnExit,true);
+}
+
+
+KgpgInterface::~KgpgInterface()
+{}
+
+
+void KgpgInterface::encryptfin(KProcess *)
+{
+ if (message.find("END_ENCRYPTION")!=-1)
+ emit encryptionfinished(sourceFile);
+ else {
+ emit errormessage(message);
+ }
+}
+
+void KgpgInterface::readencprocess(KProcIO *p)
+{
+ QString required;
+ while (p->readln(required,true)!=-1) {
+ if (required.find("BEGIN_ENCRYPTION",0,false)!=-1)
+ emit processstarted(sourceFile.path());
+ if (required.find("GET_")!=-1) {
+ if (required.find("openfile.overwrite.okay")!=-1)
+ p->writeStdin("Yes");
+ else if ((required.find("passphrase.enter")!=-1)) {
+ QCString passphrase;
+ int code=KPasswordDialog::getNewPassword(passphrase,i18n("Enter passphrase for your file (symmetrical encryption):"));
+ if (code!=QDialog::Accepted) {
+ p->deleteLater();
+ emit processaborted(true);
+ return;
+ }
+ p->writeStdin(passphrase,true);
+ } else {
+ p->writeStdin("quit");
+ p->closeWhenDone();
+ }
+ }
+ message+=required+"\n";
+ }
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////// File decryption
+
+void KgpgInterface::KgpgDecryptFile(KURL srcUrl,KURL destUrl,QStringList Options)
+{
+ message=QString::null;
+ step=3;
+ decryptUrl=srcUrl.path();
+ userIDs=QString::null;
+ anonymous=false;
+
+ KProcIO *proc=new KProcIO(QTextCodec::codecForLocale());
+
+ *proc<<"gpg"<<"--no-tty"<<"--no-secmem-warning"<<"--status-fd=2"<<"--command-fd=0"<<"--utf8-strings";
+
+ for ( QStringList::Iterator it = Options.begin(); it != Options.end(); ++it )
+ if (!QFile::encodeName(*it).isEmpty()) *proc<< QFile::encodeName(*it);
+
+ if (!destUrl.fileName().isEmpty()) // a filename was entered
+ *proc<<"-o"<<QFile::encodeName(destUrl.path());
+
+ *proc<<"-d"<<QFile::encodeName(srcUrl.path());
+
+ QObject::connect(proc, SIGNAL(processExited(KProcess *)),this,SLOT(decryptfin(KProcess *)));
+ QObject::connect(proc,SIGNAL(readReady(KProcIO *)),this,SLOT(readdecprocess(KProcIO *)));
+ proc->start(KProcess::NotifyOnExit,true);
+}
+
+void KgpgInterface::decryptfin(KProcess *)
+{
+ if ((message.find("DECRYPTION_OKAY")!=-1) && (message.find("END_DECRYPTION")!=-1)) //&& (message.find("GOODMDC")!=-1)
+ emit decryptionfinished();
+ else
+ emit errormessage(message);
+}
+
+
+void KgpgInterface::readdecprocess(KProcIO *p)
+{
+ QString required;
+ while (p->readln(required,true)!=-1) {
+ if (required.find("BEGIN_DECRYPTION",0,false)!=-1)
+ emit processstarted(decryptUrl);
+ if (required.find("USERID_HINT",0,false)!=-1)
+ updateIDs(required);
+
+ if (required.find("ENC_TO")!=-1) {
+ if (required.find("0000000000000000")!=-1)
+ anonymous=true;
+ }
+ if (required.find("GET_")!=-1) {
+ if (required.find("openfile.overwrite.okay")!=-1)
+ p->writeStdin("Yes");
+ else if ((required.find("passphrase.enter")!=-1)) {
+ if (userIDs.isEmpty())
+ userIDs=i18n("[No user id found]");
+ userIDs.replace(QRegExp("<"),"&lt;");
+ QCString passphrase;
+ QString passdlgmessage;
+ if (anonymous)
+ passdlgmessage=i18n("<b>No user id found</b>. Trying all secret keys.<br>");
+ if ((step<3) && (!anonymous))
+ passdlgmessage=i18n("<b>Bad passphrase</b>. You have %1 tries left.<br>").arg(step);
+
+ passdlgmessage+=i18n("Enter passphrase for <b>%1</b>").arg(userIDs);
+ int code=KPasswordDialog::getPassword(passphrase,passdlgmessage);
+ if (code!=QDialog::Accepted) {
+ p->deleteLater();
+ emit processaborted(true);
+ return;
+ }
+ p->writeStdin(passphrase,true);
+ userIDs=QString::null;
+ if (step>1) step--;
+ else step=3;
+ } else {
+ p->writeStdin("quit");
+ p->closeWhenDone();
+ }
+ }
+ message+=required+"\n";
+ }
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////// Text encryption
+
+
+void KgpgInterface::KgpgEncryptText(QString text,QStringList userIDs, QStringList Options)
+{
+ message=QString::null;
+ //QTextCodec *codec = KGlobal::charsets()->codecForName(KGlobal::locale()->encoding());
+ QTextCodec *codec =QTextCodec::codecForLocale ();
+ if (codec->canEncode(text)) txtToEncrypt=text;
+ else txtToEncrypt=text.utf8();
+
+ KProcIO *proc=new KProcIO(QTextCodec::codecForLocale());
+ *proc<<"gpg"<<"--no-tty"<<"--no-secmem-warning"<<"--command-fd=0"<<"--status-fd=1"<<"--utf8-strings";
+
+ for ( QStringList::Iterator it = Options.begin(); it != Options.end(); ++it )
+ if (!QFile::encodeName(*it).isEmpty()) *proc<< QFile::encodeName(*it);
+
+ if (!userIDs.isEmpty())
+ {
+ *proc<<"-e";
+ for ( QStringList::Iterator it = userIDs.begin(); it != userIDs.end(); ++it )
+ *proc<<"--recipient"<< *it;
+ }
+ else
+ *proc<<"-c";
+
+ ///////// when process ends, update dialog infos
+
+ QObject::connect(proc, SIGNAL(processExited(KProcess *)),this,SLOT(txtencryptfin(KProcess *)));
+ QObject::connect(proc,SIGNAL(readReady(KProcIO *)),this,SLOT(txtreadencprocess(KProcIO *)));
+ proc->start(KProcess::NotifyOnExit,false);
+ emit txtencryptionstarted();
+}
+
+
+void KgpgInterface::txtencryptfin(KProcess *)
+{
+ if (!message.isEmpty())
+ emit txtencryptionfinished(message);
+ else
+ emit txtencryptionfinished(QString::null);
+}
+
+void KgpgInterface::txtreadencprocess(KProcIO *p)
+{
+ QString required;
+ while (p->readln(required,true)!=-1) {
+ if (required.find("BEGIN_ENCRYPTION",0,false)!=-1)
+ {
+ p->writeStdin(txtToEncrypt,false);
+ txtToEncrypt=QString::null;
+ p->closeWhenDone();
+ }
+ else
+ if ((required.find("passphrase.enter")!=-1))
+ {
+ QCString passphrase;
+ QString passdlgmessage=i18n("Enter passphrase (symmetrical encryption)");
+ int code=KPasswordDialog::getNewPassword(passphrase,passdlgmessage);
+ if (code!=QDialog::Accepted)
+ {
+ p->deleteLater();
+ return;
+ }
+ p->writeStdin(passphrase,true);
+ }
+ else
+ if (!required.startsWith("[GNUPG:]")) message+=required+"\n";
+ }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Text decryption
+
+void KgpgInterface::KgpgDecryptText(QString text,QStringList Options)
+{
+ gpgOutput=QString::null;
+ log=QString::null;
+
+ message=QString::null;
+ userIDs=QString::null;
+ step=3;
+ anonymous=false;
+ decfinished=false;
+ decok=false;
+ badmdc=false;
+ KProcess *proc=new KProcess();
+ *proc<<"gpg"<<"--no-tty"<<"--no-secmem-warning"<<"--command-fd=0"<<"--status-fd=2"<<"--no-batch"<<"--utf8-strings";
+ for ( QStringList::Iterator it = Options.begin(); it != Options.end(); ++it )
+ if (!QFile::encodeName(*it).isEmpty()) *proc<< QFile::encodeName(*it);
+ *proc<<"-d";
+
+ ///////// when process ends, update dialog infos
+
+ QObject::connect(proc, SIGNAL(processExited(KProcess *)),this,SLOT(txtdecryptfin(KProcess *)));
+ connect(proc, SIGNAL(receivedStdout(KProcess *, char *, int)),this, SLOT(getOutput(KProcess *, char *, int)));
+ connect(proc, SIGNAL(receivedStderr(KProcess *, char *, int)),this, SLOT(getCmdOutput(KProcess *, char *, int)));
+ proc->start(KProcess::NotifyOnExit,KProcess::All);
+ proc->writeStdin(text.utf8(), text.length());
+}
+
+void KgpgInterface::txtdecryptfin(KProcess *)
+{
+if ((decok) && (!badmdc))
+emit txtdecryptionfinished(message);
+
+else if (badmdc)
+{
+KMessageBox::sorry(0,i18n("Bad MDC detected. The encrypted text has been manipulated."));
+emit txtdecryptionfailed(log);
+}
+else
+emit txtdecryptionfailed(log);
+}
+
+
+void KgpgInterface::getOutput(KProcess *, char *data, int )
+{
+ message.append(QString::fromUtf8(data));
+}
+
+
+void KgpgInterface::getCmdOutput(KProcess *p, char *data, int )
+{
+ gpgOutput.append(QString::fromUtf8(data));
+ log.append(data);
+
+ int pos;
+ while ((pos=gpgOutput.find("\n"))!=-1)
+ {
+ QString required=gpgOutput.left(pos);
+ gpgOutput.remove(0,pos+2);
+
+ if (required.find("USERID_HINT",0,false)!=-1)
+ updateIDs(required);
+
+ if (required.find("ENC_TO")!=-1)
+ {
+ if (required.find("0000000000000000")!=-1)
+ anonymous=true;
+ }
+
+ if (required.find("GET_")!=-1)
+ {
+ if ((required.find("passphrase.enter")!=-1))
+ {
+ if (userIDs.isEmpty())
+ userIDs=i18n("[No user id found]");
+ QCString passphrase;
+ QString passdlgmessage;
+ if (anonymous)
+ passdlgmessage=i18n("<b>No user id found</b>. Trying all secret keys.<br>");
+ if ((step<3) && (!anonymous))
+ passdlgmessage=i18n("<b>Bad passphrase</b>. You have %1 tries left.<br>").arg(step);
+ passdlgmessage+=i18n("Enter passphrase for <b>%1</b>").arg(userIDs);
+ int code=KPasswordDialog::getPassword(passphrase,passdlgmessage);
+ if (code!=QDialog::Accepted)
+ {
+ p->deleteLater();
+ emit processaborted(true);
+ return;
+ }
+ passphrase.append("\n");
+ p->writeStdin(passphrase,passphrase.length());
+ userIDs=QString::null;
+ if (step>1) step--;
+ else step=3;
+ }
+ else
+ {
+ p->writeStdin("quit",4);
+ p->closeStdin();
+ }
+ }
+
+ if (required.find("BEGIN_DECRYPTION")!=-1)
+ {
+ p->closeStdin();
+ required=QString::null;
+ }
+
+ if (required.find("END_DECRYPTION")!=-1) decfinished=true;
+ if (required.find("DECRYPTION_OKAY")!=-1) decok=true;
+ if (required.find("DECRYPTION_FAILED")!=-1) decok=false;
+ if (required.find("BADMDC")!=-1) badmdc=true;
+ }
+}
+////////////////////////////////////////////////////////////////////////////////////////////////////////// Text signing
+
+
+void KgpgInterface::KgpgSignText(QString text,QString userIDs, QStringList Options)
+{
+ message=QString::null;
+ step=4;
+ QString txtprocess;
+ QTextCodec *codec =QTextCodec::codecForLocale ();
+ if (codec->canEncode(text)) txtprocess=text;
+ else txtprocess=text.utf8();
+
+ KProcIO *proc=new KProcIO(QTextCodec::codecForLocale());
+ *proc<<"gpg"<<"--no-tty"<<"--no-secmem-warning"<<"--command-fd=0"<<"--status-fd=1"<<"--utf8-strings";
+
+ for ( QStringList::Iterator it = Options.begin(); it != Options.end(); ++it )
+ if (!QFile::encodeName(*it).isEmpty()) *proc<< QFile::encodeName(*it);
+ *proc<<"--clearsign"<<"-u"<<userIDs;
+
+ ///////// when process ends, update dialog infos
+
+ QObject::connect(proc, SIGNAL(processExited(KProcess *)),this,SLOT(txtsignfin(KProcess *)));
+ QObject::connect(proc,SIGNAL(readReady(KProcIO *)),this,SLOT(txtsignprocess(KProcIO *)));
+
+ //emit txtsigningstarted();
+
+ proc->start(KProcess::NotifyOnExit,false);
+ /*if (useAgent)
+ {
+ kdDebug(2100)<<"Using Agent+++++++++++++"<<endl;
+ //KMessageBox::sorry(0,"using agent");
+ proc->writeStdin(txtprocess,true);
+ proc->closeWhenDone();
+ }
+ else*/
+ message=txtprocess;
+}
+
+
+void KgpgInterface::txtsignfin(KProcess *)
+{
+ if (!message.isEmpty())
+ emit txtSignOver(message);
+ else
+ emit txtSignOver(QString::null);
+}
+
+void KgpgInterface::txtsignprocess(KProcIO *p)
+{
+ QString required;
+ while (p->readln(required,true)!=-1) {
+// kdDebug(2100)<<"SIGNING: "<<required<<endl;
+
+ if (required.find("USERID_HINT",0,false)!=-1)
+ updateIDs(required);
+
+ if (required.find("GOOD_PASSPHRASE")!=-1)
+ {
+ p->writeStdin(message,true);
+ message=QString::null;
+ p->closeWhenDone();
+ }
+
+ if ((required.find("passphrase.enter")!=-1))
+ {
+ if (step>1) step--;
+ else step=3;
+ if (userIDs.isEmpty())
+ userIDs=i18n("[No user id found]");
+ QCString passphrase;
+ QString passdlgmessage;
+ if (step<3)
+ passdlgmessage=i18n("<b>Bad passphrase</b>. You have %1 tries left.<br>").arg(step);
+ passdlgmessage+=i18n("Enter passphrase for <b>%1</b>").arg(userIDs);
+ int code=KPasswordDialog::getPassword(passphrase,passdlgmessage);
+ if (code!=QDialog::Accepted)
+ {
+ p->deleteLater();
+ return;
+ }
+ p->writeStdin(passphrase,true);
+ }
+ else
+ if (!required.startsWith("[GNUPG:]")) message+=required+"\n";
+ }
+}
+
+
+//////////////////////////////////////////////// decrypt file to text
+
+void KgpgInterface::KgpgDecryptFileToText(KURL srcUrl,QStringList Options)
+{
+
+ message=QString::null;
+ userIDs=QString::null;
+ step=3;
+ anonymous=false;
+decfinished=false;
+decok=false;
+badmdc=false;
+
+ KProcess *proc=new KProcess();
+ *proc<<"gpg"<<"--no-tty"<<"--utf8-strings"<<"--no-secmem-warning"<<"--command-fd=0"<<"--status-fd=2"<<"--no-batch"<<"-o"<<"-";
+ for ( QStringList::Iterator it = Options.begin(); it != Options.end(); ++it ) {
+ if (!QFile::encodeName(*it).isEmpty()) *proc<< QFile::encodeName(*it);
+ }
+ *proc<<"-d"<<QFile::encodeName(srcUrl.path());
+
+ ///////// when process ends, update dialog infos
+
+ connect(proc, SIGNAL(processExited(KProcess *)),this,SLOT(txtdecryptfin(KProcess *)));
+ connect(proc, SIGNAL(receivedStdout(KProcess *, char *, int)),this, SLOT(getOutput(KProcess *, char *, int)));
+ connect(proc, SIGNAL(receivedStderr(KProcess *, char *, int)),this, SLOT(getCmdOutput(KProcess *, char *, int)));
+ proc->start(KProcess::NotifyOnExit,KProcess::All);
+}
+
+
+/////////////////////////////////////////////////////// verify text
+
+
+void KgpgInterface::KgpgVerifyText(QString text)
+{
+
+ QTextCodec *codec =QTextCodec::codecForLocale ();
+ if (!codec->canEncode(text)) text=text.utf8();
+ signmiss=false;
+ signID=QString::null;
+ message=QString::null;
+ KProcIO *verifyproc=new KProcIO(QTextCodec::codecForLocale());
+ *verifyproc<<"gpg"<<"--no-secmem-warning"<<"--status-fd=2"<<"--command-fd=0"<<"--utf8-strings"<<"--verify";
+ connect(verifyproc, SIGNAL(processExited(KProcess *)),this, SLOT(slotverifyresult(KProcess *)));
+ connect(verifyproc, SIGNAL(readReady(KProcIO *)),this, SLOT(slotverifyread(KProcIO *)));
+ verifyproc->start(KProcess::NotifyOnExit,true);
+ verifyproc->writeStdin (text);
+ verifyproc->closeWhenDone();
+}
+
+
+void KgpgInterface::slotverifyresult(KProcess*)
+{
+if (signmiss) emit missingSignature(signID);
+ else {
+ if (signID.isEmpty()) signID=i18n("No signature found.");
+ emit verifyOver(signID,message);
+ }
+//kdDebug(2100) << "GPG VERIFY OVER________"<<endl;
+}
+
+void KgpgInterface::slotverifyread(KProcIO *p)
+{
+QString required;
+ while (p->readln(required,true)!=-1)
+ {
+ message+=required+"\n";
+ required=required.section("]",1,-1).stripWhiteSpace();
+ if (required.startsWith("GOODSIG"))
+ {
+ QString userName=required.section(" ",2,-1).replace(QRegExp("<"),"&lt;");
+ userName=checkForUtf8(userName);
+ signID=i18n("<qt>Good signature from:<br><b>%1</b><br>Key ID: %2</qt>").arg(userName).arg("0x"+required.section(" ",1,1).right(8));
+ }
+ if (required.startsWith("BADSIG"))
+ {
+ signID=i18n("<qt><b>Bad signature</b> from:<br>%1<br>Key ID: %2<br><br><b>Text is corrupted.</b></qt>").arg(required.section(" ",2,-1).replace(QRegExp("<"),"&lt;")).arg("0x"+required.section(" ",1,1).right(8));
+ }
+ if (required.startsWith("NO_PUBKEY"))
+ {
+ signID="0x"+required.section(" ",1,1).right(8);
+ signmiss=true;
+ }
+ if (required.startsWith("UNEXPECTED") || required.startsWith("NODATA"))
+ signID=i18n("No signature found.");
+ if (required.startsWith("TRUST_UNDEFINED"))
+ signID+=i18n("The signature is valid, but the key is untrusted");
+ if (required.startsWith("TRUST_ULTIMATE"))
+ signID+=i18n("The signature is valid, and the key is ultimately trusted");
+ }
+}
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////// MD5
+
+Md5Widget::Md5Widget(QWidget *parent, const char *name,KURL url):KDialogBase( parent, name, true,i18n("MD5 Checksum"),Apply | Close)
+{
+ setButtonApply(i18n("Compare MD5 with Clipboard"));
+ mdSum=QString::null;
+ QFile f(url.path());
+ f.open( IO_ReadOnly);
+ KMD5 checkfile;
+ checkfile.reset();
+ checkfile.update(f);
+ mdSum=checkfile.hexDigest().data();
+ f.close();
+ QWidget *page = new QWidget(this);
+
+ resize( 360, 150 );
+ QGridLayout *MyDialogLayout = new QGridLayout( page, 1, 1, 5, 6, "MyDialogLayout");
+
+ QLabel *TextLabel1 = new QLabel( page, "TextLabel1" );
+ TextLabel1->setText(i18n("MD5 sum for <b>%1</b> is:").arg(url.fileName()));
+ MyDialogLayout->addWidget( TextLabel1, 0, 0 );
+
+ KLineEdit *KRestrictedLine1 = new KLineEdit(mdSum,page);
+ KRestrictedLine1->setReadOnly(true);
+ KRestrictedLine1->setPaletteBackgroundColor(QColor(255,255,255));
+ MyDialogLayout->addWidget( KRestrictedLine1, 1, 0 );
+
+
+ QHBoxLayout *Layout4 = new QHBoxLayout( 0, 0, 6, "Layout4");
+
+ KLed1=new KLed(QColor(80,80,80),KLed::Off,KLed::Sunken,KLed::Circular,page,"KLed1");
+ KLed1->off();
+ KLed1->setSizePolicy( QSizePolicy( (QSizePolicy::SizeType)0, (QSizePolicy::SizeType)0, 0, 0, KLed1->sizePolicy().hasHeightForWidth() ) );
+ Layout4->addWidget( KLed1 );
+
+ TextLabel1_2 = new QLabel( page, "TextLabel1_2" );
+ TextLabel1_2->setText(i18n( "<b>Unknown status</b>" ) );
+ Layout4->addWidget( TextLabel1_2 );
+
+ MyDialogLayout->addLayout( Layout4, 2, 0 );
+ QSpacerItem* spacer = new QSpacerItem( 0, 0, QSizePolicy::Minimum, QSizePolicy::Expanding );
+ MyDialogLayout->addItem( spacer, 3, 0 );
+
+ page->show();
+ page->resize(page->minimumSize());
+ setMainWidget(page);
+
+
+}
+
+Md5Widget::~Md5Widget()
+{}
+
+void Md5Widget::slotApply()
+{
+ QClipboard *cb = QApplication::clipboard();
+ QString text;
+ // Copy text from the clipboard (paste)
+ text = cb->text(QClipboard::Clipboard);
+ if ( !text.isEmpty() ) {
+ text=text.stripWhiteSpace();
+ while (text.find(' ')!=-1)
+ text.remove(text.find(' '),1);
+ if (text==mdSum) {
+ TextLabel1_2->setText(i18n("<b>Correct checksum</b>, file is ok."));
+ KLed1->setColor(QColor(0,255,0));
+ KLed1->on();
+ }//KMessageBox::sorry(0,"OK");
+ else if (text.length()!=mdSum.length())
+ KMessageBox::sorry(0,i18n("Clipboard content is not a MD5 sum."));
+ else {
+ TextLabel1_2->setText(i18n("<b>Wrong checksum, FILE CORRUPTED</b>"));
+ KLed1->setColor(QColor(255,0,0));
+ KLed1->on();
+ }
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////// signatures
+
+
+void KgpgInterface::KgpgSignFile(QString keyID,KURL srcUrl,QStringList Options)
+{
+ ////////////////////////////////////// create a detached signature for a chosen file
+ message=QString::null;
+ step=3;
+ ///////////// create gpg command
+ KProcIO *proc=new KProcIO(QTextCodec::codecForLocale());
+ keyID=keyID.stripWhiteSpace();
+ *proc<<"gpg"<<"--no-tty"<<"--no-secmem-warning"<<"--utf8-strings"<<"--status-fd=2"<<"--command-fd=0"<<"-u"<<keyID.local8Bit();
+ for ( QStringList::Iterator it = Options.begin(); it != Options.end(); ++it )
+ if (!QFile::encodeName(*it).isEmpty()) *proc<< QFile::encodeName(*it);
+
+ *proc<<"--output"<<QFile::encodeName(srcUrl.path()+".sig");
+ *proc<<"--detach-sig"<<QFile::encodeName(srcUrl.path());
+
+ QObject::connect(proc, SIGNAL(processExited(KProcess *)),this,SLOT(signfin(KProcess *)));
+ QObject::connect(proc,SIGNAL(readReady(KProcIO *)),this,SLOT(readsignprocess(KProcIO *)));
+ proc->start(KProcess::NotifyOnExit,true);
+}
+
+
+
+void KgpgInterface::signfin(KProcess *)
+{
+ if (message.find("SIG_CREATED")!=-1)
+ KMessageBox::information(0,i18n("The signature file %1 was successfully created.").arg(file.fileName()));
+ else if (message.find("BAD_PASSPHRASE")!=-1)
+ KMessageBox::sorry(0,i18n("Bad passphrase, signature was not created."));
+ else
+ KMessageBox::sorry(0,message);
+ emit signfinished();
+}
+
+
+void KgpgInterface::readsignprocess(KProcIO *p)
+{
+ QString required;
+ while (p->readln(required,true)!=-1) {
+ if (required.find("USERID_HINT",0,false)!=-1)
+ updateIDs(required);
+
+ if (required.find("GET_")!=-1) {
+ if (required.find("openfile.overwrite.okay")!=-1)
+ p->writeStdin("Yes");
+ else if ((required.find("passphrase.enter")!=-1)) {
+ if (userIDs.isEmpty())
+ userIDs=i18n("[No user id found]");
+ QCString passphrase;
+ QString passdlgmessage;
+ if (step<3)
+ passdlgmessage=i18n("<b>Bad passphrase</b>. you have %1 tries left.<br>").arg(step);
+ passdlgmessage+=i18n("Enter passphrase for <b>%1</b>").arg(userIDs);
+ int code=KPasswordDialog::getPassword(passphrase,passdlgmessage);
+ if (code!=QDialog::Accepted) {
+ p->deleteLater();
+ emit signfinished();
+ return;
+ }
+ p->writeStdin(passphrase,true);
+ userIDs=QString::null;
+ if (step>1) step--;
+ else step=3;
+ } else {
+ p->writeStdin("quit");
+ p->closeWhenDone();
+ }
+ }
+ message+=required+"\n";
+ }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+void KgpgInterface::KgpgVerifyFile(KURL sigUrl,KURL srcUrl)
+{
+ ////////////////////////////////////// verify signature for a chosen file
+ message=QString::null;
+ signID=QString::null;
+ signmiss=false;
+ ///////////// create gpg command
+ KProcIO *proc=new KProcIO(QTextCodec::codecForLocale());
+ file=sigUrl;
+ *proc<<"gpg"<<"--no-tty"<<"--utf8-strings"<<"--no-secmem-warning"<<"--status-fd=2"<<"--verify";
+ if (!srcUrl.isEmpty())
+ *proc<<QFile::encodeName(srcUrl.path());
+ *proc<<QFile::encodeName(sigUrl.path());
+
+ QObject::connect(proc, SIGNAL(processExited(KProcess *)),this,SLOT(verifyfin(KProcess *)));
+ QObject::connect(proc,SIGNAL(readReady(KProcIO *)),this,SLOT(readprocess(KProcIO *)));
+ proc->start(KProcess::NotifyOnExit,true);
+}
+
+
+void KgpgInterface::readprocess(KProcIO *p)
+{
+QString required;
+ while (p->readln(required,true)!=-1)
+ {
+ message+=required+"\n";
+ if (required.find("GET_")!=-1) {
+ p->writeStdin("quit");
+ p->closeWhenDone();
+ }
+ required=required.section("]",1,-1).stripWhiteSpace();
+ if (required.startsWith("UNEXPECTED") || required.startsWith("NODATA"))
+ signID=i18n("No signature found.");
+ if (required.startsWith("GOODSIG"))
+ {
+ signID=i18n("<qt>Good signature from:<br><b>%1</b><br>Key ID: %2</qt>").arg(required.section(" ",2,-1).replace(QRegExp("<"),"&lt;")).arg("0x"+required.section(" ",1,1).right(8));
+ }
+ if (required.startsWith("BADSIG"))
+ {
+ signID=i18n("<qt><b>BAD signature</b> from:<br> %1<br>Key id: %2<br><br>"
+ "<b>The file is corrupted!</b></qt>").arg(required.section(" ",2,-1).replace(QRegExp("<"),"&lt;")).arg("0x"+required.section(" ",1,1).right(8));
+ }
+ if (required.startsWith("NO_PUBKEY"))
+ {
+ signmiss=true;
+ signID="0x"+required.section(" ",1,1).right(8);
+ }
+ if (required.startsWith("TRUST_UNDEFINED"))
+ signID+=i18n("The signature is valid, but the key is untrusted");
+ if (required.startsWith("TRUST_ULTIMATE"))
+ signID+=i18n("The signature is valid, and the key is ultimately trusted");
+ }
+}
+
+
+void KgpgInterface::verifyfin(KProcess *)
+{
+ if (!signmiss) {
+ if (signID.isEmpty()) signID=i18n("No signature found.");
+ (void) new KDetailedInfo(0,"verify_result",signID,message);
+ }
+ else {
+ if (KMessageBox::questionYesNo(0,i18n("<qt><b>Missing signature:</b><br>Key id: %1<br><br>"
+ "Do you want to import this key from a keyserver?</qt>").arg(signID),file.fileName(),QString::null, i18n("Import"), i18n("Do Not Import"))==KMessageBox::Yes)
+ emit verifyquerykey(signID);
+ }
+ emit verifyfinished();
+}
+
+
+
+//////////////////////////////////////////////////////////// sign a key
+
+void KgpgInterface::KgpgSignKey(QString keyID,QString signKeyID,QString signKeyMail,bool local,int checking)
+{
+ signKeyMail.replace(QRegExp("<"),"&lt;");
+ konsChecked=checking;
+ konsLocal=local;
+ konsSignKey=signKeyID;
+ konsKeyID=keyID;
+ errMessage=QString::null;
+ if (checkuid(keyID)>0)
+ {
+ openSignConsole();
+ return;
+ }
+
+ signSuccess=0;
+ step=1;
+ output=QString::null;
+ KProcIO *conprocess=new KProcIO(QTextCodec::codecForLocale());
+ *conprocess<<"gpg"<<"--no-secmem-warning"<<"--no-tty"<<"--utf8-strings"<<"--command-fd=0"<<"--status-fd=2"<<"-u"<<signKeyID;
+ *conprocess<<"--edit-key"<<keyID;
+ if (local) *conprocess<<"lsign";
+ else *conprocess<<"sign";
+ QObject::connect(conprocess,SIGNAL(readReady(KProcIO *)),this,SLOT(sigprocess(KProcIO *)));
+ QObject::connect(conprocess, SIGNAL(processExited(KProcess *)),this, SLOT(signover(KProcess *)));
+ conprocess->start(KProcess::NotifyOnExit,true);
+}
+
+void KgpgInterface::sigprocess(KProcIO *p)
+{
+ QString required=QString::null;
+
+ while (p->readln(required,true)!=-1)
+ {
+
+ output+=required+"\n";
+ if (required.find("USERID_HINT",0,false)!=-1)
+ updateIDs(required);
+
+ if (signSuccess==4) {
+ if (required.find("GET_")!=-1)
+ p->writeStdin("quit");
+ p->closeWhenDone();
+ return;
+ }
+
+ if ((required.find("GOOD_PASSPHRASE")!=-1)) {
+ signSuccess=3;
+ step=2;
+ }
+
+ if (required.find("sign_uid.expire")!=-1) {
+ p->writeStdin("Never");
+ required=QString::null;
+ }
+ if (required.find("sign_uid.class")!=-1) {
+ p->writeStdin(QString::number(konsChecked));
+ required=QString::null;
+ }
+ if (required.find("sign_uid.okay")!=-1) {
+ p->writeStdin("Y");
+ required=QString::null;
+ }
+
+ if (required.find("sign_all.okay")!=-1) {
+ p->writeStdin("Y");
+ required=QString::null;
+ }
+
+ if (required.find("passphrase.enter")!=-1) {
+ QCString signpass;
+ int code=KPasswordDialog::getPassword(signpass,i18n("<qt>%1 Enter passphrase for <b>%2</b>:</qt>")
+ .arg(errMessage).arg(userIDs));
+ if (code!=QDialog::Accepted) {
+ signSuccess=4; ///// aborted by user mode
+ required=QString::null;
+ p->writeStdin("quit");
+ p->closeWhenDone();
+ return;
+ }
+ p->writeStdin(signpass,true);
+ required=QString::null;
+ // step=2;
+ }
+ if ((step==2) && (required.find("keyedit.prompt")!=-1)) {
+ p->writeStdin("save");
+ required=QString::null;
+ }
+ if (required.find("BAD_PASSPHRASE")!=-1) {
+ errMessage=i18n("<b>Bad passphrase</b>. Try again.</br>");
+ required=QString::null;
+ signSuccess=2; ///// bad passphrase
+ }
+ if (required.find("GET_")!=-1) /////// gpg asks for something unusal, turn to konsole mode
+ {
+ if (signSuccess!=2)
+ signSuccess=1; ///// switching to console mode
+ p->writeStdin("quit");
+ p->closeWhenDone();
+
+ }
+ }
+}
+
+
+void KgpgInterface::signover(KProcess *)
+{
+ if (signSuccess>1)
+ emit signatureFinished(signSuccess); //// signature successful or bad passphrase
+ else {
+ KDetailedConsole *q=new KDetailedConsole(0,"sign_error",i18n("<qt>Signing key <b>%1</b> with key <b>%2</b> failed.<br>"
+ "Do you want to try signing the key in console mode?</qt>").arg(konsKeyID).arg(konsSignKey),output);
+ if (q->exec()==QDialog::Accepted)
+ openSignConsole();
+ else
+ emit signatureFinished(0);
+ }
+}
+
+void KgpgInterface::openSignConsole()
+{
+ KProcess conprocess;
+ KConfig *config = KGlobal::config();
+ config->setGroup("General");
+ conprocess<< config->readPathEntry("TerminalApplication","konsole");
+ conprocess<<"-e"<<"gpg";
+ conprocess<<"--no-secmem-warning"<<"--expert"<<"-u"<<konsSignKey;
+ if (!konsLocal)
+ conprocess<<"--sign-key"<<konsKeyID;
+ else
+ conprocess<<"--lsign-key"<<konsKeyID;
+ conprocess.start(KProcess::Block);
+ emit signatureFinished(3);
+
+}
+
+//////////////////////////////////////////////////////////////////////////// delete signature
+
+
+void KgpgInterface::KgpgDelSignature(QString keyID,QString signKeyID)
+{
+ if (checkuid(keyID)>0) {
+ KMessageBox::sorry(0,i18n("This key has more than one user ID.\nEdit the key manually to delete signature."));
+ return;
+ }
+
+ message=signKeyID.remove(0,2);
+ deleteSuccess=false;
+ step=0;
+
+ FILE *fp;
+ QString encResult;
+ char buffer[200];
+ signb=0;
+ sigsearch=0;
+
+ QString gpgcmd="gpg --no-tty --no-secmem-warning --with-colon --list-sigs "+keyID;
+ fp = popen(QFile::encodeName(gpgcmd), "r");
+ while ( fgets( buffer, sizeof(buffer), fp)) {
+ encResult=buffer;
+ if (encResult.startsWith("sig")) {
+ if (encResult.find(message)!=-1)
+ break;
+ signb++;
+ } else if (encResult.startsWith("rev"))
+ signb++;
+ }
+ pclose(fp);
+ KProcIO *conprocess=new KProcIO(QTextCodec::codecForLocale());
+ *conprocess<<"gpg"<<"--no-secmem-warning"<<"--no-tty"<<"--utf8-strings"<<"--command-fd=0"<<"--status-fd=2";
+ *conprocess<<"--edit-key"<<keyID<<"uid 1"<<"delsig";
+ QObject::connect(conprocess,SIGNAL(readReady(KProcIO *)),this,SLOT(delsigprocess(KProcIO *)));
+ QObject::connect(conprocess, SIGNAL(processExited(KProcess *)),this, SLOT(delsignover(KProcess *)));
+ conprocess->start(KProcess::NotifyOnExit,true);
+}
+
+
+void KgpgInterface::delsigprocess(KProcIO *p)
+{
+
+ QString required=QString::null;
+ while (p->readln(required,true)!=-1)
+ {
+ if (required.find("keyedit.delsig")!=-1){
+
+ if ((sigsearch==signb) && (step==0)) {
+ p->writeStdin("Y");
+ step=1;
+ } else
+ p->writeStdin("n");
+ sigsearch++;
+ required=QString::null;
+ }
+ if ((step==1) && (required.find("keyedit.prompt")!=-1)) {
+ p->writeStdin("save");
+ required=QString::null;
+ deleteSuccess=true;
+ }
+ if (required.find("GET_LINE")!=-1) {
+ p->writeStdin("quit");
+ p->closeWhenDone();
+ deleteSuccess=false;
+ }
+ }
+}
+
+void KgpgInterface::delsignover(KProcess *)
+{
+ emit delsigfinished(deleteSuccess);
+}
+
+/////////////////////////////////////////////////// check if a key has more than one id
+
+int KgpgInterface::checkuid(QString KeyID)
+{
+ FILE *fp;
+ QString encResult;
+ char buffer[200];
+ int uidcnt=0;
+
+ QString gpgcmd="gpg --no-tty --no-secmem-warning --with-colon --list-sigs "+KeyID;
+ ////////// encode with untrusted keys or armor if checked by user
+ fp = popen(QFile::encodeName(gpgcmd), "r");
+ while (fgets(buffer, sizeof(buffer), fp)) {
+ encResult=buffer;
+ if (encResult.startsWith("uid"))
+ uidcnt++;
+ }
+ pclose(fp);
+ return uidcnt;
+}
+
+
+/////////////////////////////////////////////////////////////// change key expiration
+
+
+void KgpgInterface::KgpgKeyExpire(QString keyID,QDate date,bool unlimited)
+{
+ expSuccess=0;
+ step=0;
+ if (unlimited)
+ expirationDelay=0;
+ else
+ expirationDelay=QDate::currentDate().daysTo(date);
+ output=QString::null;
+ KProcIO *conprocess=new KProcIO(QTextCodec::codecForLocale());
+ *conprocess<<"gpg"<<"--no-secmem-warning"<<"--no-tty"<<"--command-fd=0"<<"--status-fd=2"<<"--utf8-strings";
+ *conprocess<<"--edit-key"<<keyID<<"expire";
+ QObject::connect(conprocess,SIGNAL(readReady(KProcIO *)),this,SLOT(expprocess(KProcIO *)));
+ QObject::connect(conprocess, SIGNAL(processExited(KProcess *)),this, SLOT(expover(KProcess *)));
+ conprocess->start(KProcess::NotifyOnExit,KProcess::AllOutput);
+
+}
+
+void KgpgInterface::expprocess(KProcIO *p)
+{
+ QString required=QString::null;
+
+ while (p->readln(required,true)!=-1) {
+ output+=required+"\n";
+
+ if (required.find("USERID_HINT",0,false)!=-1)
+ updateIDs(required);
+
+ if ((required.find("GOOD_PASSPHRASE")!=-1)) {
+ expSuccess=3;
+ step=2;
+ }
+
+ if (required.find("keygen.valid")!=-1) {
+ p->writeStdin(QString::number(expirationDelay));
+ required=QString::null;
+ }
+
+ if (required.find("passphrase.enter")!=-1) {
+ QCString signpass;
+ int code=KPasswordDialog::getPassword(signpass,i18n("<qt>Enter passphrase for <b>%1</b>:</qt>").arg(userIDs));
+ if (code!=QDialog::Accepted) {
+ expSuccess=3; ///// aborted by user mode
+ p->writeStdin("quit");
+ p->closeWhenDone();
+ return;
+ }
+ p->writeStdin(signpass,true);
+ required=QString::null;
+ // step=2;
+ }
+ if ((step==2) && (required.find("keyedit.prompt")!=-1)) {
+ p->writeStdin("save");
+ p->closeWhenDone();
+ required=QString::null;
+ }
+ if ((step==2) && (required.find("keyedit.save.okay")!=-1)) {
+ p->writeStdin("YES");
+ p->closeWhenDone();
+ required=QString::null;
+ }
+ if (required.find("BAD_PASSPHRASE")!=-1) {
+ p->writeStdin("quit");
+ p->closeWhenDone();
+ expSuccess=2; ///// bad passphrase
+ }
+ if ((required.find("GET_")!=-1) && (expSuccess!=2)) /////// gpg asks for something unusal, turn to konsole mode
+ {
+ expSuccess=1; ///// switching to console mode
+ p->writeStdin("quit");
+ p->closeWhenDone();
+
+ }
+ }
+}
+
+
+
+void KgpgInterface::expover(KProcess *)
+{
+ if ((expSuccess==3) || (expSuccess==2))
+ emit expirationFinished(expSuccess); //// signature successful or bad passphrase
+ else {
+ KDetailedConsole *q=new KDetailedConsole(0,"sign_error",i18n("<qt><b>Changing expiration failed.</b><br>"
+ "Do you want to try changing the key expiration in console mode?</qt>"),output);
+ if (q->exec()==QDialog::Accepted)
+ KMessageBox::sorry(0,"work in progress...");
+ //openSignConsole();
+ else
+ emit expirationFinished(0);
+ }
+}
+
+
+/////////////////////////////////////////////////////////////// change key trust
+
+
+void KgpgInterface::KgpgTrustExpire(QString keyID,int keyTrust)
+{
+ trustValue=keyTrust+1;
+/* Don't know=1; Do NOT trust=2; Marginally=3; Fully=4; Ultimately=5; */
+
+ output=QString::null;
+ KProcIO *conprocess=new KProcIO(QTextCodec::codecForLocale());
+ *conprocess<<"gpg"<<"--no-secmem-warning"<<"--no-tty"<<"--command-fd=0"<<"--status-fd=2"<<"--utf8-strings";
+ *conprocess<<"--edit-key"<<keyID<<"trust";
+ QObject::connect(conprocess,SIGNAL(readReady(KProcIO *)),this,SLOT(trustprocess(KProcIO *)));
+ QObject::connect(conprocess, SIGNAL(processExited(KProcess *)),this, SLOT(trustover(KProcess *)));
+ conprocess->start(KProcess::NotifyOnExit,true);
+
+}
+
+void KgpgInterface::trustprocess(KProcIO *p)
+{
+ QString required=QString::null;
+ while (p->readln(required,true)!=-1) {
+ output+=required+"\n";
+ if (required.find("edit_ownertrust.set_ultimate.okay")!=-1) {
+ p->writeStdin("YES");
+ required=QString::null;
+ }
+
+ if (required.find("edit_ownertrust.value")!=-1) {
+ p->writeStdin(QString::number(trustValue));
+ required=QString::null;
+ }
+
+ if (required.find("keyedit.prompt")!=-1) {
+ p->writeStdin("save");
+ p->closeWhenDone();
+ required=QString::null;
+ }
+
+ if (required.find("GET_")!=-1) /////// gpg asks for something unusal, turn to konsole mode
+ {
+ expSuccess=1; ///// switching to console mode
+ p->writeStdin("quit");
+ p->closeWhenDone();
+
+ }
+ }
+}
+
+
+
+void KgpgInterface::trustover(KProcess *)
+{
+ emit trustfinished();
+}
+
+
+/////////////////////////////////////////////////////////////// change passphrase
+
+
+void KgpgInterface::KgpgChangePass(QString keyID)
+{
+ step=1;
+ output=QString::null;
+ message=QString::null;
+ KProcIO *conprocess=new KProcIO(QTextCodec::codecForLocale());
+ *conprocess<<"gpg"<<"--no-secmem-warning"<<"--no-tty"<<"--no-use-agent"<<"--command-fd=0"<<"--status-fd=2"<<"--utf8-strings";
+ *conprocess<<"--edit-key"<<keyID<<"passwd";
+ QObject::connect(conprocess,SIGNAL(readReady(KProcIO *)),this,SLOT(passprocess(KProcIO *)));
+ QObject::connect(conprocess, SIGNAL(processExited(KProcess *)),this, SLOT(passover(KProcess *)));
+ conprocess->start(KProcess::NotifyOnExit,KProcess::AllOutput);
+
+}
+
+void KgpgInterface::passprocess(KProcIO *p)
+{
+ QString required=QString::null;
+
+ while (p->readln(required,true)!=-1) {
+ output+=required+"\n";
+
+ if (required.find("USERID_HINT",0,false)!=-1)
+ updateIDs(required);
+
+ if ((step>2) && (required.find("keyedit.prompt")!=-1)) {
+ if (step==3)
+ {
+ emit passwordChanged();
+ p->writeStdin("save");
+ }
+ else p->writeStdin("quit");
+ required=QString::null;
+ }
+
+ if ((required.find("GOOD_PASSPHRASE")!=-1) && (step==2))
+ step=3;
+
+ if ((required.find("BAD_PASSPHRASE")!=-1) && (step==2)) {
+ step=1;
+ message=i18n("<b>Bad passphrase</b>. Try again<br>");
+ }
+
+ if ((required.find("passphrase.enter")!=-1)) {
+ if (userIDs.isEmpty())
+ userIDs=i18n("[No user id found]");
+ userIDs.replace(QRegExp("<"),"&lt;");
+
+ if (step==1) {
+ QCString passphrase;
+ int code=KPasswordDialog::getPassword(passphrase,i18n("<qt>%1 Enter passphrase for <b>%2</b></qt>")
+ .arg(message).arg(userIDs));
+ if (code!=QDialog::Accepted) {
+ p->writeStdin("quit");
+ // p->closeWhenDone();
+ emit processaborted(true);
+ p->deleteLater();
+ return;
+ }
+ p->writeStdin(passphrase,true);
+ step=2;
+ }
+
+ if (step==3) {
+ QCString passphrase;
+ int code=KPasswordDialog::getNewPassword(passphrase,i18n("<qt>Enter new passphrase for <b>%1</b><br>If you forget this passphrase, all your encrypted files and messages will be lost !<br></qt>").arg(userIDs));
+ if (code!=QDialog::Accepted) {
+ step=4;
+ p->writeStdin("quit");
+ p->writeStdin("quit");
+ p->closeWhenDone();
+ emit processaborted(true);
+ return;
+ }
+ p->writeStdin(passphrase,true);
+ userIDs=QString::null;
+ }
+
+ required=QString::null;
+ }
+
+
+ if (required.find("GET_")!=-1) /////// gpg asks for something unusal, turn to konsole mode
+ {
+ p->writeStdin("quit");
+ p->closeWhenDone();
+
+ }
+ }
+}
+
+
+
+void KgpgInterface::passover(KProcess *)
+{
+ //emit trustfinished();
+}
+
+
+
+////////////////////////////////////////////////////////////// key export
+
+QString KgpgInterface::getKey(QStringList IDs, bool attributes)
+{
+ keyString=QString::null;
+ KProcIO *proc=new KProcIO(QTextCodec::codecForLocale());
+ *proc<< "gpg"<<"--no-tty"<<"--no-secmem-warning"<<"--utf8-strings";
+ *proc<<"--export"<<"--armor";
+ if (!attributes)
+ *proc<<"--export-options"<<"no-include-attributes";
+
+ for ( QStringList::Iterator it = IDs.begin(); it != IDs.end(); ++it )
+ *proc << *it;
+ QObject::connect(proc, SIGNAL(readReady(KProcIO *)),this, SLOT(slotReadKey(KProcIO *)));
+ proc->start(KProcess::Block,false);
+ return keyString;
+}
+
+
+void KgpgInterface::slotReadKey(KProcIO *p)
+{
+ QString outp;
+ while (p->readln(outp)!=-1)
+ if (!outp.startsWith("gpg:")) keyString+=outp+"\n";
+}
+
+
+////////////////////////////////////////////////////////////// key import
+
+void KgpgInterface::importKeyURL(KURL url)
+{
+ ///////////// import a key
+
+ if( KIO::NetAccess::download( url, tempKeyFile,0) ) {
+ message=QString::null;
+ KProcIO *conprocess=new KProcIO(QTextCodec::codecForLocale());
+ *conprocess<< "gpg"<<"--no-tty"<<"--no-secmem-warning"<<"--status-fd=2"<<"--utf8-strings"<<"--import";
+ *conprocess<<"--allow-secret-key-import";
+ *conprocess<<tempKeyFile;
+ QObject::connect(conprocess, SIGNAL(processExited(KProcess *)),this, SLOT(importURLover(KProcess *)));
+ QObject::connect(conprocess, SIGNAL(readReady(KProcIO *)),this, SLOT(importprocess(KProcIO *)));
+ conprocess->start(KProcess::NotifyOnExit,true);
+ }
+}
+
+void KgpgInterface::importKey(QString keystr)
+{
+ ///////////// import a key
+ message=QString::null;
+ KProcIO *conprocess=new KProcIO(QTextCodec::codecForLocale());
+ *conprocess<< "gpg"<<"--no-tty"<<"--no-secmem-warning"<<"--status-fd=2"<<"--import";
+ *conprocess<<"--allow-secret-key-import";
+ QObject::connect(conprocess, SIGNAL(processExited(KProcess *)),this, SLOT(importover(KProcess *)));
+ QObject::connect(conprocess, SIGNAL(readReady(KProcIO *)),this, SLOT(importprocess(KProcIO *)));
+ conprocess->start(KProcess::NotifyOnExit,true);
+ conprocess->writeStdin(keystr, true);
+ conprocess->closeWhenDone();
+}
+
+void KgpgInterface::importover(KProcess *)
+{
+QStringList importedKeysIds;
+QStringList messageList;
+QString resultMessage;
+bool secretImport=false;
+kdDebug(2100)<<"Importing is over"<<endl;
+ QString parsedOutput=message;
+ QStringList importedKeys;
+
+ while (parsedOutput.find("IMPORTED")!=-1) {
+ parsedOutput.remove(0,parsedOutput.find("IMPORTED")+8);
+ importedKeys<<parsedOutput.section("\n",0,0).stripWhiteSpace();
+ importedKeysIds<<parsedOutput.stripWhiteSpace().section(' ',0,0);
+ }
+
+
+ if (message.find("IMPORT_RES")!=-1) {
+ parsedOutput=message.section("IMPORT_RES",-1,-1).stripWhiteSpace();
+ messageList=QStringList::split(" ",parsedOutput,true);
+
+ resultMessage=i18n("<qt>%n key processed.<br></qt>","<qt>%n keys processed.<br></qt>",messageList[0].toULong());
+ if (messageList[4]!="0")
+ resultMessage+=i18n("<qt>One key unchanged.<br></qt>","<qt>%n keys unchanged.<br></qt>",messageList[4].toULong());
+ if (messageList[7]!="0")
+ resultMessage+=i18n("<qt>One signature imported.<br></qt>","<qt>%n signatures imported.<br></qt>",messageList[7].toULong());
+ if (messageList[1]!="0")
+ resultMessage+=i18n("<qt>One key without ID.<br></qt>","<qt>%n keys without ID.<br></qt>",messageList[1].toULong());
+ if (messageList[3]!="0")
+ resultMessage+=i18n("<qt>One RSA key imported.<br></qt>","<qt>%n RSA keys imported.<br></qt>",messageList[3].toULong());
+ if (messageList[5]!="0")
+ resultMessage+=i18n("<qt>One user ID imported.<br></qt>","<qt>%n user IDs imported.<br></qt>",messageList[5].toULong());
+ if (messageList[6]!="0")
+ resultMessage+=i18n("<qt>One subkey imported.<br></qt>","<qt>%n subkeys imported.<br></qt>",messageList[6].toULong());
+ if (messageList[8]!="0")
+ resultMessage+=i18n("<qt>One revocation certificate imported.<br></qt>","<qt>%n revocation certificates imported.<br></qt>",messageList[8].toULong());
+ if (messageList[9]!="0")
+ {
+ resultMessage+=i18n("<qt>One secret key processed.<br></qt>","<qt>%n secret keys processed.<br></qt>",messageList[9].toULong());
+ secretImport=true;
+ }
+ if (messageList[10]!="0")
+ resultMessage+=i18n("<qt><b>One secret key imported.</b><br></qt>","<qt><b>%n secret keys imported.</b><br></qt>",messageList[10].toULong());
+ if (messageList[11]!="0")
+ resultMessage+=i18n("<qt>One secret key unchanged.<br></qt>","<qt>%n secret keys unchanged.<br></qt>",messageList[11].toULong());
+ if (messageList[12]!="0")
+ resultMessage+=i18n("<qt>One secret key not imported.<br></qt>","<qt>%n secret keys not imported.<br></qt>",messageList[12].toULong());
+ if (messageList[2]!="0")
+ resultMessage+=i18n("<qt><b>One key imported:</b><br></qt>","<qt><b>%n keys imported:</b><br></qt>",messageList[2].toULong());
+
+ if (secretImport) resultMessage+=i18n("<qt><br><b>You have imported a secret key.</b> <br>"
+ "Please note that imported secret keys are not trusted by default.<br>"
+ "To fully use this secret key for signing and encryption, you must edit the key (double click on it) and set its trust to Full or Ultimate.</qt>");
+ } else
+ resultMessage=i18n("No key imported... \nCheck detailed log for more infos");
+
+ if (messageList[8]!="0") importedKeysIds="ALL";
+ if ((messageList[9]!="0") && (importedKeysIds.isEmpty())) // orphaned secret key imported
+ emit refreshOrphaned();
+ emit importfinished(importedKeysIds);
+
+ (void) new KDetailedInfo(0,"import_result",resultMessage,message,importedKeys);
+}
+
+void KgpgInterface::importURLover(KProcess *p)
+{
+ KIO::NetAccess::removeTempFile(tempKeyFile);
+ importover(p);
+ //KMessageBox::information(0,message);
+ //emit importfinished();
+}
+
+void KgpgInterface::importprocess(KProcIO *p)
+{
+ QString outp;
+ while (p->readln(outp)!=-1) {
+ if (outp.find("http-proxy")==-1)
+ message+=outp+"\n";
+ }
+}
+
+
+/////////////////////////////////////////////////////////////////////////////////////// User ID's
+
+
+void KgpgInterface::KgpgAddUid(QString keyID,QString name,QString email,QString comment)
+{
+uidName=name;
+uidComment=comment;
+uidEmail=email;
+output=QString::null;
+addSuccess=true;
+
+ KProcIO *conprocess=new KProcIO(QTextCodec::codecForLocale());
+ *conprocess<< "gpg"<<"--no-tty"<<"--status-fd=2"<<"--command-fd=0"<<"--utf8-strings";
+ *conprocess<<"--edit-key"<<keyID<<"adduid";
+ QObject::connect(conprocess, SIGNAL(processExited(KProcess *)),this, SLOT(adduidover(KProcess *)));
+ QObject::connect(conprocess, SIGNAL(readReady(KProcIO *)),this, SLOT(adduidprocess(KProcIO *)));
+ conprocess->start(KProcess::NotifyOnExit,true);
+}
+
+void KgpgInterface::adduidover(KProcess *)
+{
+if (addSuccess) emit addUidFinished();
+else emit addUidError(output);
+}
+
+void KgpgInterface::adduidprocess(KProcIO *p)
+{
+ QString required=QString::null;
+ while (p->readln(required,true)!=-1) {
+ output+=required+"\n";
+ if (required.find("USERID_HINT",0,false)!=-1)
+ updateIDs(required);
+
+ if (required.find("keygen.name")!=-1) {
+ p->writeStdin(uidName);
+ required=QString::null;
+ }
+
+ if (required.find("keygen.email")!=-1) {
+ p->writeStdin(uidEmail);
+ required=QString::null;
+ }
+
+ if (required.find("keygen.comment")!=-1) {
+ p->writeStdin(uidComment);
+ required=QString::null;
+ }
+
+ if (required.find("passphrase.enter")!=-1) {
+ QCString delpass;
+ int code=KPasswordDialog::getPassword(delpass,i18n("<qt>Enter passphrase for <b>%1</b>:</qt>")
+ .arg(userIDs));
+ if (code!=QDialog::Accepted) {
+ //addSuccess=false;
+ p->writeStdin("quit");
+ p->closeWhenDone();
+ return;
+ }
+ p->writeStdin(delpass,true);
+ required=QString::null;
+
+ }
+
+ if (required.find("keyedit.prompt")!=-1) {
+ p->writeStdin("save");
+ required=QString::null;
+ }
+
+ if ((required.find("GET_")!=-1)) /////// gpg asks for something unusal, turn to konsole mode
+ {
+ kdDebug(2100)<<"unknown request"<<endl;
+ addSuccess=false; ///// switching to console mode
+ p->writeStdin("quit");
+ p->closeWhenDone();
+ }
+ }
+}
+
+
+
+
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// photo id's
+
+void KgpgInterface::KgpgGetPhotoList(QString keyID)
+{
+photoList.clear();
+output=QString::null;
+photoCount=1;
+userIDs=keyID;
+
+ KProcIO *conprocess=new KProcIO(QTextCodec::codecForLocale());
+ *conprocess<< "gpg"<<"--no-tty"<<"--status-fd=2"<<"--command-fd=0";
+ *conprocess<<"--with-colon"<<"--list-keys"<<keyID;
+ QObject::connect(conprocess, SIGNAL(processExited(KProcess *)),this, SLOT(photoreadover(KProcess *)));
+ QObject::connect(conprocess, SIGNAL(readReady(KProcIO *)),this, SLOT(photoreadprocess(KProcIO *)));
+ conprocess->start(KProcess::NotifyOnExit,true);
+}
+
+void KgpgInterface::photoreadprocess(KProcIO *p)
+{
+ QString required=QString::null;
+ while (p->readln(required,true)!=-1) {
+ output+=required+"\n";
+ if (required.startsWith("uat") || required.startsWith("uid")) photoCount++;
+}
+}
+
+
+void KgpgInterface::photoreadover(KProcess *)
+{
+for (int i=1;i<photoCount+1;i++)
+if (isPhotoId(i)) photoList+=QString::number(i);
+
+emit signalPhotoList(photoList);
+}
+
+bool KgpgInterface::isPhotoId(int uid)
+{
+KTempFile *kgpginfotmp=new KTempFile();
+ kgpginfotmp->setAutoDelete(true);
+ QString pgpgOutput="cp %i "+kgpginfotmp->name();
+
+KProcIO *conprocess=new KProcIO(QTextCodec::codecForLocale());
+ *conprocess<< "gpg"<<"--no-tty"<<"--status-fd=2"<<"--command-fd=0"<<"--utf8-strings";
+ *conprocess<<"--photo-viewer"<<QFile::encodeName(pgpgOutput)<<"--edit-key"<<userIDs<<"uid"<<QString::number(uid)<<"showphoto";
+ conprocess->start(KProcess::Block);
+ if (kgpginfotmp->file()->size()>0)
+ {
+ kgpginfotmp->unlink();
+ return true;
+ }
+ kgpginfotmp->unlink();
+ return false;
+}
+
+void KgpgInterface::KgpgDeletePhoto(QString keyID,QString uid)
+{
+ delSuccess=true;
+ output=QString::null;
+ KProcIO *conprocess=new KProcIO(QTextCodec::codecForLocale());
+ *conprocess<< "gpg"<<"--no-tty"<<"--status-fd=2"<<"--command-fd=0"<<"--utf8-strings";
+ *conprocess<<"--edit-key"<<keyID<<"uid"<<uid<<"deluid";
+ QObject::connect(conprocess, SIGNAL(processExited(KProcess *)),this, SLOT(delphotoover(KProcess *)));
+ QObject::connect(conprocess, SIGNAL(readReady(KProcIO *)),this, SLOT(delphotoprocess(KProcIO *)));
+ conprocess->start(KProcess::NotifyOnExit,true);
+}
+
+void KgpgInterface::delphotoover(KProcess *)
+{
+if (delSuccess) emit delPhotoFinished();
+else emit delPhotoError(output);
+}
+
+void KgpgInterface::delphotoprocess(KProcIO *p)
+{
+ QString required=QString::null;
+ while (p->readln(required,true)!=-1) {
+ output+=required+"\n";
+ if (required.find("USERID_HINT",0,false)!=-1)
+ updateIDs(required);
+
+ if (required.find("keyedit.remove.uid.okay")!=-1) {
+ p->writeStdin("YES");
+ required=QString::null;
+ }
+
+ if (required.find("passphrase.enter")!=-1) {
+ QCString delpass;
+ int code=KPasswordDialog::getPassword(delpass,i18n("<qt>Enter passphrase for <b>%1</b>:</qt>").arg(userIDs));
+ if (code!=QDialog::Accepted) {
+ //deleteSuccess=false;
+ p->writeStdin("quit");
+ p->closeWhenDone();
+ return;
+ }
+ p->writeStdin(delpass,true);
+ required=QString::null;
+
+ }
+
+ if (required.find("keyedit.prompt")!=-1) {
+ p->writeStdin("save");
+ required=QString::null;
+ }
+
+ if ((required.find("GET_")!=-1)) /////// gpg asks for something unusal, turn to konsole mode
+ {
+ kdDebug(2100)<<"unknown request"<<endl;
+ delSuccess=false;
+ p->writeStdin("quit");
+ p->closeWhenDone();
+
+ }
+ }
+}
+
+
+void KgpgInterface::KgpgAddPhoto(QString keyID,QString imagePath)
+{
+photoUrl=imagePath;
+output=QString::null;
+addSuccess=true;
+ KProcIO *conprocess=new KProcIO(QTextCodec::codecForLocale());
+ *conprocess<< "gpg"<<"--no-tty"<<"--status-fd=2"<<"--command-fd=0"<<"--utf8-strings";
+ *conprocess<<"--edit-key"<<keyID<<"addphoto";
+ QObject::connect(conprocess, SIGNAL(processExited(KProcess *)),this, SLOT(addphotoover(KProcess *)));
+ QObject::connect(conprocess, SIGNAL(readReady(KProcIO *)),this, SLOT(addphotoprocess(KProcIO *)));
+ conprocess->start(KProcess::NotifyOnExit,true);
+}
+
+void KgpgInterface::addphotoover(KProcess *)
+{
+if (addSuccess) emit addPhotoFinished();
+else emit addPhotoError(output);
+}
+
+void KgpgInterface::addphotoprocess(KProcIO *p)
+{
+ QString required=QString::null;
+ while (p->readln(required,true)!=-1) {
+ output+=required+"\n";
+ if (required.find("USERID_HINT",0,false)!=-1)
+ updateIDs(required);
+
+ if (required.find("photoid.jpeg.add")!=-1) {
+ p->writeStdin(photoUrl);
+ required=QString::null;
+ }
+
+ if (required.find("photoid.jpeg.size")!=-1) {
+ if (KMessageBox::questionYesNo(0,i18n("This image is very large. Use it anyway?"), QString::null, i18n("Use Anyway"), i18n("Do Not Use"))==KMessageBox::Yes)
+ p->writeStdin("Yes");
+ else
+ {
+ p->writeStdin("No");
+ p->writeStdin("");
+ p->writeStdin("quit");
+ }
+ required=QString::null;
+ }
+
+ if (required.find("passphrase.enter")!=-1) {
+ QCString delpass;
+ int code=KPasswordDialog::getPassword(delpass,i18n("<qt>Enter passphrase for <b>%1</b>:</qt>").arg(userIDs));
+ if (code!=QDialog::Accepted) {
+ //deleteSuccess=false;
+ p->writeStdin("quit");
+ p->closeWhenDone();
+ return;
+ }
+ p->writeStdin(delpass,true);
+ required=QString::null;
+
+ }
+
+ if (required.find("keyedit.prompt")!=-1) {
+ p->writeStdin("save");
+ required=QString::null;
+ }
+
+ if ((required.find("GET_")!=-1)) /////// gpg asks for something unusal, turn to konsole mode
+ {
+ kdDebug(2100)<<"unknown request"<<endl;
+ p->writeStdin("quit");
+ addSuccess=false;
+ p->closeWhenDone();
+
+ }
+ }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// key revocation
+
+void KgpgInterface::KgpgRevokeKey(QString keyID,QString revokeUrl,int reason,QString description)
+{
+ revokeReason=reason;
+ revokeSuccess=false;
+ revokeDescription=description;
+ certificateUrl=revokeUrl;
+ output=QString::null;
+ KProcIO *conprocess=new KProcIO(QTextCodec::codecForLocale());
+ *conprocess<< "gpg"<<"--no-tty"<<"--status-fd=2"<<"--logger-fd=2"<<"--command-fd=0"<<"--utf8-strings";
+ if (!revokeUrl.isEmpty())
+ *conprocess<<"-o"<<revokeUrl;
+ *conprocess<<"--gen-revoke"<<keyID;
+ QObject::connect(conprocess, SIGNAL(processExited(KProcess *)),this, SLOT(revokeover(KProcess *)));
+ QObject::connect(conprocess, SIGNAL(readReady(KProcIO *)),this, SLOT(revokeprocess(KProcIO *)));
+ conprocess->start(KProcess::NotifyOnExit,true);
+}
+
+void KgpgInterface::revokeover(KProcess *)
+{
+ if (!revokeSuccess)
+ KMessageBox::detailedSorry(0,i18n("Creation of the revocation certificate failed..."),output);
+ else {
+ output=output.section("-----BEGIN",1);
+ output.prepend("-----BEGIN");
+ output=output.section("BLOCK-----",0);
+ emit revokecertificate(output);
+ if (!certificateUrl.isEmpty())
+ emit revokeurl(certificateUrl);
+ }
+}
+
+void KgpgInterface::revokeprocess(KProcIO *p)
+{
+ QString required=QString::null;
+ while (p->readln(required,true)!=-1) {
+ output+=required+"\n";
+
+ if (required.find("USERID_HINT",0,false)!=-1)
+ updateIDs(required);
+
+ if ((required.find("GOOD_PASSPHRASE")!=-1))
+ revokeSuccess=true;
+
+ if ((required.find("gen_revoke.okay")!=-1) || (required.find("ask_revocation_reason.okay")!=-1) || (required.find("openfile.overwrite.okay")!=-1)) {
+ p->writeStdin("YES");
+ required=QString::null;
+ }
+
+ if (required.find("ask_revocation_reason.code")!=-1) {
+ p->writeStdin(QString::number(revokeReason));
+ required=QString::null;
+ }
+
+ if (required.find("passphrase.enter")!=-1) {
+ QCString signpass;
+ int code=KPasswordDialog::getPassword(signpass,i18n("<qt>Enter passphrase for <b>%1</b>:</qt>").arg(userIDs));
+ if (code!=QDialog::Accepted) {
+ expSuccess=3; ///// aborted by user mode
+ p->writeStdin("quit");
+ p->closeWhenDone();
+ return;
+ }
+ p->writeStdin(signpass,true);
+ required=QString::null;
+
+ }
+ if (required.find("ask_revocation_reason.text")!=-1) {
+ // kdDebug(2100)<<"description"<<endl;
+ p->writeStdin(revokeDescription);
+ revokeDescription=QString::null;
+ required=QString::null;
+ }
+ if ((required.find("GET_")!=-1)) /////// gpg asks for something unusal, turn to konsole mode
+ {
+ kdDebug(2100)<<"unknown request"<<endl;
+ expSuccess=1; ///// switching to console mode
+ p->writeStdin("quit");
+ p->closeWhenDone();
+
+ }
+ }
+}
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// parsing of ./gnupg/options file
+
+QString KgpgInterface::getGpgSetting(QString name,QString configFile)
+{
+ name=name.stripWhiteSpace()+" ";
+ QFile qfile(QFile::encodeName(configFile));
+ if (qfile.open(IO_ReadOnly) && (qfile.exists())) {
+ QString result;
+ QTextStream t( &qfile );
+ result=t.readLine();
+ while (result!=NULL) {
+ if (result.stripWhiteSpace().startsWith(name)) {
+ result=result.stripWhiteSpace();
+ result.remove(0,name.length());
+ result=result.stripWhiteSpace();
+ return result.section(" ",0,0);
+ }
+ result=t.readLine();
+ }
+ qfile.close();
+ }
+ return QString::null;
+}
+
+QString KgpgInterface::getGpgMultiSetting(QString name,QString configFile)
+{
+// get GnuPG setting for item that can have multiple entries (eg. encrypt-to)
+
+QString parsedResult=QString::null;
+
+ name=name.stripWhiteSpace()+" ";
+ QFile qfile(QFile::encodeName(configFile));
+ if (qfile.open(IO_ReadOnly) && (qfile.exists())) {
+ QString result;
+ QTextStream t( &qfile );
+ result=t.readLine();
+ while (result!=NULL) {
+ if (result.stripWhiteSpace().startsWith(name)) {
+ result=result.stripWhiteSpace();
+ result.remove(0,name.length());
+ if (parsedResult!=QString::null)
+ parsedResult+=" "+result.stripWhiteSpace();
+ else
+ parsedResult+=result.stripWhiteSpace();
+ //return result.section(" ",0,0);
+ }
+ result=t.readLine();
+ }
+ qfile.close();
+ }
+ return parsedResult;
+}
+
+void KgpgInterface::delGpgGroup(QString name, QString configFile)
+{
+ QString textToWrite;
+ QFile qfile(QFile::encodeName(configFile));
+ if (qfile.open(IO_ReadOnly) && (qfile.exists())) {
+ QString result;
+ QTextStream t( &qfile );
+ result=t.readLine();
+ while (result!=NULL) {
+ if (result.stripWhiteSpace().startsWith("group ")) {
+ QString result2=result.stripWhiteSpace();
+ result2.remove(0,6);
+ result2=result2.stripWhiteSpace();
+ if (result2.startsWith(name) && (result2.remove(0,name.length()).stripWhiteSpace().startsWith("=")))
+ result=QString::null;
+ }
+ if (result!=QString::null) textToWrite+=result+"\n";
+ result=t.readLine();
+ }
+ qfile.close();
+ if (qfile.open(IO_WriteOnly)) {
+ QTextStream t( &qfile);
+ t << textToWrite;
+ qfile.close();
+ }
+ }
+}
+
+void KgpgInterface::setGpgGroupSetting(QString name,QStringList values, QString configFile)
+{
+ QString textToWrite;
+ bool found=false;
+ QFile qfile(QFile::encodeName(configFile));
+ kdDebug(2100)<<"Changing group: "<<name<<endl;
+ if (qfile.open(IO_ReadOnly) && (qfile.exists())) {
+ QString result;
+ QTextStream t( &qfile );
+ result=t.readLine();
+ while (result!=NULL) {
+ if (result.stripWhiteSpace().startsWith("group ")) {
+ QString result2=result.stripWhiteSpace();
+ result2.remove(0,6);
+ result2=result2.stripWhiteSpace();
+ if (result2.startsWith(name) && (result2.remove(0,name.length()).stripWhiteSpace().startsWith("="))) {
+// kdDebug(2100)<<"Found group: "<<name<<endl;
+ //kdDebug(2100)<<"New values: "<<values<<endl;
+ result=QString("group %1=%2").arg(name).arg(values.join(" "));
+ found=true;
+ }
+ }
+ textToWrite+=result+"\n";
+ result=t.readLine();
+ }
+ qfile.close();
+ if (!found)
+ textToWrite+="\n"+QString("group %1=%2").arg(name).arg(values.join(" "));
+
+ if (qfile.open(IO_WriteOnly)) {
+ QTextStream t( &qfile);
+ t << textToWrite;
+ qfile.close();
+ }
+ }
+}
+
+
+
+QStringList KgpgInterface::getGpgGroupSetting(QString name,QString configFile)
+{
+
+ QFile qfile(QFile::encodeName(configFile));
+ if (qfile.open(IO_ReadOnly) && (qfile.exists())) {
+ QString result;
+ QTextStream t( &qfile );
+ result=t.readLine();
+ while (result!=NULL) {
+ result=result.stripWhiteSpace();
+ if (result.startsWith("group ")) {
+ kdDebug(2100)<<"Found 1 group"<<endl;
+ result.remove(0,6);
+ if (result.stripWhiteSpace().startsWith(name)) {
+ kdDebug(2100)<<"Found group: "<<name<<endl;
+ result=result.section('=',1);
+ result=result.section('#',0,0);
+ return QStringList::split (" ",result);
+ }
+ }
+ result=t.readLine();
+ }
+ qfile.close();
+ }
+ return QString::null;
+}
+
+QStringList KgpgInterface::getGpgGroupNames(QString configFile)
+{
+ QStringList groups;
+ QFile qfile(QFile::encodeName(configFile));
+ if (qfile.open(IO_ReadOnly) && (qfile.exists())) {
+ QString result;
+ QTextStream t( &qfile );
+ result=t.readLine();
+ while (result!=NULL) {
+ result=result.stripWhiteSpace();
+ if (result.startsWith("group ")) {
+ result.remove(0,6);
+ groups<<result.section("=",0,0).stripWhiteSpace();
+ }
+ result=t.readLine();
+ }
+ qfile.close();
+ }
+ return groups;
+}
+
+
+bool KgpgInterface::getGpgBoolSetting(QString name,QString configFile)
+{
+ name=name;
+ QFile qfile(QFile::encodeName(configFile));
+ if (qfile.open(IO_ReadOnly) && (qfile.exists())) {
+ QString result;
+ QTextStream t( &qfile );
+ result=t.readLine();
+ while (result!=NULL) {
+ if (result.stripWhiteSpace().startsWith(name)) {
+ return true;
+ }
+ result=t.readLine();
+ }
+ qfile.close();
+ }
+ return false;
+}
+
+void KgpgInterface::setGpgSetting(QString name,QString value,QString url)
+{
+ name=name+" ";
+ QString textToWrite;
+ bool found=false;
+ QFile qfile(QFile::encodeName(url));
+
+ if (qfile.open(IO_ReadOnly) && (qfile.exists())) {
+ QString result;
+ QTextStream t( &qfile );
+ result=t.readLine();
+ while (result!=NULL) {
+ if (result.stripWhiteSpace().startsWith(name)) {
+ if (!value.isEmpty())
+ result=name+" "+value;
+ else
+ result=QString::null;
+ found=true;
+ }
+ if (result!=QString::null) textToWrite+=result+"\n";
+ result=t.readLine();
+ }
+ qfile.close();
+ if ((!found) && (!value.isEmpty()))
+ textToWrite+="\n"+name+" "+value;
+
+ if (qfile.open(IO_WriteOnly)) {
+ QTextStream t( &qfile);
+ t << textToWrite;
+ qfile.close();
+ }
+ }
+}
+
+
+void KgpgInterface::setGpgMultiSetting(QString name,QStringList values,QString url)
+{
+ name=name+" ";
+ QString textToWrite;
+ bool found=false;
+ QFile qfile(QFile::encodeName(url));
+
+ if (qfile.open(IO_ReadOnly) && (qfile.exists())) {
+ QString result;
+ QTextStream t( &qfile );
+ result=t.readLine();
+ while (result!=NULL) {
+ if (!result.stripWhiteSpace().startsWith(name))
+ textToWrite+=result+"\n";
+ result=t.readLine();
+ }
+ qfile.close();
+
+ while (!values.isEmpty())
+ {
+ textToWrite+="\n"+name+" "+values.first();
+ values.pop_front();
+ }
+
+ if (qfile.open(IO_WriteOnly)) {
+ QTextStream t( &qfile);
+ t << textToWrite;
+ qfile.close();
+ }
+ }
+}
+
+void KgpgInterface::setGpgBoolSetting(QString name,bool enable,QString url)
+{
+ QString textToWrite;
+ bool found=false;
+ QFile qfile(QFile::encodeName(url));
+
+ if (qfile.open(IO_ReadOnly) && (qfile.exists())) {
+ QString result;
+ QTextStream t( &qfile );
+ result=t.readLine();
+ while (result!=NULL) {
+ if (result.stripWhiteSpace().startsWith(name)) {
+ if (enable)
+ result=name;
+ else
+ result=QString::null;
+ found=true;
+ }
+ if (result!=QString::null) textToWrite+=result+"\n";
+ result=t.readLine();
+ }
+ qfile.close();
+ if ((!found) && (enable))
+ textToWrite+=name;
+
+ if (qfile.open(IO_WriteOnly)) {
+ QTextStream t( &qfile);
+ t << textToWrite;
+ qfile.close();
+ }
+ }
+}
+
+QString KgpgInterface::checkForUtf8bis(QString txt)
+{
+ if (strchr (txt.ascii(), 0xc3) || (txt.find("\\x")!=-1))
+ txt=checkForUtf8(txt);
+ else {
+ txt=checkForUtf8(txt);
+ txt=QString::fromUtf8(txt.ascii());
+ }
+ return txt;
+}
+
+
+QString KgpgInterface::checkForUtf8(QString txt)
+{
+ // code borrowed from gpa
+ const char *s;
+
+ /* Make sure the encoding is UTF-8.
+ * Test structure suggested by Werner Koch */
+ if (txt.isEmpty())
+ return QString::null;
+
+ for (s = txt.ascii(); *s && !(*s & 0x80); s++)
+ ;
+ if (*s && !strchr (txt.ascii(), 0xc3) && (txt.find("\\x")==-1))
+ return txt;
+
+ /* The string is not in UTF-8 */
+ //if (strchr (txt.ascii(), 0xc3)) return (txt+" +++");
+ if (txt.find("\\x")==-1)
+ return QString::fromUtf8(txt.ascii());
+ // if (!strchr (txt.ascii(), 0xc3) || (txt.find("\\x")!=-1)) {
+ for ( int idx = 0 ; (idx = txt.find( "\\x", idx )) >= 0 ; ++idx ) {
+ char str[2] = "x";
+ str[0] = (char) QString( txt.mid( idx + 2, 2 ) ).toShort( 0, 16 );
+ txt.replace( idx, 4, str );
+ }
+ if (!strchr (txt.ascii(), 0xc3))
+ return QString::fromUtf8(txt.ascii());
+ else
+ return QString::fromUtf8(QString::fromUtf8(txt.ascii()).ascii()); // perform Utf8 twice, or some keys display badly
+
+ return txt;
+}
+
+
+#include "kgpginterface.moc"