kwifimanager_kcmodule.cpp

Linux/Unix下无限网卡配置和管理程序

/***************************************************************************
                          kwifimanager_kcmodule.cpp  -  description
                             -------------------
    begin                : Die Okt  2 19:41:16 CEST 2001
    copyright            : (C) 2001 by Stefan Winter
    email                : [e-mail]
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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 <qlayout.h>
#include <qlineedit.h>
#include <qpushbutton.h>
#include <qcheckbox.h>
#include <qradiobutton.h>
#include <qgroupbox.h>
#include <qbuttongroup.h>
#include <qlabel.h>
#include <qtabwidget.h>
#include <qcombobox.h>
#include <qdir.h>

#include <klocale.h>
// #include <kglobal.h>
#include <kmessagebox.h>
#include <ksimpleconfig.h>
#include <kprocess.h>
#include <kstandarddirs.h>

#include <kcmodule.h>
#include <kgenericfactory.h>

#include "kwifimanager_kcmodule.h"
#include <stdlib.h>
#include <iostream>
#include <fstream>

/* factory function for module startup, new style */

class KWifimanager_KCModule;

typedef KGenericFactory<KWifimanager_KCModule, QWidget > KWiFiFactory;



KWifimanager_ConfigWidget2::KWifimanager_ConfigWidget2 (KWifimanager_KCModule * parent, const char *name = 0L):
QWidget (parent, name)
{
  myParent=parent;
  QGridLayout *organizer = new QGridLayout (this);
  activate = new QCheckBox ("Load preset configuration on Control Center Module startup?", this);
  activate->setChecked (KWifimanager_KCModule::use_preset_config);
  config_to_activate = new QComboBox (this);
  config_to_activate->insertItem ("Config 1");
  config_to_activate->insertItem ("Config 2");
  config_to_activate->insertItem ("Config 3");
  config_to_activate->insertItem ("Config 4");
  config_to_activate->setCurrentItem (KWifimanager_KCModule::preset_config_to_use);
  organizer->addMultiCellWidget (activate, 0, 0, 0, 2);
  myLabel = new QLabel ("Configuration to load: ", this);
  actButton = new QPushButton ("Activate configuration", this);
  myNextLabel = new QLabel ("Settings apply to interface: ", this);
  interfaceselector = new QLineEdit (KWifimanager_KCModule::interface_to_use, this);
  autodetect = new QPushButton ("Autodetect interface", this);
  organizer->addRowSpacing (1, config_to_activate->sizeHint ().height ());
  organizer->addWidget (myLabel, 1, 0);
  organizer->addWidget (config_to_activate, 1, 1);
  organizer->addWidget (actButton, 1, 3);
  organizer->addWidget (myNextLabel, 2, 0);
  organizer->addWidget (interfaceselector, 2, 1);
  organizer->addWidget (autodetect, 2, 3);
  organizer->addColSpacing (2, 10);
  setFixedSize (sizeHint ());
  connect (autodetect, SIGNAL (clicked ()), this, SLOT (slotAutodetectInterface ()));
  connect (activate, SIGNAL (clicked ()), this, SLOT (slotUserChangedSomething ()));

  connect (actButton, SIGNAL (clicked ()), this, SLOT (slotActivateNow ()));
  connect (config_to_activate, SIGNAL (activated (int)), this, SLOT (slotUserChangedSomething ()));
  connect (interfaceselector, SIGNAL (textChanged (const QString &)), this, SLOT (slotUserChangedSomething ()));
};

void
KWifimanager_ConfigWidget2::slotActivateNow ()
{
  bool temp_use_preset = KWifimanager_KCModule::use_preset_config;
  int temp_preset_config = KWifimanager_KCModule::preset_config_to_use;
  QString temp_interface = KWifimanager_KCModule::interface_to_use;
  saveData ();
  myParent->save();
  KStandardDirs finder;
  QString kdedir = finder.findResourceDir ("data", "kwifimanager/config/kwifimanagerrc");
  (kdedir = "") ? kdedir = finder.findResourceDir ("data", "kwifimanager/pics/offline.png") + "kwifimanager/config/" : kdedir += "kwifimanager/config/";
  QString kde = kdedir;
  KSimpleConfig *conffile = new KSimpleConfig (kde + "kwifimanagerrc", false);
  conffile->setGroup ("General");
  conffile->writeEntry ("Use preset configuration", KWifimanager_KCModule::use_preset_config);
  conffile->writeEntry ("Configuration to use", KWifimanager_KCModule::preset_config_to_use);
  conffile->writeEntry ("Interface", KWifimanager_KCModule::interface_to_use);
  conffile->sync ();
  KWifimanager_KCModule::init ();
  KWifimanager_KCModule::changeConfig (KWifimanager_KCModule::preset_config_to_use + 1, iw_sockets_open (), KWifimanager_KCModule::interface_to_use);
  conffile->writeEntry ("Use preset configuration", temp_use_preset);
  conffile->writeEntry ("Configuration to use", temp_preset_config);
  conffile->writeEntry ("Interface", temp_interface);
  conffile->sync ();
};

void
KWifimanager_ConfigWidget2::saveData ()
{
  KWifimanager_KCModule::use_preset_config = activate->isChecked ();
  KWifimanager_KCModule::preset_config_to_use = config_to_activate->currentItem ();
  KWifimanager_KCModule::interface_to_use = interfaceselector->text ();
};

void
KWifimanager_ConfigWidget2::slotAutodetectInterface ()
{
  deviceinfo *detect = new deviceinfo;
  detect->skfd = iw_sockets_open ();
  detect->used_interface = "";
  interfaceselector->setText (return_info (detect, false));
};

void
KWifimanager_ConfigWidget2::slotUserChangedSomething ()
{
  emit changed ();
};

void
KWifimanager_ConfigWidget::saveData (int which_one)
{
  KWifimanager_KCModule::configs->net_name[which_one] = network_name->text ();
  KWifimanager_KCModule::configs->script_name[which_one] = script_name->text ();
  mangroup->id (mangroup->selected ()) == 0 ? KWifimanager_KCModule::configs->managed[which_one] = true : KWifimanager_KCModule::configs->managed[which_one] = false;
  KWifimanager_KCModule::configs->crypto_enabled[which_one] = use_crypto->isChecked ();
  KWifimanager_KCModule::configs->active_crypto_key[which_one] = crypto_number->text ().toInt ();
  KWifimanager_KCModule::configs->active_key_string[which_one] = crypto_number->text ();
  KWifimanager_KCModule::configs->crypto1[which_one] = crypto1->text ();
  KWifimanager_KCModule::configs->crypto2[which_one] = crypto2->text ();
  KWifimanager_KCModule::configs->crypto3[which_one] = crypto3->text ();
  KWifimanager_KCModule::configs->crypto4[which_one] = crypto4->text ();
  KWifimanager_KCModule::configs->crypto_is_string1[which_one] = ct1->isChecked ();
  KWifimanager_KCModule::configs->crypto_is_string2[which_one] = ct2->isChecked ();
  KWifimanager_KCModule::configs->crypto_is_string3[which_one] = ct3->isChecked ();
  KWifimanager_KCModule::configs->crypto_is_string4[which_one] = ct4->isChecked ();
  switch (openquery->id (openquery->selected ()))
    {
    case 0:
      KWifimanager_KCModule::configs->crypto_mode[which_one] = OPEN;
      break;
    case 1:
      KWifimanager_KCModule::configs->crypto_mode[which_one] = RESTRICTED;
      break;
    };
  KWifimanager_KCModule::configs->pm_enabled[which_one] = pm->isChecked ();
  KWifimanager_KCModule::configs->sleep_time[which_one] = sleeptime->text ().toInt ();
  KWifimanager_KCModule::configs->sleep_time_string[which_one] = sleeptime->text ();
  KWifimanager_KCModule::configs->wake_time[which_one] = waketime->text ().toInt ();
  KWifimanager_KCModule::configs->wake_time_string[which_one] = waketime->text ();
  switch (bitrate->id (bitrate->selected ()))
    {
    case 0:
      KWifimanager_KCModule::configs->bitrate[which_one] = AUTO;
      break;
    case 1:
      KWifimanager_KCModule::configs->bitrate[which_one] = M1;
      break;
    case 2:
      KWifimanager_KCModule::configs->bitrate[which_one] = M2;
      break;
    case 3:
      KWifimanager_KCModule::configs->bitrate[which_one] = M55;
      break;
    case 4:
      KWifimanager_KCModule::configs->bitrate[which_one] = M11;
      break;
    };
  switch (receive->id (receive->selected ()))
    {
    case 0:
      KWifimanager_KCModule::configs->packet[which_one] = UNI;
      break;
    case 1:
      KWifimanager_KCModule::configs->packet[which_one] = MULTI;
      break;
    case 2:
      KWifimanager_KCModule::configs->packet[which_one] = BOTH;
      break;
    };
}

void
KWifimanager_ConfigWidget::slotUserChangedSomething ()
{
  emit changed ();
};

void
KWifimanager_ConfigWidget::slotToggleCrypto (bool aktiv)
{
  if (aktiv)
    {
      crypto_number->show ();
      openquery->show ();
      cryptobox->show ();
      cryptlabel->show ();
    }
  else
    {
      crypto_number->hide ();
      openquery->hide ();
      cryptobox->hide ();
      cryptlabel->hide ();
    };
};

void
KWifimanager_ConfigWidget::slotTogglePower (bool aktiv)
{
  if (aktiv)
    {
      sleeptime->show ();
      waketime->show ();
      receive->show ();
      sleep->show ();
      wake->show ();
    }
  else
    {
      sleeptime->hide ();
      waketime->hide ();
      receive->hide ();
      sleep->hide ();
      wake->hide ();
    };
}

KWifimanager_ConfigWidget::KWifimanager_ConfigWidget (int number, QWidget * parent, const char *name = 0L):
QWidget (parent, name)
{
  geo = new QGridLayout (this, 1, 1, 20, 0);
  network_name = new QLineEdit (KWifimanager_KCModule::configs->net_name[number], this);
  network_name->setMaxLength (200);
  network_name->setFixedSize (150, 20);
  script_name = new QLineEdit (KWifimanager_KCModule::configs->script_name[number], this);
  mangroup = new QButtonGroup (2, Qt::Horizontal, i18n ("Operation Mode"), this);
  mangroup->setMaximumHeight(50);
  managed = new QRadioButton (i18n ("infrastructure"), mangroup);
  ad_hoc = new QRadioButton (i18n ("peer-to-peer"), mangroup);
  KWifimanager_KCModule::configs->managed[number] == true ? mangroup->setButton (0) : mangroup->setButton (1);
  cryptobox = new QGroupBox (3, Qt::Horizontal, i18n ("Crypto keys"), this);
  ct1 = new QCheckBox (i18n ("String?"), cryptobox);
  ct1->setChecked (KWifimanager_KCModule::configs->crypto_is_string1[number]);
  crypto1 = new QLineEdit (KWifimanager_KCModule::configs->crypto1[number], cryptobox);
  crypto1->setEchoMode(QLineEdit::Password);
  crypto1->setFixedSize (100, 20);
  new QLabel ("1", cryptobox);
  ct2 = new QCheckBox (i18n ("String?"), cryptobox);
  ct2->setChecked (KWifimanager_KCModule::configs->crypto_is_string2[number]);
  crypto2 = new QLineEdit (KWifimanager_KCModule::configs->crypto2[number], cryptobox);
  crypto2->setEchoMode(QLineEdit::Password);
  crypto2->setFixedSize (100, 20);
  new QLabel ("2", cryptobox);
  ct3 = new QCheckBox (i18n ("String?"), cryptobox);
  ct3->setChecked (KWifimanager_KCModule::configs->crypto_is_string3[number]);
  crypto3 = new QLineEdit (KWifimanager_KCModule::configs->crypto3[number], cryptobox);
  crypto3->setEchoMode(QLineEdit::Password);
  crypto3->setFixedSize (100, 20);
  new QLabel ("3", cryptobox);
  ct4 = new QCheckBox (i18n ("String?"), cryptobox);
  ct4->setChecked (KWifimanager_KCModule::configs->crypto_is_string4[number]);
  crypto4 = new QLineEdit (KWifimanager_KCModule::configs->crypto4[number], cryptobox);
  crypto4->setEchoMode(QLineEdit::Password);
  crypto4->setFixedSize (100, 20);
  new QLabel ("4", cryptobox);
  bitrate = new QButtonGroup (2, Qt::Horizontal, i18n ("Speed setting"), this);
  MXA = new QRadioButton (i18n ("auto"), bitrate);
  MX1 = new QRadioButton (i18n ("1 MBit/s"), bitrate);
  MX2 = new QRadioButton (i18n ("2 MBit/s"), bitrate);
  MX55 = new QRadioButton (i18n ("5.5 MBit/s"), bitrate);
  MX11 = new QRadioButton (i18n ("11 MBit/s"), bitrate);
  bitrate->setButton (KWifimanager_KCModule::configs->bitrate[number]);
  pm = new QCheckBox (i18n ("Enable Power Management"), this);
  pm->setChecked (KWifimanager_KCModule::configs->pm_enabled[number]);
  sleep = new QLabel (i18n ("Sleep duration (ms)"), this);
  wake = new QLabel (i18n ("Awaken time (ms)"), this);
  sleeptime = new QLineEdit (this);
  sleeptime->setFixedSize (60, 20);
  sleeptime->setText (KWifimanager_KCModule::configs->sleep_time_string[number]);
  waketime = new QLineEdit (this);
  waketime->setFixedSize (60, 20);
  waketime->setText (KWifimanager_KCModule::configs->wake_time_string[number]);
  receive = new QButtonGroup (1, Qt::Horizontal, i18n ("Receive packets"), this);
  rec_uni = new QRadioButton (i18n ("Unicast only"), receive);
  rec_multi = new QRadioButton (i18n ("Multi/Broadcast only"), receive);
  rec_both = new QRadioButton (i18n ("Both"), receive);
  receive->setButton (KWifimanager_KCModule::configs->packet[number]);
  use_crypto = new QCheckBox (i18n ("Use cryptography?"), this);
  use_crypto->setChecked (KWifimanager_KCModule::configs->crypto_enabled[number]);
  cryptlabel = new QLabel (i18n ("Key to use"), this);
  crypto_number = new QLineEdit (this);
  crypto_number->setMaxLength (1);
  crypto_number->setFixedSize (20, 20);
  crypto_number->setText (KWifimanager_KCModule::configs->active_key_string[number]);
  openquery = new QButtonGroup (2, Qt::Horizontal, i18n ("Crypto mode"), this);
  open = new QRadioButton (i18n ("Open mode"), openquery);
  rest = new QRadioButton (i18n ("Restricted mode"), openquery);
  openquery->setButton (KWifimanager_KCModule::configs->crypto_mode[number]);
  QLabel *sn = new QLabel (i18n ("Execute script on connect:"), this);
  QLabel *nn = new QLabel (i18n ("Network name:"), this);
  geo->addWidget (nn, 0, 0);
  geo->addWidget (network_name, 0, 1);
  geo->addMultiCellWidget (mangroup, 1, 1, 0, 1);
  geo->addWidget (sn, 2, 0);
  geo->addMultiCellWidget (script_name, 2, 2, 1, 4);
  geo->addMultiCellWidget (use_crypto, 4, 4, 0, 1);
  geo->addWidget (cryptlabel, 5, 0);
  geo->addWidget (crypto_number, 5, 1);
  geo->addMultiCellWidget (openquery, 6, 6, 0, 1);
  geo->addMultiCellWidget (cryptobox, 7, 7, 0, 1);
  geo->addMultiCellWidget (bitrate, 0, 1, 3, 4);
  geo->addMultiCellWidget (pm, 4, 4, 3, 4);
  geo->addWidget (sleep, 5, 3);
  geo->addWidget (sleeptime, 5, 4);
  geo->addWidget (wake, 6, 3);
  geo->addWidget (waketime, 6, 4);
  geo->addMultiCellWidget (receive, 7, 7, 3, 4);
  geo->addColSpacing (2, 25);
  geo->addColSpacing (4, bitrate->sizeHint ().width () - sleep->sizeHint ().width ());
  geo->addRowSpacing (3, 25);
  int temp = crypto_number->sizeHint ().height ();
  if (use_crypto->sizeHint ().height () > temp)
    temp = use_crypto->sizeHint ().height ();
  geo->addRowSpacing (5, temp);
  temp = openquery->sizeHint ().height ();
  geo->addRowSpacing (6, temp);
  temp = cryptobox->sizeHint ().height ();
  geo->addRowSpacing (7, temp);
  temp = cryptobox->sizeHint ().width () - cryptlabel->sizeHint ().width ();
  geo->addColSpacing (1, temp);
  geo->addColSpacing (0, cryptlabel->sizeHint ().width ());
  geo->addColSpacing (3, sleep->sizeHint ().width ());
  geo->addColSpacing (4, bitrate->sizeHint ().width () - sleep->sizeHint ().width ());
  bitrate->setMaximumSize (bitrate->sizeHint ().width (), bitrate->sizeHint ().height ());
  connect (use_crypto, SIGNAL (toggled (bool)), this, SLOT (slotToggleCrypto (bool)));
  slotToggleCrypto (use_crypto->isChecked ());
  connect (pm, SIGNAL (toggled (bool)), this, SLOT (slotTogglePower (bool)));
  slotTogglePower (pm->isChecked ());
  connect (script_name, SIGNAL (textChanged (const QString &)), this, SLOT (slotUserChangedSomething ()));
  connect (network_name, SIGNAL (textChanged (const QString &)), this, SLOT (slotUserChangedSomething ()));
  connect (mangroup, SIGNAL (clicked (int)), this, SLOT (slotUserChangedSomething ()));
  connect (bitrate, SIGNAL (clicked (int)), this, SLOT (slotUserChangedSomething ()));
  connect (pm, SIGNAL (clicked ()), this, SLOT (slotUserChangedSomething ()));
  connect (use_crypto, SIGNAL (clicked ()), this, SLOT (slotUserChangedSomething ()));
  connect (openquery, SIGNAL (clicked (int)), this, SLOT (slotUserChangedSomething ()));
  connect (ct1, SIGNAL (clicked ()), this, SLOT (slotUserChangedSomething ()));
  connect (ct2, SIGNAL (clicked ()), this, SLOT (slotUserChangedSomething ()));
  connect (ct3, SIGNAL (clicked ()), this, SLOT (slotUserChangedSomething ()));
  connect (ct4, SIGNAL (clicked ()), this, SLOT (slotUserChangedSomething ()));
  connect (crypto1, SIGNAL (textChanged (const QString &)), this, SLOT (slotUserChangedSomething ()));
  connect (crypto2, SIGNAL (textChanged (const QString &)), this, SLOT (slotUserChangedSomething ()));
  connect (crypto3, SIGNAL (textChanged (const QString &)), this, SLOT (slotUserChangedSomething ()));
  connect (crypto4, SIGNAL (textChanged (const QString &)), this, SLOT (slotUserChangedSomething ()));
  connect (crypto_number, SIGNAL (textChanged (const QString &)), this, SLOT (slotUserChangedSomething ()));
  connect (sleeptime, SIGNAL (textChanged (const QString &)), this, SLOT (slotUserChangedSomething ()));
  connect (waketime, SIGNAL (textChanged (const QString &)), this, SLOT (slotUserChangedSomething ()));
  connect (receive, SIGNAL (clicked (int)), this, SLOT (slotUserChangedSomething ()));

};

configuration_data *
  KWifimanager_KCModule::configs =
  new
  configuration_data;
bool KWifimanager_KCModule::use_preset_config = false;
int
  KWifimanager_KCModule::preset_config_to_use =
  1;

int
set_info (int skfd,		/* The socket */
	  const char *args[],	/* Command line args */
	  int count,		/* Args count */
	  const char *ifname)	/* Dev name */
{

  const char *
    operation_mode[] = {
    "Auto",
    "Ad-Hoc",
    "Managed",
    "Master",
    "Repeater",
    "Secondary"
  };

  struct iwreq
    wrq;
  int
    i;

  /* Set dev name */
  strncpy (wrq.ifr_name, ifname, IFNAMSIZ);

  /* if nothing after the device name */
  if (count < 1)
    iw_usage ();

  /* The other args on the line specify options to be set... */
  for (i = 0; i < count; i++)
    {