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