apps/konqueror/settings/kio/kmanualproxydlg.cpp

   1 /*
   2    kmanualproxydlg.cpp - Proxy configuration dialog
   3
   4    Copyright (C) 2001-2004 Dawit Alemayehu <adawit@kde.org>
   5
   6    This library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU General Public
   8    License (GPL) version 2 as published by the Free Software
   9    Foundation.
  10
  11    This library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Library General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this library; see the file COPYING.LIB.  If not, write to
  18    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19    Boston, MA 02110-1301, USA.
  20 */
  21
  22 // Own
  23 #include "kmanualproxydlg.h"
  24
  25 // Qt
  26 #include <QtGui/QCheckBox>
  27 #include <QtGui/QLabel>
  28 #include <QtGui/QLayout>
  29 #include <QtGui/QPushButton>
  30 #include <QtGui/QSpinBox>
  31
  32 // KDE
  33 #include <kdebug.h>
  34 #include <kiconloader.h>
  35 #include <kicontheme.h>
  36 #include <kinputdialog.h>
  37 #include <kio/ioslave_defaults.h>
  38 #include <klineedit.h>
  39 #include <klistwidget.h>
  40 #include <klocale.h>
  41 #include <kmessagebox.h>
  42 #include <knuminput.h>
  43 #include <kurifilter.h>
  44
  45
  46
  47 KManualProxyDlg::KManualProxyDlg( QWidget* parent, const char* name )
  48                 :KProxyDialogBase( parent, name, true,
  49                                    i18n("Manual Proxy Configuration") )
  50 {
  51     mDlg = new ManualProxyDlgUI (this);
  52     setMainWidget(mDlg);
  53     mDlg->pbCopyDown->setIcon( KIcon("go-down") );
  54     QSizePolicy sizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed );
  55     sizePolicy.setHeightForWidth( mDlg->pbCopyDown->sizePolicy().hasHeightForWidth() );
  56     mDlg->pbCopyDown->setSizePolicy( sizePolicy );
  57
  58     init();
  59 }
  60
  61 void KManualProxyDlg::init()
  62 {
  63     mDlg->sbHttp->setRange( 0, MAX_PORT_VALUE );
  64     mDlg->sbHttps->setRange( 0, MAX_PORT_VALUE );
  65     mDlg->sbFtp->setRange( 0, MAX_PORT_VALUE );
  66
  67     connect( mDlg->pbNew, SIGNAL( clicked() ), SLOT( newPressed() ) );
  68     connect( mDlg->pbChange, SIGNAL( clicked() ), SLOT( changePressed() ) );
  69     connect( mDlg->pbDelete, SIGNAL( clicked() ), SLOT( deletePressed() ) );
  70     connect( mDlg->pbDeleteAll, SIGNAL( clicked() ), SLOT( deleteAllPressed() ) );
  71
  72     connect( mDlg->lbExceptions, SIGNAL(itemSelectionChanged()), SLOT(updateButtons()) );
  73     connect( mDlg->lbExceptions, SIGNAL(itemDoubleClicked (QListWidgetItem *)), SLOT(changePressed()));
  74
  75     connect( mDlg->cbSameProxy, SIGNAL( toggled(bool) ), SLOT( sameProxy(bool) ) );
  76     connect( mDlg->pbCopyDown, SIGNAL( clicked() ), SLOT( copyDown() ) );
  77
  78     connect( mDlg->leHttp, SIGNAL(textChanged(const QString&)), SLOT(textChanged(const QString&)) );
  79     connect( mDlg->sbHttp, SIGNAL(valueChanged(int)), SLOT(valueChanged (int)) );
  80
  81     connect( this, SIGNAL(okClicked()), this, SLOT(slotOk()));
  82 }
  83
  84 void KManualProxyDlg::setProxyData( const KProxyData &data )
  85 {
  86     KUrl url;
  87
  88     // Set the HTTP proxy...
  89     if (!isValidURL(data.proxyList["http"], &url))
  90         mDlg->sbHttp->setValue( DEFAULT_PROXY_PORT );
  91     else
  92     {
  93         int port = url.port();
  94         if ( port <= 0 )
  95             port = DEFAULT_PROXY_PORT;
  96
  97         url.setPort( -1 );
  98         mDlg->leHttp->setText( url.url() );
  99         mDlg->sbHttp->setValue( port );
 100     }
 101
 102     bool useSameProxy = (!mDlg->leHttp->text().isEmpty () &&
 103                          data.proxyList["http"] == data.proxyList["https"] &&
 104                          data.proxyList["http"] == data.proxyList["ftp"]);
 105
 106     mDlg->cbSameProxy->setChecked ( useSameProxy );
 107
 108     if ( useSameProxy )
 109     {
 110       mDlg->leHttps->setText ( mDlg->leHttp->text() );
 111       mDlg->leFtp->setText ( mDlg->leHttp->text() );
 112       mDlg->sbHttps->setValue( mDlg->sbHttp->value() );
 113       mDlg->sbFtp->setValue( mDlg->sbHttp->value() );
 114
 115       sameProxy ( true );
 116     }
 117     else
 118     {
 119       // Set the HTTPS proxy...
 120       if( !isValidURL( data.proxyList["https"], &url ) )
 121           mDlg->sbHttps->setValue( DEFAULT_PROXY_PORT );
 122       else
 123       {
 124           int port = url.port();
 125           if ( port <= 0 )
 126               port = DEFAULT_PROXY_PORT;
 127
 128           url.setPort( -1 );
 129           mDlg->leHttps->setText( url.url() );
 130           mDlg->sbHttps->setValue( port );
 131       }
 132
 133       // Set the FTP proxy...
 134       if( !isValidURL( data.proxyList["ftp"], &url ) )
 135           mDlg->sbFtp->setValue( DEFAULT_PROXY_PORT );
 136       else
 137       {
 138           int port = url.port();
 139           if ( port <= 0 )
 140               port = DEFAULT_PROXY_PORT;
 141
 142           url.setPort( -1 );
 143           mDlg->leFtp->setText( url.url() );
 144           mDlg->sbFtp->setValue( port );
 145       }
 146     }
 147
 148     QStringList::ConstIterator it = data.noProxyFor.begin();
 149     for( ; it != data.noProxyFor.end(); ++it )
 150     {
 151       // "no_proxy" is a keyword used by the environment variable
 152       // based configuration. We ignore it here as it is not applicable...
 153       if ((*it).toLower() != "no_proxy" && !(*it).isEmpty())
 154       {
 155         // Validate the NOPROXYFOR entries and use only hostnames if the entry is
 156         // a valid or legitimate URL. NOTE: needed to catch manual manipulation
 157         // of the proxy config files...
 158         if( isValidURL( *it ) || ((*it).length() >= 3 && (*it).startsWith('.')) )
 159           mDlg->lbExceptions->addItem( *it );
 160       }
 161     }
 162
 163     mDlg->cbReverseProxy->setChecked( data.useReverseProxy );
 164 }
 165
 166 const KProxyData KManualProxyDlg::data() const
 167 {
 168     KProxyData data;
 169
 170     if (!m_bHasValidData)
 171       return data;
 172
 173     data.proxyList["http"] = urlFromInput( mDlg->leHttp, mDlg->sbHttp );
 174
 175     if ( mDlg->cbSameProxy->isChecked () )
 176     {
 177         data.proxyList["https"] = data.proxyList["http"];
 178         data.proxyList["ftp"] = data.proxyList["http"];
 179     }
 180     else
 181     {
 182         data.proxyList["https"] = urlFromInput( mDlg->leHttps, mDlg->sbHttps );
 183         data.proxyList["ftp"] = urlFromInput( mDlg->leFtp, mDlg->sbFtp );
 184     }
 185
 186     if ( mDlg->lbExceptions->count() )
 187     {
 188         for ( int rowIndex = 0 ; rowIndex < mDlg->lbExceptions->count() ; rowIndex++ ) {
 189             data.noProxyFor << mDlg->lbExceptions->item(rowIndex)->text();
 190         }
 191     }
 192
 193     data.type = KProtocolManager::ManualProxy;
 194     data.useReverseProxy = mDlg->cbReverseProxy->isChecked();
 195
 196     return data;
 197 }
 198
 199 void KManualProxyDlg::sameProxy( bool enable )
 200 {
 201     mDlg->leHttps->setEnabled (!enable );
 202     mDlg->leFtp->setEnabled (!enable );
 203     mDlg->sbHttps->setEnabled (!enable );
 204     mDlg->sbFtp->setEnabled (!enable );
 205     mDlg->pbCopyDown->setEnabled( !enable );
 206
 207     if (enable)
 208     {
 209       mOldFtpText = mDlg->leFtp->text();
 210       mOldHttpsText = mDlg->leHttps->text();
 211
 212       mOldFtpPort = mDlg->sbFtp->value();
 213       mOldHttpsPort = mDlg->sbHttps->value();
 214
 215       int port = mDlg->sbHttp->value();
 216       QString text = mDlg->leHttp->text();
 217
 218       mDlg->leFtp->setText (text);
 219       mDlg->leHttps->setText (text);
 220
 221       mDlg->sbFtp->setValue (port);
 222       mDlg->sbHttps->setValue (port);
 223
 224       if (mDlg->lbHttps->font().bold())
 225         setHighLight( mDlg->lbHttps, false );
 226
 227       if (mDlg->lbFtp->font().bold())
 228         setHighLight( mDlg->lbFtp, false );
 229     }
 230     else
 231     {
 232       mDlg->leFtp->setText (mOldFtpText);
 233       mDlg->leHttps->setText (mOldHttpsText);
 234
 235       mDlg->sbFtp->setValue (mOldFtpPort);
 236       mDlg->sbHttps->setValue (mOldHttpsPort);
 237     }
 238 }
 239
 240 bool KManualProxyDlg::validate()
 241 {
 242     KUrl filteredURL;
 243     unsigned short count = 0;
 244
 245     if ( isValidURL( mDlg->leHttp->text(), &filteredURL ) )
 246     {
 247         mDlg->leHttp->setText( filteredURL.url() );
 248         count++;
 249     }
 250     else
 251         setHighLight( mDlg->lbHttp, true );
 252
 253     if ( !mDlg->cbSameProxy->isChecked () )
 254     {
 255         if ( isValidURL( mDlg->leHttps->text(), &filteredURL ) )
 256         {
 257             mDlg->leHttps->setText( filteredURL.url() );
 258             count++;
 259         }
 260         else
 261             setHighLight( mDlg->lbHttps, true );
 262
 263         if ( isValidURL( mDlg->leFtp->text(), &filteredURL ) )
 264         {
 265             mDlg->leFtp->setText( filteredURL.url() );
 266             count++;
 267         }
 268         else
 269             setHighLight( mDlg->lbFtp, true );
 270     }
 271
 272     if ( count == 0 )
 273     {
 274         showErrorMsg( i18n("Invalid Proxy Setting"),
 275                       i18n("One or more of the specified proxy settings are "
 276                            "invalid. The incorrect entries are highlighted.") );
 277     }
 278
 279     return (count > 0);
 280 }
 281
 282 void KManualProxyDlg::textChanged(const QString& text)
 283 {
 284     if (!mDlg->cbSameProxy->isChecked())
 285         return;
 286
 287     mDlg->leFtp->setText( text );
 288     mDlg->leHttps->setText( text );
 289 }
 290
 291 void KManualProxyDlg::valueChanged(int value)
 292 {
 293     if (!mDlg->cbSameProxy->isChecked())
 294         return;
 295
 296     mDlg->sbFtp->setValue (value);
 297     mDlg->sbHttps->setValue (value);
 298  }
 299
 300 void KManualProxyDlg::copyDown()
 301 {
 302     int action = -1;
 303
 304     if ( !mDlg->leHttp->text().isEmpty() )
 305         action += 4;
 306     else if ( !mDlg->leHttps->text().isEmpty() )
 307         action += 3;
 308
 309     switch ( action )
 310     {
 311       case 3:
 312         mDlg->leHttps->setText( mDlg->leHttp->text() );
 313         mDlg->sbHttps->setValue( mDlg->sbHttp->value() );
 314         mDlg->leFtp->setText( mDlg->leHttp->text() );
 315         mDlg->sbFtp->setValue( mDlg->sbHttp->value() );
 316         break;
 317       case 2:
 318         mDlg->leFtp->setText( mDlg->leHttps->text() );
 319         mDlg->sbFtp->setValue( mDlg->sbHttps->value() );
 320         break;
 321       case 1:
 322       case 0:
 323       default:
 324         break;
 325     }
 326 }
 327
 328 void KManualProxyDlg::slotOk()
 329 {
 330     if ( m_bHasValidData || validate() )
 331       m_bHasValidData = true;
 332 }
 333
 334 bool KManualProxyDlg::handleDuplicate( const QString& site )
 335 {
 336     for ( int rowIndex = 0 ; rowIndex < mDlg->lbExceptions->count() ; rowIndex++ )
 337     {
 338         QListWidgetItem* item = mDlg->lbExceptions->item(rowIndex);
 339
 340         if ( item->text().lastIndexOf( site ) != -1 &&
 341              item != mDlg->lbExceptions->currentItem() )
 342         {
 343             QString msg = i18n("You entered a duplicate address. "
 344                                "Please try again.");
 345             QString details = i18n("<qt><center><b>%1</b></center> "
 346                                    "is already in the list.</qt>", site);
 347             KMessageBox::detailedError( this, msg, details, i18n("Duplicate Entry") );
 348             return true;
 349         }
 350     }
 351     return false;
 352 }
 353
 354 void KManualProxyDlg::newPressed()
 355 {
 356   QString result;
 357   if( getException(result, i18n("New Exception")) && !handleDuplicate(result) )
 358     mDlg->lbExceptions->addItem( result );
 359 }
 360
 361 void KManualProxyDlg::changePressed()
 362 {
 363   QString result;
 364   if( getException( result, i18n("Change Exception"),
 365                     mDlg->lbExceptions->currentItem()->text() ) &&
 366       !handleDuplicate( result ) )
 367       mDlg->lbExceptions->currentItem()->setText(result);
 368 }
 369
 370 void KManualProxyDlg::deletePressed()
 371 {
 372     delete mDlg->lbExceptions->takeItem( mDlg->lbExceptions->currentRow() );
 373     if(mDlg->lbExceptions->currentItem())
 374        mDlg->lbExceptions->currentItem()->setSelected(true);
 375     updateButtons();
 376 }
 377
 378 void KManualProxyDlg::deleteAllPressed()
 379 {
 380     mDlg->lbExceptions->clear();
 381     updateButtons();
 382 }
 383
 384 void KManualProxyDlg::updateButtons()
 385 {
 386     bool hasItems = mDlg->lbExceptions->count() > 0;
 387     bool itemSelected = (hasItems && mDlg->lbExceptions->currentItem()!=0);
 388
 389     mDlg->pbDeleteAll->setEnabled( hasItems );
 390     mDlg->pbDelete->setEnabled( itemSelected );
 391     mDlg->pbChange->setEnabled( itemSelected );
 392 }
 393
 394 QString KManualProxyDlg::urlFromInput(const KLineEdit* edit,
 395                                       const QSpinBox* spin) const
 396 {
 397   if (!edit)
 398     return QString();
 399
 400   KUrl u( edit->text() );
 401
 402   if (spin)
 403     u.setPort( spin->value() );
 404
 405   return u.url();
 406 }
 407
 408 bool KManualProxyDlg::isValidURL( const QString& _url, KUrl* result ) const
 409 {
 410     KUrl url (_url);
 411
 412     QStringList filters;
 413     filters << "kshorturifilter" << "localdomainurifilter";
 414
 415     // If the typed URL is malformed, and the filters cannot filter it
 416     // then it must be an invalid entry.
 417     if( !(url.isValid() && KUriFilter::self()->filterUri(url, filters) &&
 418         url.hasHost()) )
 419       return false;
 420
 421     QString host (url.host());
 422
 423     // We only check for a relevant subset of characters that are
 424     // not allowed in <authority> component of a URL.
 425     if ( host.contains ('*') || host.contains (' ') || host.contains ('?') )
 426       return false;
 427
 428     if ( result )
 429       *result = url;
 430
 431     return true;
 432 }
 433
 434 void KManualProxyDlg::showErrorMsg( const QString& caption,
 435                                     const QString& message )
 436 {
 437   QString cap( caption );
 438   QString msg( message );
 439
 440   if ( cap.isNull() )
 441     cap = i18n("Invalid Entry");
 442
 443   if ( msg.isNull() )
 444     msg = i18n("The address you have entered is not valid.");
 445
 446   QString details = i18n("<qt>Make sure none of the addresses or URLs you "
 447                           "specified contain invalid or wildcard characters "
 448                           "such as spaces, asterisks (*), or question marks(?).<br /><br />"
 449                           "<u>Examples of VALID entries:</u><br />"
 450                           "<code>http://mycompany.com, 192.168.10.1, "
 451                           "mycompany.com, localhost, http://localhost</code><br /><br />"
 452                           "<u>Examples of INVALID entries:</u><br />"
 453                           "<code>http://my company.com, http:/mycompany,com "
 454                           "file:/localhost</code></qt>");
 455
 456   KMessageBox::detailedError( this, msg, details, cap );
 457 }
 458
 459 bool KManualProxyDlg::getException ( QString& result,
 460                                      const QString& caption,
 461                                      const QString& value )
 462 {
 463     QString label;
 464
 465     // Specify the appropriate message...
 466     if ( mDlg->cbReverseProxy->isChecked() )
 467       label = i18n("Enter the URL or address that should use the above proxy "
 468                    "settings:");
 469     else
 470       label = i18n("Enter the address or URL that should be excluded from "
 471                    "using the above proxy settings:");
 472
 473     QString whatsThis = i18n("<qt>Enter a valid address or URL.<br /><br />"
 474                             "<b><u>NOTE:</u></b> Wildcard matching such as "
 475                             "<code>*.kde.org</code> is not supported. If you want "
 476                             "to match any host in the <code>.kde.org</code> domain, "
 477                             "e.g. <code>printing.kde.org</code>, then simply enter "
 478                             "<code>.kde.org</code>.</qt>");
 479
 480     bool ok;
 481     result = KInputDialog::getText( caption, label, value, &ok, this,
 482                                     0, QString(), whatsThis );
 483
 484     // If the user pressed cancel, do nothing...
 485     if (!ok)
 486       return false;
 487
 488     // If the typed URL is malformed, and the filters cannot filter it
 489     // then it must be an invalid entry,
 490     if( isValidURL(result) || (result.length() >= 3 && result.startsWith('.')))
 491       return true;
 492
 493     showErrorMsg();
 494     return false;
 495 }
 496
 497 #include "kmanualproxydlg.moc"