wifi/interface_wireless.cpp

   1 /***************************************************************************
   2                           stuff.cpp  -  description
   3                              -------------------
   4     begin                : Sun May 6 2001
   5     copyright            : (C) 2001 by Stefan Winter
   6     email                : mail@stefan-winter.de
   7  ***************************************************************************/
   8
   9 /***************************************************************************
  10  *                                                                         *
  11  *   This program is free software; you can redistribute it and/or modify  *
  12  *   it under the terms of the GNU General Public License as published by  *
  13  *   the Free Software Foundation; either version 2 of the License, or     *
  14  *   (at your option) any later version.                                   *
  15  *                                                                         *
  16  ***************************************************************************/
  17
  18 #include "interface_wireless.h"
  19 #include <QDir>
  20 #include <QFile>
  21 #include <QString>
  22 #include <QStringList>
  23 #include <QColor>
  24 #include <QRegExp>
  25
  26 #ifndef WITHOUT_ARTS
  27 #include <arts/artsflow.h>
  28 #include <arts/connect.h>
  29 #include <arts/iomanager.h>
  30 #include <arts/referenceclean.h>
  31 #endif // WITHOUT_ARTS
  32
  33 #include <iostream>
  34 #include <string>
  35 #include <klocale.h>
  36 #include <k3procio.h>
  37 #include <kdebug.h>
  38 #include <arpa/inet.h>
  39
  40 QStringList Interface_wireless::ignoreInterfaces;
  41
  42 Interface_wireless::Interface_wireless ( )
  43 {
  44   has_frequency = false;
  45   frequency = 0;
  46   has_mode = false;
  47   mode = 0;
  48   has_key = 0;
  49   key = "";
  50   key_size = 0;
  51   key_flags = 0;
  52   essid = "";
  53   access_point_address = "";
  54   ip_addresses.clear (  );
  55   bitrate = 0;
  56   socket = -1;
  57   has_range = false;
  58   for ( int i = 0; i < MAX_HISTORY; i++ )
  59     {
  60       sigLevel[i] = -255;
  61       noiseLevel[i] = -255;
  62       qual[i] = -255;
  63       valid[i] = false;
  64     }
  65   current = 0;
  66   sigLevelMin = 32000;
  67   noiseLevelMin = 32000;
  68   sigLevelMax = -32000;
  69   noiseLevelMax = -32000;
  70
  71   already_warned = false;
  72 }
  73
  74 bool
  75 Interface_wireless::get_device_freq ( long &freq )
  76 {
  77   if ( has_frequency )
  78     {
  79       freq = frequency;
  80       return true;
  81     }
  82   else
  83     {
  84       return false;
  85     }
  86 }
  87
  88 bool
  89 Interface_wireless::get_mode ( int &ext_mode )
  90 {
  91   if ( has_mode )
  92     {
  93       ext_mode = mode;
  94       return true;
  95     }
  96   else
  97     {
  98       return false;
  99     }
 100 }
 101
 102 bool
 103 Interface_wireless::get_key ( QString & ext_key, int &ext_size, int &ext_flags )
 104 {
 105   if ( has_key )
 106     {
 107       ext_key = key;
 108       ext_size = key_size;
 109       ext_flags = key_flags;
 110       return true;
 111     }
 112   else
 113     {
 114       return false;
 115     }
 116 }
 117
 118 QString
 119 Interface_wireless::get_essid (  )
 120 {
 121   return essid;
 122 }
 123
 124 bool
 125 Interface_wireless::get_has_txpower (  )
 126 {
 127   return has_txpower;
 128 }
 129
 130 int
 131 Interface_wireless::get_txpower_disabled (  )
 132 {
 133   return txpower_disabled;
 134 }
 135
 136 bool
 137 Interface_wireless::get_AP_info ( QString & mac, QString & /*ip */  )
 138 {
 139   mac = access_point_address;
 140   return false;
 141 }
 142
 143 QStringList
 144 Interface_wireless::get_IP_info (  )
 145 {
 146   return ip_addresses;
 147 }
 148
 149 signed long
 150 Interface_wireless::get_bitrate (  )
 151 {
 152   return bitrate;
 153 }
 154
 155 signed long
 156 Interface_wireless::getMaxBitrate (  )
 157 {
 158   return maxBitrate;
 159 }
 160
 161 QString
 162 Interface_wireless::get_interface_name (  )
 163 {
 164   return interface_name;
 165 }
 166
 167 bool
 168 Interface_wireless::get_current_quality ( int &sig, int &noi, int &qua )
 169 {
 170   if ( valid[current] )
 171     {
 172       sig = sigLevel[current];
 173       noi = noiseLevel[current];
 174       qua = qual[current];
 175       return true;
 176     }
 177   else
 178     return false;
 179 }
 180
 181 CARDSTATES
 182 Interface_wireless::getDeviceState (  )
 183 {
 184   if ( !has_frequency || txpower_disabled )
 185     {
 186       return NO_CARD;
 187     }
 188   else if ( mode == 1 )
 189     {
 190       return AD_HOC;
 191     }
 192   else if ( qual[current] == 0 )
 193     {
 194       return NO_CONNECTION;
 195     }
 196   else if ( qual[current] > 0 )
 197     {
 198       return AP_CONNECT;
 199     }
 200   else
 201     return NO_CARD;
 202 }
 203
 204 #ifndef WITHOUT_ARTS
 205
 206 void
 207 sine_wave ( double frequency )
 208 {
 209   using namespace Arts;
 210   StdIOManager *limiter = new StdIOManager;
 211   Dispatcher dispatcher ( limiter );
 212   MyTimeNotify *zeit = new MyTimeNotify ( &dispatcher );
 213   Synth_FREQUENCY freq;
 214   Synth_WAVE_SIN sin;
 215   Synth_PLAY play;
 216   setValue ( freq, frequency );
 217   connect ( freq, sin );
 218   connect ( sin, play, "invalue_left" );
 219   freq.start (  );
 220   sin.start (  );
 221   play.start (  );
 222   limiter->addTimer ( 240, zeit );
 223   dispatcher.run (  );
 224   play.stop (  );
 225   sin.stop (  );
 226   freq.stop (  );
 227 }
 228
 229 void
 230 MyTimeNotify::notifyTime (  )
 231 {
 232   test->terminate (  );
 233 }
 234
 235 #endif
 236
 237 QString
 238 whois ( const char *MAC_ADR, QStringList APList )
 239 {
 240   for ( QStringList::Iterator it = APList.begin (  ); it != APList.end (  ); ( it++ )++ )
 241     {
 242       if ( ( *it ) == ( QString ) MAC_ADR )
 243         return *( ++it );
 244     }
 245   return i18n ( "UNKNOWN" );
 246 }
 247
 248 int
 249 NetworkParameterDataModel::rowCount ( const QModelIndex & parent ) const
 250 {
 251   return dataContainer.size (  );
 252 }
 253
 254 int
 255 NetworkParameterDataModel::columnCount ( const QModelIndex & parent ) const
 256 {
 257   return 4;
 258 }
 259
 260 QVariant
 261 NetworkParameterDataModel::data ( const QModelIndex & index, int role ) const
 262 {
 263   if ( index.row (  ) >= dataContainer.size (  ) )
 264     return QVariant (  );
 265
 266   if ( role != Qt::DisplayRole && role != Qt::BackgroundColorRole )
 267     return QVariant (  );
 268
 269   if ( role == Qt::DisplayRole )
 270     switch ( index.column (  ) )
 271       {
 272       case 0:
 273         return dataContainer[index.row (  )].ssid;
 274       case 1:
 275         return dataContainer[index.row (  )].mode;
 276       case 2:
 277         return ( QString ( "%1" ) ).arg ( dataContainer[index.row (  )].quality );
 278       case 3:
 279         if ( dataContainer[index.row (  )].encryption == "off" )
 280           return QString ( i18n ( "off" ) );
 281         if ( dataContainer[index.row (  )].encryption == "on" )
 282           return QString ( i18n ( "on" ) );
 283         return dataContainer[index.row (  )].encryption;
 284       default:
 285         return QVariant (  );
 286       }
 287
 288   if ( role == Qt::BackgroundColorRole )
 289     switch ( index.column (  ) )
 290       {
 291       case 0:
 292         return ( dataContainer[index.row (  )].ssid == "" ? QColor ( 255, 255, 0 ) : QColor ( 0, 128, 0 ) );
 293       case 1:
 294         return QColor ( 0, 128, 0 );
 295       case 2:
 296         return QColor ( 0, 128, 0 );
 297       case 3:
 298         if ( dataContainer[index.row (  )].encryption == "on" )
 299           return QColor ( 255, 255, 0 );
 300         if ( checkWEP ( dataContainer[index.row (  )].encryption ) == NONE )
 301           return QColor ( 0, 128, 0 );
 302         if ( checkWEP ( dataContainer[index.row (  )].encryption ) == VALID_HEX ||
 303              checkWEP ( dataContainer[index.row (  )].encryption ) == VALID_STRING )
 304           return QColor ( 0, 128, 0 );
 305         if ( checkWEP ( dataContainer[index.row (  )].encryption ) == INVALID )
 306           return QColor ( 255, 0, 0 );
 307         return QVariant (  );
 308       default:
 309         return QVariant (  );
 310       }
 311
 312   // we will never get here, but let's make the compiler happy
 313   return QVariant ();
 314 }
 315
 316 WEP_KEY
 317 NetworkParameterDataModel::checkWEP ( const QString & key ) const
 318 {
 319
 320   kDebug (  ) << "In checkWEP()\n";
 321   if ( key == "off" )
 322     return NONE;
 323
 324   if ( key.length (  ) == 5 )
 325     return VALID_STRING;
 326   if ( key.length (  ) == 13 )
 327     return VALID_STRING;
 328   if ( key.length (  ) == 32 )
 329     return VALID_STRING;
 330
 331   // a more restrictive check: is it really a hex number?
 332
 333   QRegExp hexNumber ( "[A-F,a-f,0-9]*" );
 334
 335   if ( key.length (  ) == 10 && hexNumber.exactMatch ( key ) )
 336     return VALID_HEX;
 337   if ( key.length (  ) == 26 && hexNumber.exactMatch ( key ) )
 338     return VALID_HEX;
 339   if ( key.length (  ) == 64 && hexNumber.exactMatch ( key ) )
 340     return VALID_HEX;
 341
 342   return INVALID;
 343 }
 344
 345
 346 QVariant
 347 NetworkParameterDataModel::data ( int row, int col )
 348 {
 349   return data ( createIndex ( row, col, 0 ), Qt::DisplayRole );
 350 }
 351
 352 QVariant
 353 NetworkParameterDataModel::headerData ( int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const
 354 {
 355   if ( orientation == Qt::Vertical )
 356     return QVariant (  );
 357   switch ( section )
 358     {
 359     case 0:
 360       return i18n ( "SSID" );
 361       break;
 362     case 1:
 363       return i18n ( "Mode" );
 364       break;
 365     case 2:
 366       return i18n ( "Quality" );
 367       break;
 368     case 3:
 369       return i18n ( "Encryption" );
 370       break;
 371     case 4:
 372       return "reserved";
 373       break;
 374     default:
 375       return "???";
 376       break;
 377     }
 378 }
 379
 380 QVariant
 381 NetworkParameterDataModel::headerData ( int col )
 382 {
 383   return headerData ( col, Qt::Horizontal );
 384 }
 385
 386 bool
 387 NetworkParameterDataModel::setData ( const QModelIndex & index, const QVariant & value, int role = Qt::EditRole )
 388 {
 389   if ( role != Qt::EditRole )
 390     return false;
 391   if ( dataContainer.size (  ) == 0 )
 392     insertColumns ( 0, 4 );
 393   for ( int i = dataContainer.size (  ); i <= index.row (  ); i++ )
 394     {
 395       kDebug (  ) << "intialising intermediate row " << i << ".\n";
 396       struct NetworkParameterData *newRow = new NetworkParameterData;
 397       newRow->ssid = "";
 398       newRow->mode = "";
 399       newRow->quality = 0;
 400       newRow->encryption = "off";
 401       dataContainer.append ( *newRow );
 402       insertRow ( i );
 403     }
 404   kDebug (  ) << "Setting value at row " << index.row (  ) << ", col " << index.column (  ) << " to " << value.
 405     toString (  ) << ".\n";
 406
 407   switch ( index.column (  ) )
 408     {
 409     case 0:
 410       dataContainer[index.row (  )].ssid = value.toString (  );
 411       break;
 412     case 1:
 413       dataContainer[index.row (  )].mode = value.toString (  );
 414       break;
 415     case 2:
 416       dataContainer[index.row (  )].quality = value.toString (  ).toInt (  );
 417       break;
 418     case 3:
 419       dataContainer[index.row (  )].encryption = value.toString (  );
 420       break;
 421     default:
 422       return false;
 423     }
 424   // emit dataChanged(index,index);
 425   return true;
 426 }
 427
 428 void
 429 NetworkParameterDataModel::gotFinishedIndicator (  )
 430 {
 431   emit finishedScanning (  );
 432 }
 433
 434 bool
 435 NetworkParameterDataModel::setData ( int row, int col, const QVariant & value )
 436 {
 437   return setData ( createIndex ( row, col ), value );
 438 }
 439
 440 Qt::ItemFlags NetworkParameterDataModel::flags ( const QModelIndex & index ) const
 441 {
 442   if ( index.row (  ) >= dataContainer.size (  ) )
 443     return 0;
 444   if ( index.column (  ) > 3 )
 445     return 0;
 446   if ( index.column (  ) != 0 && index.column (  ) != 3 )
 447     return Qt::ItemIsSelectable;
 448   if ( index.column (  ) == 0 && !dataContainer[index.row (  )].ssid.isEmpty() )
 449     return Qt::ItemIsSelectable;
 450   if ( index.column (  ) == 3 && dataContainer[index.row (  )].encryption == "off" )
 451     return Qt::ItemIsSelectable;
 452   return Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable;
 453 }
 454
 455 #include "interface_wireless.moc"