kppp/pppdata.cpp

   1 /*
   2  *            kPPP: A pppd front end for the KDE project
   3  *
   4  * $Id$
   5  *
   6  *            Copyright (C) 1997 Bernd Johannes Wuebben
   7  *                   wuebben@math.cornell.edu
   8  *
   9  * based on EzPPP:
  10  * Copyright (C) 1997  Jay Painter
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Library General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2 of the License, or (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Library General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Library General Public
  23  * License along with this program; if not, write to the Free
  24  * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  25  */
  26
  27 #include "pppdata.h"
  28 #include "runtests.h"
  29 #include "devices.h"
  30 #include <klocale.h>
  31 #include <kconfig.h>
  32 #include <kconfiggroup.h>
  33 #include <kmessagebox.h>
  34 #include <kapplication.h>
  35 #include <kglobalsettings.h>
  36 #include <assert.h>
  37 #include <kglobal.h>
  38
  39 PPPData gpppdata;
  40
  41
  42 PPPData::PPPData()
  43   :  config(0L),
  44      accounthighcount(-1),        // start out with no account entries
  45      caccount(-1),         // set the current account index also
  46      modemhighcount(-1),        // start out with no modem entries
  47      cmodem(-1),         // set the current modem index also
  48      suidprocessid(-1),    // process ID of setuid child
  49      pppdisrunning(false),
  50      pppderror(0),
  51      waitcallback(false)
  52 {
  53 }
  54
  55
  56 //
  57 // open configuration file
  58 //
  59 bool PPPData::open() {
  60
  61   config = KGlobal::config();
  62
  63   if (config->accessMode() == KConfig::NoAccess) {
  64     KMessageBox::error(0L,
  65                        i18n("The application-specific config file could not "
  66                        "be opened in either read-write or read-only mode.\n"
  67                        "The superuser might have to change its ownership "
  68                        "by issuing the following command in your home directory:\n"
  69                        "chown {YourUsername} .kde/share/config/kppprc"),
  70                          kapp->objectName());
  71     return false;
  72   }
  73
  74   // don't expand shell variables
  75   accounthighcount = readNumConfig(GENERAL_GRP, NUMACCOUNTS_KEY, 0) - 1;
  76
  77   if (accounthighcount > MAX_ACCOUNTS)
  78     accounthighcount = MAX_ACCOUNTS;
  79
  80   if(accounthighcount >= 0 && defaultAccount().isEmpty()) {
  81     setAccountByIndex(0);
  82     setDefaultAccount(accname());
  83   } else if(!setAccount(defaultAccount()))
  84     setDefaultAccount(accname());
  85
  86   modemhighcount = readNumConfig(GENERAL_GRP, NUMMODEMS_KEY, 0) - 1;
  87
  88   if (modemhighcount > MAX_MODEMS)
  89     modemhighcount = MAX_MODEMS;
  90
  91   // if there aren't any ModemX set and exists the [Modem] group,
  92   // probably it's the first time we are using this new version
  93   // with multiple modem profiles.
  94   // So we copy the old [Modem] to the new [Modem0]
  95   if(modemhighcount < 0 && defaultModem().isEmpty() && config->hasGroup("Modem"))
  96   {
  97         KConfigGroup cg( config , "Modem");
  98
  99     QMap <QString, QString> map = config->entryMap("Modem");
 100     QMap <QString, QString>::ConstIterator it = map.constBegin();
 101
 102     newmodem();
 103
 104     while (it != map.constEnd()) {
 105           KConfigGroup cg2( config , cmodemgroup);
 106       cg2.writeEntry(it.key(), *it);
 107       it++;
 108     }
 109
 110         QString newname("Modem0");
 111     setModname(newname);
 112   }
 113
 114   if(modemhighcount >= 0 && defaultModem().isEmpty()) {
 115     setModemByIndex(0);
 116     setDefaultModem(modname());
 117   } else if(!setModem(defaultModem()))
 118     setDefaultModem(modname());
 119
 120
 121   // start out with internal debugging disabled
 122   // the user is still free to specify `debug' on his own
 123   setPPPDebug(false);
 124
 125   ::pppdVersion(&pppdVer, &pppdMod, &pppdPatch);
 126
 127   return true;
 128 }
 129
 130
 131 //
 132 // save configuration
 133 //
 134 void PPPData::save() {
 135
 136   if (config) {
 137     writeConfig(GENERAL_GRP, NUMACCOUNTS_KEY, accountCount());
 138     writeConfig(GENERAL_GRP, NUMMODEMS_KEY, modemCount());
 139     config->sync();
 140   }
 141
 142 }
 143
 144
 145 //
 146 // cancel changes
 147 //
 148 void PPPData::cancel() {
 149
 150   if (config) {
 151     config->markAsClean();
 152     config->reparseConfiguration();
 153   }
 154
 155 }
 156
 157
 158 // currently differentiates between READWRITE and NONE only
 159 int PPPData::access() const {
 160
 161   return config->accessMode();
 162 }
 163
 164
 165 // functions to read/write date to configuration file
 166 QString PPPData::readConfig(const QString &group, const QString &key,
 167                             const QString &defvalue = "")
 168 {
 169   if (config) {
 170     return config->group(group).readEntry(key, defvalue);
 171   } else
 172     return defvalue;
 173 }
 174
 175
 176 int PPPData::readNumConfig(const QString &group, const QString &key,
 177                            int defvalue) {
 178   if (config) {
 179     return config->group(group).readEntry(key, defvalue);
 180   } else
 181     return defvalue;
 182
 183 }
 184
 185
 186 bool PPPData::readListConfig(const QString &group, const QString &key,
 187                              QStringList &list) {
 188   list.clear();
 189   if (config) {
 190     list = config->group(group).readEntry(key, QStringList());
 191     return true;
 192   } else
 193     return false;
 194 }
 195
 196
 197 void PPPData::writeConfig(const QString &group, const QString &key,
 198                           const QString &value) {
 199   if (config) {
 200     config->group(group).writeEntry(key, value);
 201   }
 202 }
 203
 204
 205 void PPPData::writeConfig(const QString &group, const QString &key, int value) {
 206   if (config) {
 207     config->group(group).writeEntry(key, value);
 208   }
 209 }
 210
 211
 212 void PPPData::writeListConfig(const QString &group, const QString &key,
 213                               QStringList &list) {
 214   if (config) {
 215     config->group(group).writeEntry(key, list);
 216   }
 217 }
 218
 219
 220 //
 221 // functions to set/return general information
 222 //
 223 QString PPPData::password() const {
 224   return passwd;
 225 }
 226
 227
 228 void PPPData::setPassword(const QString &pw) {
 229   passwd = pw;
 230 }
 231
 232
 233 const QString PPPData::defaultAccount() {
 234   return readConfig(GENERAL_GRP, DEFAULTACCOUNT_KEY);
 235 }
 236
 237
 238 void PPPData::setDefaultAccount(const QString &n) {
 239   writeConfig(GENERAL_GRP, DEFAULTACCOUNT_KEY, n);
 240
 241   //now set the current account index to the default account
 242   setAccount(defaultAccount());
 243 }
 244
 245
 246 const QString PPPData::defaultModem() {
 247   return readConfig(GENERAL_GRP, DEFAULTMODEM_KEY);
 248 }
 249
 250
 251 void PPPData::setDefaultModem(const QString &n) {
 252   writeConfig(GENERAL_GRP, DEFAULTMODEM_KEY, n);
 253
 254   //now set the current modem index to the default modem
 255   setModem(defaultModem());
 256 }
 257
 258 bool PPPData::get_show_clock_on_caption() {
 259   return (bool) readNumConfig(GENERAL_GRP, SHOWCLOCK_KEY, true);
 260 }
 261
 262
 263 void PPPData::set_show_clock_on_caption(bool set) {
 264   writeConfig(GENERAL_GRP, SHOWCLOCK_KEY, (int) set);
 265 }
 266
 267
 268 bool PPPData::get_xserver_exit_disconnect() {
 269   return (bool) readNumConfig(GENERAL_GRP, DISCONNECT_KEY, true);
 270 }
 271
 272 bool PPPData::get_redial_on_nocarrier() {
 273   return (bool) readNumConfig(GENERAL_GRP, REDIALONNOCARR_KEY, false);
 274 }
 275
 276
 277 void PPPData::setPPPDebug(bool set) {
 278   writeConfig(GENERAL_GRP, PPP_DEBUG_OPTION, (int)set);
 279 }
 280
 281
 282 bool PPPData::getPPPDebug() {
 283   return (bool)readNumConfig(GENERAL_GRP, PPP_DEBUG_OPTION, false);
 284 }
 285
 286
 287 void PPPData::set_xserver_exit_disconnect(bool set) {
 288   writeConfig(GENERAL_GRP, DISCONNECT_KEY, (int) set);
 289 }
 290
 291 void PPPData::set_redial_on_nocarrier(bool set) {
 292   writeConfig(GENERAL_GRP, REDIALONNOCARR_KEY, (int) set);
 293 }
 294
 295
 296 bool PPPData::quit_on_disconnect() {
 297   return (bool) readNumConfig(GENERAL_GRP, QUITONDISCONNECT_KEY, false);
 298 }
 299
 300
 301 void PPPData::set_quit_on_disconnect(bool set) {
 302   writeConfig(GENERAL_GRP, QUITONDISCONNECT_KEY, (int) set);
 303 }
 304
 305
 306 bool PPPData::get_show_log_window() {
 307   return (bool) readNumConfig (GENERAL_GRP, SHOWLOGWIN_KEY, false);
 308 }
 309
 310
 311 void PPPData::set_show_log_window(bool set) {
 312   writeConfig(GENERAL_GRP, SHOWLOGWIN_KEY, (int) set);
 313 }
 314
 315
 316 bool PPPData::automatic_redial() {
 317   return (bool) readNumConfig(GENERAL_GRP, AUTOREDIAL_KEY, false);
 318 }
 319
 320
 321 void PPPData::set_automatic_redial(bool set) {
 322   writeConfig(GENERAL_GRP, AUTOREDIAL_KEY, (int) set);
 323 }
 324
 325
 326 bool PPPData::get_iconify_on_connect() {
 327   return (bool) readNumConfig(GENERAL_GRP, ICONIFY_ON_CONNECT_KEY, true);
 328 }
 329
 330
 331 void PPPData::set_iconify_on_connect(bool set) {
 332   writeConfig(GENERAL_GRP, ICONIFY_ON_CONNECT_KEY, (int) set);
 333 }
 334
 335
 336 bool PPPData::get_dock_into_panel() {
 337   return (bool) readNumConfig(GENERAL_GRP, DOCKING_KEY, false);
 338 }
 339
 340
 341 void PPPData::set_dock_into_panel(bool set) {
 342   writeConfig(GENERAL_GRP, DOCKING_KEY, (int) set);
 343 }
 344
 345
 346 QString PPPData::pppdVersion() {
 347   return QString("%1.%2.%3").arg(pppdVer).arg(pppdMod).arg(pppdPatch);
 348 }
 349
 350 bool PPPData::pppdVersionMin(int ver, int mod, int patch) {
 351   // check if pppd version fulfills minimum requirement
 352   return (pppdVer > ver
 353           || (pppdVer == ver && pppdMod > mod)
 354           || (pppdVer == ver && pppdMod == mod && pppdPatch >= patch));
 355 }
 356
 357 int PPPData::pppdTimeout() {
 358   return readNumConfig(GENERAL_GRP, PPPDTIMEOUT_KEY, PPPD_TIMEOUT);
 359 }
 360
 361
 362 void PPPData::setpppdTimeout(int n) {
 363   writeConfig(GENERAL_GRP, PPPDTIMEOUT_KEY, n);
 364 }
 365
 366 //
 367 // functions to set/return modem information
 368 //
 369
 370
 371 //returns number of modems
 372 int PPPData::modemCount() const {
 373   return modemhighcount + 1;
 374 }
 375
 376
 377 bool PPPData::setModem(const QString &mname) {
 378   for(int i = 0; i <= modemhighcount; i++) {
 379     setModemByIndex(i);
 380     if(modname() == mname) {
 381       cmodem = i;
 382       return true;
 383     }
 384   }
 385   return false;
 386 }
 387
 388
 389 bool PPPData::setModemByIndex(int i) {
 390   if(i >= 0 && i <= modemhighcount) {
 391     cmodem = i;
 392     cmodemgroup.sprintf("%s%i", MODEM_GRP, i);
 393     return true;
 394   }
 395   return false;
 396 }
 397
 398
 399 bool PPPData::isUniqueModname(const QString &n) {
 400   int current = cmodem;
 401   for(int i=0; i <= modemhighcount; i++) {
 402     setModemByIndex(i);
 403     if(modname() == n && i != current) {
 404       setModemByIndex(current);
 405       return false;
 406     }
 407   }
 408   setModemByIndex(current);
 409   return true;
 410 }
 411
 412 bool PPPData::deleteModem() {
 413   if(cmodem < 0)
 414     return false;
 415
 416   QMap <QString, QString> map;
 417   QMap <QString, QString>::Iterator it;
 418
 419   // set all entries of the current modem to ""
 420   map = config->entryMap(cmodemgroup);
 421   it = map.begin();
 422   while (it != map.end()) {
 423     config->group(cmodemgroup).writeEntry(it.key(), "");
 424     it++;
 425   }
 426
 427   // shift the succeeding modems
 428   for(int i = cmodem+1; i <= modemhighcount; i++) {
 429     setModemByIndex(i);
 430     map = config->entryMap(cmodemgroup);
 431     it = map.begin();
 432     setModemByIndex(i-1);
 433         KConfigGroup cg(config, cmodemgroup);
 434     while (it != map.end()) {
 435       cg.writeEntry(it.key(), *it);
 436       it++;
 437     }
 438   }
 439
 440   // make sure the top modem is cleared
 441   setModemByIndex(modemhighcount);
 442   map = config->entryMap(cmodemgroup);
 443   if( !map.isEmpty())
 444   {
 445     it = map.begin();
 446     KConfigGroup cg2(config, cmodemgroup);
 447     while (!it.key().isEmpty()) {
 448       if(!it.key().isEmpty())
 449          cg2.writeEntry(it.key(), "");
 450       it++;
 451     }
 452   }
 453   modemhighcount--;
 454   if(cmodem > modemhighcount)
 455     cmodem = modemhighcount;
 456
 457   setModemByIndex(cmodem);
 458
 459   return true;
 460 }
 461
 462 bool PPPData::deleteModem(const QString &mname) {
 463   if(!setModem(mname))
 464     return false;
 465
 466   deleteModem();
 467
 468   return true;
 469 }
 470
 471
 472 int PPPData::newmodem() {
 473
 474   if(!config || modemhighcount >= MAX_MODEMS)
 475     return -1;
 476
 477   modemhighcount++;
 478   setModemByIndex(modemhighcount);
 479
 480   setpppdArgumentDefaults();
 481
 482   return cmodem;
 483 }
 484
 485 int PPPData::copymodem(int i) {
 486
 487   KConfigGroup group = config->group(cmodemgroup);
 488
 489   if(modemhighcount >= MAX_MODEMS)
 490     return -1;
 491
 492   setModemByIndex(i);
 493
 494   QMap <QString, QString> map = group.entryMap();
 495   QMap <QString, QString>::ConstIterator it = map.constBegin();
 496
 497   QString newname = i18n("%1_copy", modname());
 498
 499   newmodem();
 500
 501   while (it != map.constEnd()) {
 502         group = config->group(cmodemgroup);
 503     group.writeEntry(it.key(), *it);
 504     it++;
 505   }
 506
 507   setModname(newname);
 508
 509   return cmodem;
 510 }
 511
 512
 513 const QString PPPData::modname() {
 514   return readConfig(cmodemgroup, MOD_NAME_KEY);
 515 }
 516
 517 void PPPData::setModname(const QString &n) {
 518   if(!cmodemgroup.isNull()) {
 519     // are we manipulating the default modem's name ? then change it, too.
 520     bool def = modname() == defaultModem();
 521     writeConfig(cmodemgroup, MOD_NAME_KEY, n);
 522     if (def)
 523       setDefaultModem(n);
 524   }
 525 }
 526
 527
 528
 529
 530 const QString PPPData::modemDevice() {
 531   return readConfig (cmodemgroup, MODEMDEV_KEY, devices[DEV_DEFAULT]);
 532 }
 533
 534
 535 void PPPData::setModemDevice(const QString &n) {
 536   writeConfig(cmodemgroup, MODEMDEV_KEY, n);
 537 }
 538
 539
 540 QString PPPData::flowcontrol() {
 541   // keep default value in sync with general.cpp
 542   return readConfig(cmodemgroup, FLOWCONTROL_KEY, i18n("Hardware [CRTSCTS]"));
 543 }
 544
 545
 546 void PPPData::setFlowcontrol(const QString &n) {
 547   writeConfig(cmodemgroup, FLOWCONTROL_KEY, n);
 548 }
 549
 550
 551 const QString PPPData::speed() {
 552   QString s = readConfig(cmodemgroup, SPEED_KEY, "57600");
 553   // undo the damage of a bug in former versions. It left an empty Speed=
 554   // entry in kppprc. kppp did set the serial port to 57600 as default but
 555   // pppd wouldn't receive the speed via the command line.
 556   if(s.toUInt() == 0)
 557     s = "57600";
 558   return s;
 559 }
 560
 561
 562 void PPPData::setSpeed(const QString &n) {
 563   writeConfig(cmodemgroup, SPEED_KEY, n);
 564 }
 565
 566
 567 #if 0
 568 void PPPData::setUseCDLine(const int n) {
 569   writeConfig(cmodemgroup,USECDLINE_KEY,n);
 570 }
 571
 572
 573 int PPPData::UseCDLine() {
 574   return  readNumConfig(cmodemgroup,USECDLINE_KEY,0);
 575 }
 576 #endif
 577
 578 const QString  PPPData::modemEscapeStr() {
 579   return readConfig(cmodemgroup,ESCAPESTR_KEY,"+++");
 580 }
 581
 582
 583 void PPPData::setModemEscapeStr(const QString &n) {
 584   writeConfig(cmodemgroup,ESCAPESTR_KEY,n);
 585 }
 586
 587
 588 const QString  PPPData::modemEscapeResp() {
 589   return readConfig(cmodemgroup,ESCAPERESP_KEY,"OK");
 590 }
 591
 592
 593 void PPPData::setModemEscapeResp(const QString &n) {
 594   writeConfig(cmodemgroup,ESCAPERESP_KEY,n);
 595 }
 596
 597
 598 int  PPPData::modemEscapeGuardTime() {
 599   return readNumConfig(cmodemgroup,ESCAPEGUARDTIME_KEY,50);
 600 }
 601
 602
 603 void PPPData::setModemEscapeGuardTime(int n) {
 604   writeConfig(cmodemgroup,ESCAPEGUARDTIME_KEY,n);
 605 }
 606
 607
 608 bool PPPData::modemLockFile() {
 609   return readNumConfig(cmodemgroup, LOCKFILE_KEY, 1);
 610 }
 611
 612
 613 void PPPData::setModemLockFile(bool set) {
 614   writeConfig(cmodemgroup, LOCKFILE_KEY, set);
 615 }
 616
 617
 618 int PPPData::modemTimeout() {
 619   return readNumConfig(cmodemgroup, TIMEOUT_KEY, MODEM_TIMEOUT);
 620 }
 621
 622
 623 void PPPData::setModemTimeout(int n) {
 624   writeConfig(cmodemgroup, TIMEOUT_KEY, n);
 625 }
 626
 627
 628 int PPPData::modemToneDuration() {
 629   return readNumConfig(cmodemgroup, TONEDURATION_KEY,MODEM_TONEDURATION);
 630 }
 631
 632
 633 void PPPData::setModemToneDuration(int n) {
 634   writeConfig(cmodemgroup, TONEDURATION_KEY, n);
 635 }
 636
 637
 638 int PPPData::busyWait() {
 639   return readNumConfig(cmodemgroup, BUSYWAIT_KEY, BUSY_WAIT);
 640 }
 641
 642
 643 void PPPData::setbusyWait(int n) {
 644   writeConfig(cmodemgroup, BUSYWAIT_KEY, n);
 645 }
 646
 647
 648 //
 649 //Advanced "Modem" dialog
 650 //
 651 // defaults: InitString=ATZ, InitString1="" etc.
 652 const QString PPPData::modemInitStr(int i) {
 653   assert(i >= 0 && i < NumInitStrings);
 654   if(i == 0)
 655     return readConfig(cmodemgroup, INITSTR_KEY, "ATZ");
 656   else
 657     return readConfig(cmodemgroup, INITSTR_KEY + QString::number(i), "");
 658 }
 659
 660
 661 void PPPData::setModemInitStr(int i, const QString &n) {
 662   assert(i >= 0 && i < NumInitStrings);
 663   QString k = INITSTR_KEY + (i > 0 ? QString::number(i) : "");
 664   writeConfig(cmodemgroup, k, n);
 665 }
 666
 667
 668 const QString PPPData::modemInitResp() {
 669   return readConfig(cmodemgroup, INITRESP_KEY, "OK");
 670 }
 671
 672
 673 void PPPData::setModemInitResp(const QString &n) {
 674   writeConfig(cmodemgroup, INITRESP_KEY, n);
 675 }
 676
 677
 678 int PPPData::modemPreInitDelay() {
 679   return readNumConfig(cmodemgroup, PREINITDELAY_KEY, 50);
 680 }
 681
 682
 683 void PPPData::setModemPreInitDelay(int n) {
 684   writeConfig(cmodemgroup, PREINITDELAY_KEY, n);
 685 }
 686
 687
 688 int PPPData::modemInitDelay() {
 689   return readNumConfig(cmodemgroup, INITDELAY_KEY, 50);
 690 }
 691
 692
 693 void PPPData::setModemInitDelay(int n) {
 694   writeConfig(cmodemgroup, INITDELAY_KEY, n);
 695 }
 696
 697 QString PPPData::modemNoDialToneDetectionStr() {
 698   return readConfig(cmodemgroup, NODTDETECT_KEY, "ATX3");
 699 }
 700
 701 void PPPData::setModemNoDialToneDetectionStr(const QString &n) {
 702   writeConfig(cmodemgroup, NODTDETECT_KEY, n);
 703 }
 704
 705 const QString PPPData::modemDialStr() {
 706   return readConfig(cmodemgroup, DIALSTR_KEY, "ATDT");
 707 }
 708
 709
 710 void PPPData::setModemDialStr(const QString &n) {
 711   writeConfig(cmodemgroup, DIALSTR_KEY, n);
 712 }
 713
 714
 715 const QString PPPData::modemConnectResp() {
 716   return readConfig(cmodemgroup, CONNECTRESP_KEY, "CONNECT");
 717 }
 718
 719
 720 void PPPData::setModemConnectResp(const QString &n) {
 721   writeConfig(cmodemgroup, CONNECTRESP_KEY, n);
 722 }
 723
 724
 725 const QString PPPData::modemBusyResp() {
 726   return readConfig(cmodemgroup, BUSYRESP_KEY, "BUSY");
 727 }
 728
 729
 730 void PPPData::setModemBusyResp(const QString &n) {
 731   writeConfig(cmodemgroup, BUSYRESP_KEY, n);
 732 }
 733
 734
 735 const QString PPPData::modemNoCarrierResp() {
 736   return readConfig(cmodemgroup, NOCARRIERRESP_KEY, "NO CARRIER");
 737 }
 738
 739
 740 void PPPData::setModemNoCarrierResp(const QString &n) {
 741   writeConfig(cmodemgroup, NOCARRIERRESP_KEY, n);
 742 }
 743
 744
 745 const QString PPPData::modemNoDialtoneResp() {
 746   return readConfig(cmodemgroup, NODIALTONERESP_KEY, "NO DIALTONE");
 747 }
 748
 749
 750 void PPPData::setModemNoDialtoneResp(const QString &n) {
 751   writeConfig(cmodemgroup, NODIALTONERESP_KEY, n);
 752 }
 753
 754
 755 const QString PPPData::modemHangupStr() {
 756   return readConfig(cmodemgroup, HANGUPSTR_KEY, "+++ATH");
 757 }
 758
 759 void PPPData::setModemHangupStr(const QString &n) {
 760   writeConfig(cmodemgroup, HANGUPSTR_KEY, n);
 761 }
 762
 763
 764 const QString PPPData::modemHangupResp() {
 765   return readConfig(cmodemgroup, HANGUPRESP_KEY, "OK");
 766 }
 767
 768 void PPPData::setModemHangupResp(const QString &n) {
 769   writeConfig(cmodemgroup, HANGUPRESP_KEY, n);
 770 }
 771
 772
 773 QString PPPData::modemDLPResp() {
 774   return readConfig(cmodemgroup, DLPRESP_KEY, "DIGITAL LINE DETECTED");
 775 }
 776
 777 void PPPData::setModemDLPResp(const QString &n) {
 778   writeConfig(cmodemgroup, DLPRESP_KEY, n);
 779 }
 780
 781
 782
 783
 784 const QString PPPData::modemAnswerStr() {
 785   return readConfig(cmodemgroup, ANSWERSTR_KEY, "ATA");
 786 }
 787
 788
 789 QString PPPData::volumeOff() {
 790   return readConfig(cmodemgroup, VOLUME_OFF, "M0L0");
 791 }
 792
 793
 794 void PPPData::setVolumeOff(const QString &s) {
 795   writeConfig(cmodemgroup, VOLUME_OFF, s);
 796 }
 797
 798
 799 QString PPPData::volumeMedium() {
 800  return readConfig(cmodemgroup, VOLUME_MEDIUM, "M1L1");
 801 }
 802
 803
 804 void PPPData::setVolumeMedium(const QString &s) {
 805   writeConfig(cmodemgroup, VOLUME_MEDIUM, s);
 806 }
 807
 808
 809 QString PPPData::volumeHigh() {
 810   QString tmp = readConfig(cmodemgroup, VOLUME_HIGH, "M1L3");
 811   if(tmp == "M1L4")
 812     tmp = "M1L3";
 813   return tmp;
 814 }
 815
 816
 817 void PPPData::setVolumeHigh(const QString &s) {
 818  writeConfig(cmodemgroup, VOLUME_HIGH, s);
 819 }
 820
 821
 822 QString PPPData::volumeInitString() {
 823   QString s;
 824
 825   switch(volume()) {
 826   case 0:
 827     s = volumeOff();
 828     break;
 829   case 1:
 830     s = volumeMedium();
 831     break;
 832   case 2:
 833     s = volumeHigh();
 834     break;
 835   default:
 836     s = volumeMedium();
 837   }
 838
 839   return s;
 840 }
 841
 842
 843 int PPPData::volume() {
 844   return readNumConfig(cmodemgroup, VOLUME_KEY, 1);
 845 }
 846
 847
 848 void PPPData::setVolume(int i) {
 849   writeConfig(cmodemgroup, VOLUME_KEY, i);
 850 }
 851
 852 int PPPData::waitForDialTone() {
 853   return readNumConfig(cmodemgroup, DIALTONEWAIT_KEY, 1);
 854 }
 855
 856 void PPPData::setWaitForDialTone(int i) {
 857   writeConfig(cmodemgroup, DIALTONEWAIT_KEY, i);
 858 }
 859
 860 void PPPData::setModemAnswerStr(const QString &n) {
 861   writeConfig(cmodemgroup, ANSWERSTR_KEY, n);
 862 }
 863
 864
 865 const QString PPPData::modemRingResp() {
 866   return readConfig(cmodemgroup, RINGRESP_KEY, "RING");
 867 }
 868
 869
 870 void PPPData::setModemRingResp(const QString &n) {
 871   writeConfig(cmodemgroup, RINGRESP_KEY, n);
 872 }
 873
 874
 875 const QString PPPData::modemAnswerResp() {
 876   return readConfig(cmodemgroup, ANSWERRESP_KEY, "CONNECT");
 877 }
 878
 879
 880 void PPPData::setModemAnswerResp(const QString &n) {
 881   writeConfig(cmodemgroup, ANSWERRESP_KEY, n);
 882 }
 883
 884
 885 const QString PPPData::enter() {
 886   return readConfig(cmodemgroup, ENTER_KEY, "CR");
 887 }
 888
 889
 890 void PPPData::setEnter(const QString &n) {
 891   writeConfig(cmodemgroup, ENTER_KEY, n);
 892 }
 893
 894
 895 //
 896 // functions to set/return account information
 897 //
 898
 899 //returns number of accounts
 900 int PPPData::accountCount() const {
 901   return accounthighcount + 1;
 902 }
 903
 904
 905 bool PPPData::setAccount(const QString &aname) {
 906   for(int i = 0; i <= accounthighcount; i++) {
 907     setAccountByIndex(i);
 908     if(accname() == aname) {
 909       caccount = i;
 910       return true;
 911     }
 912   }
 913   return false;
 914 }
 915
 916
 917 bool PPPData::setAccountByIndex(int i) {
 918   if(i >= 0 && i <= accounthighcount) {
 919     caccount = i;
 920     caccountgroup.sprintf("%s%i", ACCOUNT_GRP, i);
 921     return true;
 922   }
 923   return false;
 924 }
 925
 926
 927 bool PPPData::isUniqueAccname(const QString &n) {
 928   if(n.contains(':'))
 929     return false;
 930   int current = caccount;
 931   for(int i=0; i <= accounthighcount; i++) {
 932     setAccountByIndex(i);
 933     if(accname() == n && i != current) {
 934       setAccountByIndex(current);
 935       return false;
 936     }
 937   }
 938   setAccountByIndex(current);
 939   return true;
 940 }
 941
 942
 943 bool PPPData::deleteAccount() {
 944   if(caccount < 0)
 945     return false;
 946
 947   QMap <QString, QString> map;
 948   QMap <QString, QString>::Iterator it;
 949
 950   // set all entries of the current account to ""
 951   map = config->entryMap(caccountgroup);
 952   it = map.begin();
 953   KConfigGroup cg(config,caccountgroup);
 954   while (it != map.end()) {
 955     cg.writeEntry(it.key(), "");
 956     ++it;
 957   }
 958
 959   // shift the succeeding accounts
 960   for(int i = caccount+1; i <= accounthighcount; i++) {
 961     setAccountByIndex(i);
 962     map = config->entryMap(caccountgroup);
 963     it = map.begin();
 964     setAccountByIndex(i-1);
 965         KConfigGroup cg2(config,caccountgroup);
 966     while (it != map.end()) {
 967       cg2.writeEntry(it.key(), *it);
 968       ++it;
 969     }
 970   }
 971
 972   // make sure the top account is cleared
 973   setAccountByIndex(accounthighcount);
 974   map = config->entryMap(caccountgroup);
 975   it = map.begin();
 976   KConfigGroup cg3(config,caccountgroup);
 977   while (it != map.end() && !it.key().isNull()) {
 978     cg3.writeEntry(it.key(), "");
 979     ++it;
 980   }
 981
 982   accounthighcount--;
 983   if(caccount > accounthighcount)
 984     caccount = accounthighcount;
 985
 986   setAccountByIndex(caccount);
 987
 988   return true;
 989 }
 990
 991 bool PPPData::deleteAccount(const QString &aname) {
 992   if(!setAccount(aname))
 993     return false;
 994
 995   deleteAccount();
 996
 997   return true;
 998 }
 999
1000
1001 int PPPData::newaccount() {
1002
1003   if(!config || accounthighcount >= MAX_ACCOUNTS)
1004     return -1;
1005
1006   accounthighcount++;
1007   setAccountByIndex(accounthighcount);
1008
1009   setpppdArgumentDefaults();
1010
1011   return caccount;
1012 }
1013
1014 int PPPData::copyaccount(int i) {
1015
1016   if(accounthighcount >= MAX_ACCOUNTS)
1017     return -1;
1018
1019   setAccountByIndex(i);
1020
1021   QMap <QString, QString> map = config->entryMap(caccountgroup);
1022   QMap <QString, QString>::ConstIterator it = map.constBegin();
1023
1024   QString newname = i18n("%1_copy", accname());
1025
1026   newaccount();
1027
1028   while (it != map.constEnd()) {
1029         KConfigGroup cg2 ( config, caccountgroup);
1030     cg2.writeEntry(it.key(), *it);
1031     it++;
1032   }
1033
1034   setAccname(newname);
1035
1036   return caccount;
1037 }
1038
1039
1040 const QString PPPData::accname() {
1041   return readConfig(caccountgroup, ACC_NAME_KEY);
1042 }
1043
1044 void PPPData::setAccname(const QString &n) {
1045   if(!caccountgroup.isNull()) {
1046     // are we manipulating the default account's name ? then change it, too.
1047     bool def = accname() == defaultAccount();
1048     writeConfig(caccountgroup, ACC_NAME_KEY, n);
1049     if (def)
1050       setDefaultAccount(n);
1051   }
1052 }
1053
1054
1055 #define SEPARATOR_CHAR ':'
1056 QStringList &PPPData::phonenumbers() {
1057   phonelist = readConfig(caccountgroup, PHONENUMBER_KEY).split(SEPARATOR_CHAR);
1058   return phonelist;
1059 }
1060
1061
1062 const QString PPPData::phonenumber() {
1063   return readConfig(caccountgroup, PHONENUMBER_KEY);
1064 }
1065
1066
1067 void PPPData::setPhonenumber(const QString &n) {
1068   writeConfig(caccountgroup, PHONENUMBER_KEY, n);
1069 }
1070
1071
1072 const QString PPPData::dialPrefix() {
1073   return readConfig(caccountgroup, DIAL_PREFIX_KEY, "");
1074 }
1075
1076
1077 void PPPData::setDialPrefix(const QString &s) {
1078   writeConfig(caccountgroup, DIAL_PREFIX_KEY, s);
1079 }
1080
1081
1082 int PPPData::authMethod() {
1083     return readNumConfig(caccountgroup, AUTH_KEY, 0);
1084 }
1085
1086
1087 void PPPData::setAuthMethod(int value) {
1088   writeConfig(caccountgroup, AUTH_KEY, value);
1089 }
1090
1091
1092 const QString  PPPData::storedUsername() {
1093   return readConfig(caccountgroup, STORED_USERNAME_KEY, "");
1094 }
1095
1096
1097 void PPPData::setStoredUsername(const QString &b) {
1098   writeConfig(caccountgroup, STORED_USERNAME_KEY, b);
1099 }
1100
1101
1102 const QString  PPPData::storedPassword() {
1103   return readConfig(caccountgroup, STORED_PASSWORD_KEY, "");
1104 }
1105
1106
1107 void PPPData::setStoredPassword(const QString &b) {
1108   writeConfig(caccountgroup, STORED_PASSWORD_KEY, b);
1109 }
1110
1111
1112 bool PPPData::storePassword() {
1113   return (bool)readNumConfig(caccountgroup, STORE_PASSWORD_KEY, 1);
1114 }
1115
1116 int PPPData::callbackType() {
1117   return readNumConfig(caccountgroup, CALLBACK_TYPE_KEY, 0);
1118 }
1119
1120 void PPPData::setCallbackType(int value) {
1121   writeConfig(caccountgroup, CALLBACK_TYPE_KEY, value);
1122 }
1123
1124 QString PPPData::callbackPhone() {
1125   return readConfig(caccountgroup, CALLBACK_PHONE_KEY, "");
1126 }
1127
1128 void PPPData::setCallbackPhone(const QString &b) {
1129   writeConfig(caccountgroup, CALLBACK_PHONE_KEY, b);
1130 }
1131
1132 bool PPPData::waitCallback() {
1133   return waitcallback;
1134 }
1135
1136 void PPPData::setWaitCallback(bool value) {
1137   waitcallback = value;
1138 }
1139
1140 const QString PPPData::command_before_connect() {
1141   return readConfig(caccountgroup, BEFORE_CONNECT_KEY);
1142 }
1143
1144
1145 void PPPData::setCommand_before_connect(const QString &n) {
1146   writeConfig(caccountgroup, BEFORE_CONNECT_KEY, n);
1147 }
1148
1149
1150 void PPPData::setStorePassword(bool b) {
1151   writeConfig(caccountgroup, STORE_PASSWORD_KEY, (int)b);
1152 }
1153
1154
1155 const QString PPPData::command_on_connect() {
1156   return readConfig(caccountgroup, COMMAND_KEY);
1157 }
1158
1159
1160 void PPPData::setCommand_on_connect(const QString &n) {
1161   writeConfig(caccountgroup, COMMAND_KEY, n);
1162 }
1163
1164
1165 const QString PPPData::command_on_disconnect() {
1166   return readConfig(caccountgroup, DISCONNECT_COMMAND_KEY);
1167 }
1168
1169
1170 void PPPData::setCommand_on_disconnect(const QString &n) {
1171   writeConfig(caccountgroup, DISCONNECT_COMMAND_KEY, n);
1172 }
1173
1174
1175 const QString PPPData::command_before_disconnect() {
1176   return readConfig(caccountgroup, BEFORE_DISCONNECT_KEY);
1177 }
1178
1179
1180 void PPPData::setCommand_before_disconnect(const QString &n) {
1181   writeConfig(caccountgroup, BEFORE_DISCONNECT_KEY, n);
1182 }
1183
1184
1185 const QString PPPData::ipaddr() {
1186   return readConfig(caccountgroup, IPADDR_KEY);
1187 }
1188
1189
1190 void PPPData::setIpaddr(const QString &n) {
1191   writeConfig(caccountgroup, IPADDR_KEY, n);
1192 }
1193
1194
1195 const QString PPPData::subnetmask() {
1196   return readConfig(caccountgroup, SUBNETMASK_KEY);
1197 }
1198
1199
1200 void PPPData::setSubnetmask(const QString &n) {
1201   writeConfig(caccountgroup, SUBNETMASK_KEY, n);
1202 }
1203
1204
1205 bool PPPData::autoname() {
1206   return (bool) readNumConfig(caccountgroup, AUTONAME_KEY, false);
1207 }
1208
1209
1210 void PPPData::setAutoname(bool set) {
1211   writeConfig(caccountgroup, AUTONAME_KEY, (int) set);
1212 }
1213
1214
1215 bool PPPData::AcctEnabled() {
1216   return (bool) readNumConfig(caccountgroup, ACCTENABLED_KEY, false);
1217 }
1218
1219
1220 void PPPData::setAcctEnabled(bool set) {
1221   writeConfig(caccountgroup, ACCTENABLED_KEY, (int) set);
1222 }
1223
1224
1225 int PPPData::VolAcctEnabled() {
1226   return readNumConfig(caccountgroup, VOLACCTENABLED_KEY, 0);
1227 }
1228
1229
1230 void PPPData::setVolAcctEnabled(int set) {
1231   writeConfig(caccountgroup, VOLACCTENABLED_KEY, set);
1232 }
1233
1234
1235 const QString PPPData::gateway() {
1236   return readConfig(caccountgroup, GATEWAY_KEY);
1237 }
1238
1239
1240 void PPPData::setGateway(const QString &n ) {
1241   writeConfig(caccountgroup, GATEWAY_KEY, n);
1242 }
1243
1244
1245 bool PPPData::defaultroute() {
1246   // default route is by default 'on'.
1247   return (bool) readNumConfig(caccountgroup, DEFAULTROUTE_KEY, true);
1248 }
1249
1250
1251 void PPPData::setDefaultroute(bool set) {
1252   writeConfig(caccountgroup, DEFAULTROUTE_KEY, (int) set);
1253 }
1254
1255
1256 bool PPPData::autoDNS() {
1257   bool set = (bool) readNumConfig(caccountgroup, AUTODNS_KEY, true);
1258   return (set && gpppdata.pppdVersionMin(2, 3, 7));
1259 }
1260
1261
1262 void PPPData::setAutoDNS(bool set) {
1263   writeConfig(caccountgroup, AUTODNS_KEY, (int) set);
1264 }
1265
1266
1267 void PPPData::setExDNSDisabled(bool set) {
1268   writeConfig(caccountgroup, EXDNSDISABLED_KEY, (int) set);
1269 }
1270
1271
1272 bool PPPData::exDNSDisabled() {
1273   return (bool) readNumConfig(caccountgroup, EXDNSDISABLED_KEY,0);
1274 }
1275
1276
1277 QStringList &PPPData::dns() {
1278   static QStringList dnslist;
1279
1280   readListConfig(caccountgroup, DNS_KEY, dnslist);
1281   while(dnslist.count() > MAX_DNS_ENTRIES)
1282     dnslist.removeAll(dnslist.last());
1283
1284   return dnslist;
1285 }
1286
1287
1288 void PPPData::setDns(QStringList &list) {
1289   writeListConfig(caccountgroup, DNS_KEY, list);
1290 }
1291
1292
1293 const QString PPPData::domain() {
1294   return readConfig(caccountgroup, DOMAIN_KEY);
1295 }
1296
1297
1298 void PPPData::setDomain(const QString &n ) {
1299   writeConfig(caccountgroup, DOMAIN_KEY, n);
1300 }
1301
1302
1303 QStringList &PPPData::scriptType() {
1304   static QStringList typelist;
1305
1306   readListConfig(caccountgroup, SCRIPTCOM_KEY, typelist);
1307   while(typelist.count() > MAX_SCRIPT_ENTRIES)
1308     typelist.removeAll(typelist.last());
1309
1310   return typelist;
1311 }
1312
1313
1314 void PPPData::setScriptType(QStringList &list) {
1315   writeListConfig(caccountgroup, SCRIPTCOM_KEY, list);
1316 }
1317
1318
1319 QStringList &PPPData::script() {
1320   static QStringList scriptlist;
1321
1322   readListConfig(caccountgroup, SCRIPTARG_KEY, scriptlist);
1323   while(scriptlist.count() > MAX_SCRIPT_ENTRIES)
1324     scriptlist.removeAll(scriptlist.last());
1325
1326   return scriptlist;
1327 }
1328
1329
1330 void PPPData::setScript(QStringList &list) {
1331   writeListConfig(caccountgroup, SCRIPTARG_KEY, list);
1332 }
1333
1334
1335 const QString PPPData::accountingFile() {
1336   return readConfig(caccountgroup, ACCTFILE_KEY);
1337 }
1338
1339
1340 void PPPData::setAccountingFile(const QString &n) {
1341   writeConfig(caccountgroup, ACCTFILE_KEY, n);
1342 }
1343
1344
1345 const QString PPPData::totalCosts() {
1346   return readConfig(caccountgroup, TOTALCOSTS_KEY);
1347 }
1348
1349
1350 void PPPData::setTotalCosts(const QString &n) {
1351   writeConfig(caccountgroup, TOTALCOSTS_KEY, n);
1352 }
1353
1354
1355 int PPPData::totalBytes() {
1356   return readNumConfig(caccountgroup, TOTALBYTES_KEY, 0);
1357 }
1358
1359 void PPPData::setTotalBytes(int n) {
1360   writeConfig(caccountgroup, TOTALBYTES_KEY, n);
1361 }
1362
1363
1364 QStringList &PPPData::pppdArgument() {
1365   static QStringList arglist;
1366
1367   while(arglist.count() > MAX_PPPD_ARGUMENTS)
1368     arglist.removeAll(arglist.last());
1369   readListConfig(caccountgroup, PPPDARG_KEY, arglist);
1370
1371   return arglist;
1372 }
1373
1374
1375 void PPPData::setpppdArgument(QStringList &args) {
1376   writeListConfig(caccountgroup, PPPDARG_KEY, args);
1377 }
1378
1379
1380 void PPPData::setpppdArgumentDefaults() {
1381   QStringList arg;
1382   setpppdArgument(arg);
1383 }
1384
1385
1386 // graphing widget
1387 void PPPData::setGraphingOptions(bool enable,
1388                                  QColor bg,
1389                                  QColor text,
1390                                  QColor in,
1391                                  QColor out)
1392 {
1393   if(config) {
1394     KConfigGroup group = config->group(GRAPH_GRP);
1395     group.writeEntry(GENABLED, enable);
1396     group.writeEntry(GCOLOR_BG, bg);
1397     group.writeEntry(GCOLOR_TEXT, text);
1398     group.writeEntry(GCOLOR_IN, in);
1399     group.writeEntry(GCOLOR_OUT, out);
1400   }
1401 }
1402
1403 void PPPData::graphingOptions(bool &enable,
1404                               QColor &bg,
1405                               QColor &text,
1406                               QColor &in,
1407                               QColor &out)
1408 {
1409   QColor c;
1410
1411   if(config) {
1412     KConfigGroup group = config->group(GRAPH_GRP);
1413     enable = group.readEntry(GENABLED,true);
1414     c = Qt::white;
1415     bg = group.readEntry(GCOLOR_BG, c);
1416     c = Qt::black;
1417     text = group.readEntry(GCOLOR_TEXT, c);
1418     c = Qt::blue;
1419     in = group.readEntry(GCOLOR_IN, c);
1420     c = Qt::red;
1421     out = group.readEntry(GCOLOR_OUT, c);
1422   }
1423 }
1424
1425
1426 bool PPPData::graphingEnabled() {
1427   if(config) {
1428     return config->group(GRAPH_GRP).readEntry(GENABLED, true);
1429   }
1430   else return true;
1431 }
1432
1433
1434
1435 //
1436 //functions to change/set the child pppd process info
1437 //
1438 bool PPPData::pppdRunning() const {
1439   return pppdisrunning;
1440 }
1441
1442 void PPPData::setpppdRunning(bool set) {
1443   pppdisrunning = set;
1444 }
1445
1446 int PPPData::pppdError() const {
1447   return pppderror;
1448 }
1449
1450 void PPPData::setpppdError(int err) {
1451   pppderror = err;
1452 }
1453
1454
1455 //
1456 // window position
1457 //
1458 void PPPData::winPosConWin(int& p_x, int& p_y) {
1459   QRect desk = KGlobalSettings::splashScreenDesktopGeometry();
1460   p_x = readNumConfig(WINPOS_GRP, WINPOS_CONWIN_X, desk.center().x()-160);
1461   p_y = readNumConfig(WINPOS_GRP, WINPOS_CONWIN_Y, desk.center().y()-55);
1462 }
1463
1464 void PPPData::setWinPosConWin(int p_x, int p_y) {
1465   writeConfig(WINPOS_GRP, WINPOS_CONWIN_X, p_x);
1466   writeConfig(WINPOS_GRP, WINPOS_CONWIN_Y, p_y);
1467 }
1468
1469 void PPPData::winPosStatWin(int& p_x, int& p_y) {
1470   QRect desk = KGlobalSettings::splashScreenDesktopGeometry();
1471   p_x = readNumConfig(WINPOS_GRP, WINPOS_STATWIN_X, desk.center().x()-160);
1472   p_y = readNumConfig(WINPOS_GRP, WINPOS_STATWIN_Y, desk.center().y()-55);
1473 }
1474
1475 void PPPData::setWinPosStatWin(int p_x, int p_y) {
1476   writeConfig(WINPOS_GRP, WINPOS_STATWIN_X, p_x);
1477   writeConfig(WINPOS_GRP, WINPOS_STATWIN_Y, p_y);
1478 }