lib/python/Plugins/SystemPlugins/WirelessLan/iwlibs.py

   1 # -*- coding: ISO-8859-1 -*-
   2 # python-wifi -- a wireless library to access wireless cards via python
   3 # Copyright (C) 2004, 2005, 2006 Róman Joost
   4 #
   5 # Contributions from:
   6 #   Mike Auty <m.auty@softhome.net> (Iwscanresult, Iwscan)
   7 #
   8 #    This library is free software; you can redistribute it and/or
   9 #    modify it under the terms of the GNU Lesser General Public License
  10 #    as published by the Free Software Foundation; either version 2.1 of
  11 #    the License, or (at your option) any later version.
  12 #
  13 #    This library is distributed in the hope that it will be useful, but
  14 #    WITHOUT ANY WARRANTY; without even the implied warranty of
  15 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16 #    Lesser General Public License for more details.
  17 #
  18 #    You should have received a copy of the GNU Lesser General Public
  19 #    License along with this library; if not, write to the Free Software
  20 #    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  21 #    USA
  22
  23 from struct import pack as struct_pack, \
  24         unpack as struct_unpack, \
  25         calcsize as struct_calcsize
  26
  27 from array import array
  28 from math import ceil, log10
  29 from fcntl import ioctl
  30 from socket import AF_INET, SOCK_DGRAM, socket
  31 from time import sleep
  32 from re import compile
  33
  34 from flags import *
  35
  36 def getNICnames():
  37     """ extract wireless device names of /proc/net/wireless
  38
  39         returns empty list if no devices are present
  40
  41         >>> getNICnames()
  42         ['eth1', 'wifi0']
  43     """
  44     device = compile('[a-z]+[0-9]+')
  45     ifnames = []
  46
  47     f = open('/proc/net/wireless', 'r')
  48     data = f.readlines()
  49     for line in data:
  50         try:
  51             ifnames.append(device.search(line).group())
  52         except AttributeError:
  53             pass
  54     # if we couldn't lookup the devices, try to ask the kernel
  55     if ifnames == []:
  56         ifnames = getConfiguredNICnames()
  57
  58     return ifnames
  59
  60 def getConfiguredNICnames():
  61     """get the *configured* ifnames by a systemcall
  62
  63        >>> getConfiguredNICnames()
  64        []
  65     """
  66     iwstruct = Iwstruct()
  67     ifnames = []
  68     buff = array('c', '\0'*1024)
  69     caddr_t, length = buff.buffer_info()
  70     s = iwstruct.pack('iP', length, caddr_t)
  71     try:
  72         result = iwstruct._fcntl(SIOCGIFCONF, s)
  73     except IOError, (i, e):
  74         return i, e
  75
  76     # get the interface names out of the buffer
  77     for i in range(0, 1024, 32):
  78         ifname = buff.tostring()[i:i+32]
  79         ifname = struct_unpack('32s', ifname)[0]
  80         ifname = ifname.split('\0', 1)[0]
  81         if ifname:
  82             # verify if ifnames are really wifi devices
  83             wifi = Wireless(ifname)
  84             result = wifi.getAPaddr()
  85             if result[0] == 0:
  86                 ifnames.append(ifname)
  87
  88     return ifnames
  89
  90 def makedict(**kwargs):
  91     return kwargs
  92
  93
  94 class Wireless(object):
  95     """Access to wireless interfaces"""
  96
  97     def __init__(self, ifname):
  98         self.sockfd = socket(AF_INET, SOCK_DGRAM)
  99         self.ifname = ifname
 100         self.iwstruct = Iwstruct()
 101
 102     def getAPaddr(self):
 103         """ returns accesspoint mac address
 104
 105             >>> from iwlibs import Wireless, getNICnames
 106             >>> ifnames = getNICnames()
 107             >>> ifnames
 108             ['eth1', 'wifi0']
 109             >>> wifi = Wireless(ifnames[0])
 110             >>> wifi.getAPaddr()
 111             '00:0D:88:8E:4E:93'
 112
 113             Test with non-wifi card:
 114             >>> wifi = Wireless('eth0')
 115             >>> wifi.getAPaddr()
 116             (95, 'Operation not supported')
 117
 118             Test with non-existant card:
 119             >>> wifi = Wireless('eth2')
 120             >>> wifi.getAPaddr()
 121             (19, 'No such device')
 122         """
 123         buff, s = self.iwstruct.pack_wrq(32)
 124         i, result = self.iwstruct.iw_get_ext(self.ifname,
 125                                              SIOCGIWAP,
 126                                              data=s)
 127         if i > 0:
 128             return result
 129
 130         return self.iwstruct.getMAC(result)
 131
 132     def getBitrate(self):
 133         """returns device currently set bit rate
 134
 135             >>> from iwlibs import Wireless
 136             >>> wifi = Wireless('eth1')
 137             >>> wifi.getBitrate()
 138             '11 Mb/s'
 139         """
 140         i, result = self.iwstruct.iw_get_ext(self.ifname,
 141                                             SIOCGIWRATE)
 142         if i > 0:
 143             return result
 144         iwfreq = Iwfreq(result)
 145         return iwfreq.getBitrate()
 146
 147     def getBitrates(self):
 148         """returns the number of available bitrates for the device
 149
 150             >>> from iwlibs import Wireless
 151             >>> wifi = Wireless('eth1')
 152             >>> num, rates = wifi.getBitrates()
 153             >>> num == len(rates)
 154             True
 155         """
 156         range = Iwrange(self.ifname)
 157         if range.errorflag:
 158             return (range.errorflag, range.error)
 159         return (range.num_bitrates, range.bitrates)
 160
 161     def getChannelInfo(self):
 162         """returns the number of channels and available frequency for
 163            the device
 164
 165             >>> from iwlibs import Wireless
 166             >>> wifi = Wireless('eth1')
 167             >>> num, rates = wifi.getChannelInfo()
 168             >>> num == len(rates)
 169             True
 170             """
 171         range = Iwrange(self.ifname)
 172         if range.errorflag:
 173             return (range.errorflag, range.error)
 174         return (range.num_channels, range.frequencies)
 175
 176     def getEssid(self):
 177         """get essid information
 178
 179             >>> from iwlibs import Wireless
 180             >>> wifi = Wireless('eth1')
 181             >>> wifi.getEssid()
 182             'romanofski'
 183         """
 184         essid = ""
 185         buff, s = self.iwstruct.pack_wrq(32)
 186         i, result = self.iwstruct.iw_get_ext(self.ifname,
 187                                              SIOCGIWESSID,
 188                                              data=s)
 189         if i > 0:
 190             return result
 191         str = buff.tostring()
 192         return str.strip('\x00')
 193
 194     def setEssid(self, essid):
 195         """set essid """
 196         raise NotImplementedError
 197         if len(essid) > IW_ESSID_MAX_SIZE:
 198             return "essid to big"
 199         buff, s = self.iwstruct.pack_test(essid, 32)
 200         i, result = self.iwstruct.iw_get_ext(self.ifname,
 201                                              SIOCSIWESSID,
 202                                              data=s)
 203         if i > 0:
 204             return result
 205
 206     def getEncryption(self):
 207         """get encryption information which is probably a string of '*',
 208         'open', 'private'
 209
 210             as a normal user, you will get a 'Operation not permitted'
 211             error:
 212
 213             >>> from iwlibs import Wireless
 214             >>> wifi = Wireless('eth1')
 215             >>> wifi.getEncryption()
 216             (1, 'Operation not permitted')
 217         """
 218         iwpoint = Iwpoint(self.ifname)
 219         if iwpoint.errorflag:
 220             return (iwpoint.errorflag, iwpoint.error)
 221         return iwpoint.getEncryptionKey()
 222
 223     def getFragmentation(self):
 224         """returns fragmentation threshold
 225
 226            It depends on what the driver says. If you have fragmentation
 227            threshold turned on, you'll get an int. If it's turned of
 228            you'll get a string: 'off'.
 229             >>> from iwlibs import Wireless
 230             >>> wifi = Wireless('eth1')
 231             >>> wifi.getFragmentation()
 232             'off'
 233         """
 234         iwparam = Iwparam(self.ifname, SIOCGIWFRAG)
 235         if iwparam.errorflag:
 236             return (iwparam.errorflag, iwparam.error)
 237         return iwparam.getValue()
 238
 239     def getFrequency(self):
 240         """returns currently set frequency of the card
 241
 242             >>> from iwlibs import Wireless
 243             >>> wifi = Wireless('eth1')
 244             >>> wifi.getFrequency()
 245             '2.417GHz'
 246         """
 247         i, r = self.iwstruct.iw_get_ext(self.ifname,
 248                                         SIOCGIWFREQ)
 249         if i > 0:
 250             return (i, r)
 251         iwfreq = Iwfreq(r)
 252         return iwfreq.getFrequency()
 253
 254
 255     def getMode(self):
 256         """returns currently set operation mode
 257
 258             >>> from iwlibs import Wireless
 259             >>> wifi = Wireless('eth1')
 260             >>> wifi.getMode()
 261             'Managed'
 262         """
 263         i, result = self.iwstruct.iw_get_ext(self.ifname,
 264                                              SIOCGIWMODE)
 265         if i > 0:
 266             return result
 267         mode = self.iwstruct.unpack('i', result[:4])[0]
 268         return modes[mode]
 269
 270     def setMode(self, mode):
 271         """sets the operation mode """
 272         try:
 273             this_modes = [x.lower() for x in modes]
 274             mode = mode.lower()
 275             wifimode = this_modes.index(mode)
 276         except ValueError:
 277             return "Invalid operation mode!"
 278
 279         s = self.iwstruct.pack('I', wifimode)
 280         i, result = self.iwstruct.iw_get_ext(self.ifname,
 281                                              SIOCSIWMODE,
 282                                              data=s)
 283         if i > 0:
 284             return result
 285
 286     def getWirelessName(self):
 287         """ returns wireless name
 288
 289             >>> from iwlibs import Wireless
 290             >>> wifi = Wireless('eth1')
 291             >>> wifi.getWirelessName()
 292             'IEEE 802.11-DS'
 293         """
 294         i, result = self.iwstruct.iw_get_ext(self.ifname,
 295                                              SIOCGIWNAME)
 296         if i > 0:
 297             return result
 298         return result.split('\0')[0]
 299
 300     def getPowermanagement(self):
 301         """returns power management settings
 302
 303             >>> from iwlibs import Wireless
 304             >>> wifi = Wireless('eth1')
 305             >>> wifi.getPowermanagement()
 306             'off'
 307         """
 308         iwparam = Iwparam(self.ifname, SIOCGIWPOWER)
 309         if iwparam.errorflag:
 310             return (iwparam.errorflag, iwparam.error)
 311         return iwparam.getValue()
 312
 313
 314     def getRetrylimit(self):
 315         """returns limit retry/lifetime
 316
 317             man iwconfig:
 318             Most cards have MAC retransmissions, and some  allow  to set
 319             the behaviour of the retry mechanism.
 320
 321             >>> from iwlibs import Wireless
 322             >>> wifi = Wireless('eth1')
 323             >>> wifi.getRetrylimit()
 324             16
 325         """
 326         iwparam = Iwparam(self.ifname, SIOCGIWRETRY)
 327         if iwparam.errorflag:
 328             return (iwparam.errorflag, iwparam.error)
 329         return iwparam.getValue()
 330
 331     def getRTS(self):
 332         """returns rts threshold
 333
 334             returns int, 'auto', 'fixed', 'off'
 335
 336             man iwconfig:
 337             RTS/CTS adds a handshake before each packet transmission to
 338             make sure that the channel is clear. This adds overhead, but
 339             increases performance in case of hidden  nodes or  a large
 340             number of active nodes. This parameter sets the size of the
 341             smallest packet for which the node sends RTS;  a value equal
 342             to the maximum packet size disable the mechanism.
 343
 344             >>> from iwlibs import Wireless
 345             >>> wifi = Wireless('eth1')
 346             >>> wifi.getRTS()
 347             'off'
 348         """
 349         iwparam = Iwparam(self.ifname, SIOCGIWRTS)
 350         if iwparam.errorflag:
 351             return (iwparam.errorflag, iwparam.error)
 352         return iwparam.getValue()
 353
 354     def getSensitivity(self):
 355         """returns sensitivity information
 356
 357             man iwconfig:
 358             This is the lowest signal level for which the hardware
 359             attempt  packet  reception, signals  weaker  than  this are
 360             ignored. This is used to avoid receiving background noise,
 361             so you should  set  it according  to  the  average noise
 362             level. Positive values are assumed to be the raw value used
 363             by the hardware  or a percentage, negative values are
 364             assumed to be dBm.
 365
 366             >>> from iwlibs import Wireless
 367             >>> wifi = Wireless('eth1')
 368             >>> wifi.getSensitivity()
 369             'off'
 370
 371         """
 372         iwparam = Iwparam(self.ifname, SIOCGIWSENS)
 373         if iwparam.errorflag:
 374             return (iwparam.errorflag, iwparam.error)
 375         return iwparam.getValue()
 376
 377     def getTXPower(self):
 378         """returns transmit power in dBm
 379
 380             >>> from iwlibs import Wireless
 381             >>> wifi = Wireless('eth1')
 382             >>> wifi.getTXPower()
 383             '17 dBm'
 384         """
 385         i, r = self.iwstruct.iw_get_ext(self.ifname,
 386                                         SIOCGIWTXPOW)
 387         if i > 0:
 388             return (i, r)
 389         iwfreq = Iwfreq(r)
 390         return iwfreq.getTransmitPower()
 391
 392     def getStatistics(self):
 393         """returns statistics information which can also be found in
 394            /proc/net/wireless
 395         """
 396         iwstats = Iwstats(self.ifname)
 397         if iwstats.errorflag > 0:
 398             return (iwstats.errorflag, iwstats.error)
 399         return [iwstats.status, iwstats.qual, iwstats.discard,
 400             iwstats.missed_beacon]
 401
 402     def scan(self):
 403         """returns Iwscanresult objects, after a successful scan"""
 404         iwscan = Iwscan(self.ifname)
 405         return iwscan.scan()
 406
 407
 408 class Iwstruct(object):
 409     """basic class to handle iwstruct data """
 410
 411     def __init__(self):
 412         self.idx = 0
 413         self.sockfd = socket(AF_INET, SOCK_DGRAM)
 414
 415     def parse_data(self, fmt, data):
 416         """ unpacks raw C data """
 417         size = struct_calcsize(fmt)
 418         idx = self.idx
 419
 420         str = data[idx:idx + size]
 421         self.idx = idx+size
 422         value = struct_unpack(fmt, str)
 423
 424         # take care of a tuple like (int, )
 425         if len(value) == 1:
 426             return value[0]
 427         else:
 428             return value
 429
 430     def pack(self, fmt, *args):
 431         """ calls struct_pack and returns the result """
 432         return struct_pack(fmt, *args)
 433
 434     def pack_wrq(self, buffsize):
 435         """ packs wireless request data for sending it to the kernel """
 436         # Prepare a buffer
 437         # We need the address of our buffer and the size for it. The
 438         # ioctl itself looks for the pointer to the address in our
 439         # memory and the size of it.
 440         # Dont change the order how the structure is packed!!!
 441         buff = array('c', '\0'*buffsize)
 442         caddr_t, length = buff.buffer_info()
 443         s = struct_pack('Pi', caddr_t, length)
 444         return buff, s
 445
 446     def pack_test(self, string, buffsize):
 447         """ packs wireless request data for sending it to the kernel """
 448         buffsize = buffsize - len(string)
 449         buff = array('c', string+'\0'*buffsize)
 450         caddr_t, length = buff.buffer_info()
 451         s = struct_pack('Pii', caddr_t, length, 1)
 452         return buff, s
 453
 454     def unpack(self, fmt, packed_data):
 455         """ unpacks data with given format """
 456         return struct_unpack(fmt, packed_data)
 457
 458     def _fcntl(self, request, args):
 459         return ioctl(self.sockfd.fileno(), request, args)
 460
 461     def iw_get_ext(self, ifname, request, data=None):
 462         """ read information from ifname """
 463         # put some additional data behind the interface name
 464         if data is not None:
 465             buff = IFNAMSIZE-len(ifname)
 466             ifreq = ifname + '\0'*buff
 467             ifreq = ifreq + data
 468         else:
 469             ifreq = (ifname + '\0'*32)
 470
 471         try:
 472             result = self._fcntl(request, ifreq)
 473         except IOError, (i, e):
 474             return i, e
 475
 476         return (0, result[16:])
 477
 478     def getMAC(self, packed_data):
 479         """ extracts mac addr from packed data and returns it as str """
 480         mac_addr = struct_unpack('xxBBBBBB', packed_data[:8])
 481         return "%02X:%02X:%02X:%02X:%02X:%02X" % mac_addr
 482
 483 class Iwparam(object):
 484     """class to hold iwparam data """
 485
 486     def __init__(self, ifname, ioctl):
 487         # (i) value, (b) fixed, (b) disabled, (b) flags
 488         self.fmt = "ibbH"
 489         self.value = 0
 490         self.fixed = 0
 491         self.disabled = 0
 492         self.flags = 0
 493         self.errorflag = 0
 494         self.error = ""
 495         self.ioctl = ioctl
 496         self.ifname = ifname
 497         self.update()
 498
 499     def getValue(self):
 500         """returns the value if not disabled """
 501
 502         if self.disabled:
 503             return 'off'
 504         if self.flags & IW_RETRY_TYPE == 0:
 505             return self.getRLAttributes()
 506         else:
 507             return self.getPMAttributes()
 508
 509     def getRLAttributes(self):
 510         """returns a string with attributes determined by self.flags
 511         """
 512         return self.value
 513
 514     def getPMAttributes(self):
 515         """returns a string with attributes determined by self.flags
 516            and IW_POWER*
 517         """
 518         result = ""
 519
 520         # Modifiers
 521         if self.flags & IW_POWER_MIN == 0:
 522             result = " min"
 523         if self.flags & IW_POWER_MAX == 0:
 524             result = " max"
 525
 526         # Type
 527         if self.flags & IW_POWER_TIMEOUT == 0:
 528             result = " period:"
 529         else:
 530             result = " timeout:"
 531         # Value with or without units
 532         # IW_POWER_RELATIVE - value is *not* in s/ms/us
 533         if self.flags & IW_POWER_RELATIVE:
 534             result += "%f" %(float(self.value)/MEGA)
 535         else:
 536             if self.value >= MEGA:
 537                 result += "%fs" %(float(self.value)/MEGA)
 538             elif self.value >= KILO:
 539                 result += "%fms" %(float(self.value)/KILO)
 540             else:
 541                 result += "%dus" % self.value
 542
 543         return result
 544
 545     def update(self):
 546         iwstruct = Iwstruct()
 547         i, r = iwstruct.iw_get_ext(self.ifname,
 548                                    self.ioctl)
 549         if i > 0:
 550             self.errorflag = i
 551             self.error = r
 552         self._parse(r)
 553
 554     def _parse(self, data):
 555         """ unpacks iwparam data """
 556         iwstruct = Iwstruct()
 557         self.value, self.fixed, self.disabled, self.flags =\
 558             iwstruct.parse_data(self.fmt, data)
 559
 560 class Iwfreq(object):
 561     """ class to hold iwfreq data
 562         delegates to Iwstruct class
 563     """
 564
 565     def __init__(self, data=None):
 566         self.fmt = "ihbb"
 567         if data is not None:
 568             self.frequency = self.parse(data)
 569         else:
 570             self.frequency = 0
 571         self.iwstruct = Iwstruct()
 572
 573     def __getattr__(self, attr):
 574         return getattr(self.iwstruct, attr)
 575
 576     def parse(self, data):
 577         """ unpacks iwparam"""
 578
 579         size = struct_calcsize(self.fmt)
 580         m, e, i, pad = struct_unpack(self.fmt, data[:size])
 581         # XXX well, its not *the* frequency - we need a better name
 582         if e == 0:
 583             return m
 584         else:
 585             return float(m)*10**e
 586
 587     def getFrequency(self):
 588         """returns Frequency (str)
 589
 590            data - binary data returned by systemcall (iw_get_ext())
 591         """
 592         freq = self.frequency
 593
 594         if freq >= GIGA:
 595             return "%0.3fGHz" %(freq/GIGA)
 596
 597         if freq >= MEGA:
 598             return "%0.3fMHZ" %(freq/MEGA)
 599
 600         if freq >= KILO:
 601             return "%0.3fKHz" %(freq/KILO)
 602
 603     def getBitrate(self):
 604         """ returns Bitrate in Mbit
 605
 606            data - binary data returned by systemcall (iw_get_ext())
 607         """
 608         bitrate = self.frequency
 609
 610         if bitrate >= GIGA:
 611             return "%i Gb/s" %(bitrate/GIGA)
 612
 613         if bitrate >= MEGA:
 614             return "%i Mb/s" %(bitrate/MEGA)
 615
 616         if bitrate >= KILO:
 617             return "%i Kb/s" %(bitrate/KILO)
 618
 619     def getTransmitPower(self):
 620         """ returns transmit power in dbm """
 621         # XXX something flaky is going on with m and e
 622         # eg. m = 50 and e should than be 0, because the number is stored in
 623         # m and don't needs to be recalculated
 624         return "%i dBm" %self.mw2dbm(self.frequency/10)
 625
 626     def getChannel(self, freq):
 627         """returns channel information given by frequency
 628
 629            returns None if frequency can't be converted
 630            freq = frequency to convert (int)
 631            iwrange = Iwrange object
 632         """
 633
 634         try:
 635             freq = float(freq)
 636         except:
 637             return None
 638
 639         lut = {}
 640         #13 Channels beginning at 2.412GHz and inreasing by 0,005 GHz steps
 641         for i in range(0,12):
 642             cur = float( 2.412 + ( i * 0.005 ) )
 643             lut[str(cur)] = i+1
 644         # Channel 14 need special actions ;)
 645         lut['2.484'] = 14
 646
 647
 648         if str(freq) in lut.keys():
 649                 return lut[str(freq)]
 650
 651         return None
 652
 653
 654     def mw2dbm(self, mwatt):
 655         """ converts mw to dbm(float) """
 656         return ceil(10.0 * log10(mwatt))
 657
 658     def _setFrequency(self, list):
 659         """sets self.frequency by given list
 660
 661            currently only used by Iwrange
 662         """
 663         assert len(list) == 4
 664         m, e, i, pad = list
 665         if e == 0:
 666             self.frequency = m
 667         else:
 668             self.frequency = m #float(m)*10**e
 669
 670 class Iwstats(object):
 671     """ class to hold iwstat data """
 672
 673     def __init__(self, ifname):
 674         # (2B) status, 4B iw_quality, 6i iw_discarded
 675         self.fmt = "2B4B6i"
 676         self.status = 0
 677         self.qual = Iwquality()
 678         self.discard = {}
 679         self.missed_beacon = 0
 680         self.ifname = ifname
 681         self.errorflag = 0
 682         self.error = ""
 683         self.update()
 684
 685     def update(self):
 686         iwstruct = Iwstruct()
 687         buff, s = iwstruct.pack_wrq(32)
 688         i, result = iwstruct.iw_get_ext(self.ifname,
 689                                         SIOCGIWSTATS,
 690                                         data=s)
 691         if i > 0:
 692             self.error = result
 693             self.errorflag = i
 694         self._parse(buff.tostring())
 695
 696     def _parse(self, data):
 697         """ unpacks iwstruct data """
 698         struct = Iwstruct()
 699         iwqual = Iwquality()
 700         iwstats_data = struct.parse_data(self.fmt, data)
 701
 702         self.status = iwstats_data[0:2]
 703         self.qual.quality, self.qual.sl, self.qual.nl,\
 704             self.qual.flags = iwstats_data[2:6]
 705         nwid, code, frag, retries, flags = iwstats_data[6:11]
 706         self.missed_beacon = iwstats_data[11:12][0]
 707         self.discard = makedict(nwid=nwid, code=code,
 708             fragment=frag, retries=retries, misc=flags)
 709
 710 class Iwquality(object):
 711     """ class to hold iwquality data """
 712
 713     def __init__(self):
 714         self.quality = 0
 715         self.sl = 0
 716         self.nl = 0
 717         self.updated = 0
 718         self.fmt = "4B"
 719
 720     def parse(self, data):
 721         """ unpacks iwquality data """
 722         struct = Iwstruct()
 723         qual, sl, nl, flags = struct.parse_data(self.fmt, data)
 724
 725         # compute signal and noise level
 726         self.signal_level = sl
 727         self.noise_level = nl
 728
 729         # asign the other values
 730         self.quality = qual
 731         self.updated = flags
 732
 733     def setValues(self, list):
 734         """ assigns values given by a list to our attributes """
 735         attributes = ["quality", "signallevel", "noise_level",
 736             "updated"]
 737         assert len(list) == 4
 738
 739         for i in range(len(list)):
 740             setattr(self, attributes[i], list[i])
 741
 742     def getSignallevel(self):
 743         """ returns signal level """
 744         return self.sl-0x100
 745
 746     def setSignallevel(self, sl):
 747         """ sets signal level """
 748         self.sl = sl
 749     signallevel = property(getSignallevel, setSignallevel)
 750
 751     def getNoiselevel(self):
 752         """ returns noise level """
 753         return self.nl - 0x100
 754
 755     def setNoiselevel(self):
 756         raise NotImplementedError
 757         self.nl = nl
 758     noiselevel = property(getNoiselevel, setNoiselevel)
 759
 760 class Iwpoint(object):
 761     """ class to hold iwpoint data """
 762
 763     def __init__(self, ifname):
 764         self.key = [0,0,0,0]
 765         self.fields = 0
 766         self.flags = 0
 767         # (4B) pointer to data, H length, H flags
 768         self.fmt = "4BHH"
 769         self.errorflag = 0
 770         self.error = ""
 771         self.ifname = ifname
 772         self.update()
 773
 774     def __getattr__(self, attr):
 775         return getattr(self.iwstruct, attr)
 776
 777     def update(self):
 778         iwstruct = Iwstruct()
 779         buff, s = iwstruct.pack_wrq(32)
 780         i, result = iwstruct.iw_get_ext(self.ifname,
 781                                         SIOCGIWENCODE,
 782                                         data=s)
 783         if i > 0:
 784             self.errorflag = i
 785             self.error = result
 786         self._parse(result)
 787
 788     def getEncryptionKey(self):
 789         """ returns encryption key as '**' or 'off' as str """
 790         if self.flags & IW_ENCODE_DISABLED != 0:
 791             return 'off'
 792         elif self.flags & IW_ENCODE_NOKEY != 0:
 793             # a key is set, so print it
 794             return '**' * self.fields
 795
 796     def _parse(self, data):
 797         """ unpacks iwpoint data
 798         """
 799         iwstruct = Iwstruct()
 800         ptr, ptr, ptr, ptr, self.fields, self.flags =\
 801             iwstruct.parse_data(self.fmt, data)
 802         self.key = [ptr, ptr, ptr, ptr]
 803
 804 class Iwrange(object):
 805     """holds iwrange struct """
 806     IW_MAX_FREQUENCIES = 32
 807
 808     def __init__(self, ifname):
 809         self.fmt = "iiihb6ii4B4Bi32i2i2i2i2i3h8h2b2bhi8i2b3h2i2ihB17x"\
 810             + self.IW_MAX_FREQUENCIES*"ihbb"
 811
 812         self.ifname = ifname
 813         self.errorflag = 0
 814         self.error = ""
 815
 816         # informative stuff
 817         self.throughput = 0
 818
 819         # nwid (or domain id)
 820         self.min_nwid = self.max_nwid = 0
 821
 822         # frequency for backward compatibility
 823         self.old_num_channels = self.old_num_frequency = self.old_freq = 0
 824
 825         # signal level threshold
 826         self.sensitivity = 0
 827
 828         # link quality
 829         self.max_qual = Iwquality()
 830         self.avg_qual = Iwquality()
 831
 832         # rates
 833         self.num_bitrates = 0
 834         self.bitrates = []
 835
 836         # rts threshold
 837         self.min_rts = self.max_rts = 0
 838
 839         # fragmention threshold
 840         self.min_frag = self.max_frag = 0
 841
 842         # power managment
 843         self.min_pmp = self.max_pmp = 0
 844         self.min_pmt = self.max_pmt = 0
 845         self.pmp_flags = self.pmt_flags = self.pm_capa = 0
 846
 847         # encoder stuff
 848         self.encoding_size = 0
 849         self.num_encoding_sizes = self.max_encoding_tokens = 0
 850         self.encoding_login_index = 0
 851
 852         # transmit power
 853         self.txpower_capa = self.num_txpower = self.txpower = 0
 854
 855         # wireless extension version info
 856         self.we_vers_compiled = self.we_vers_src = 0
 857
 858         # retry limits and lifetime
 859         self.retry_capa = self.retry_flags = self.r_time_flags = 0
 860         self.min_retry = self.max_retry = 0
 861         self.min_r_time = self.max_r_time = 0
 862
 863         # frequency
 864         self.num_channels = self.num_frequency = 0
 865         self.frequencies = []
 866         self.update()
 867
 868     def update(self):
 869         """updates Iwrange object by a system call to the kernel
 870            and updates internal attributes
 871         """
 872         iwstruct = Iwstruct()
 873         buff, s = iwstruct.pack_wrq(640)
 874         i, result = iwstruct.iw_get_ext(self.ifname,
 875                                         SIOCGIWRANGE,
 876                                         data=s)
 877         if i > 0:
 878             self.errorflag = i
 879             self.error = result
 880         data = buff.tostring()
 881         self._parse(data)
 882
 883     def _parse(self, data):
 884         struct = Iwstruct()
 885         result = struct.parse_data(self.fmt, data)
 886
 887         # XXX there is maybe a much more elegant way to do this
 888         self.throughput, self.min_nwid, self.max_nwid = result[0:3]
 889         self.old_num_channels, self.old_num_frequency = result[3:5]
 890         self.old_freq = result[5:11]
 891         self.sensitivity = result[11]
 892         self.max_qual.setValues(result[12:16])
 893         self.avg_qual.setValues(result[16:20])
 894         self.num_bitrates = result[20] # <- XXX
 895         raw_bitrates = result[21:53]
 896         for rate in raw_bitrates:
 897             iwfreq = Iwfreq()
 898             iwfreq.frequency = rate
 899             br = iwfreq.getBitrate()
 900             if br is not None:
 901                 self.bitrates.append(br)
 902
 903         self.min_rts, self.max_rts = result[53:55]
 904         self.min_frag, self.max_frag = result[55:57]
 905         self.min_pmp, self.max_pmp = result[57:59]
 906         self.min_pmt, self.max_pmt = result[59:61]
 907         self.pmp_flags, self.pmt_flags, self.pm_capa = result[61:64]
 908         self.encoding_size = result[64:72]
 909         self.num_encoding_sizes, self.max_encoding_tokens = result[72:74]
 910         self.encoding_login_index = result[74:76]
 911         self.txpower_capa, self.num_txpower = result[76:78]
 912         self.txpower = result[78:86]
 913         self.we_vers_compiled, self.we_vers_src = result[86:88]
 914         self.retry_capa, self.retry_flags, self.r_time_flags = result[88:91]
 915         self.min_retry, self.max_retry = result[91:93]
 916         self.min_r_time, self.max_r_time = result[93:95]
 917         self.num_channels = result[95]
 918         self.num_frequency = result[96]
 919         freq = result[97:]
 920
 921         i = self.num_frequency
 922         for x in range(0, len(freq), 4):
 923             iwfreq = Iwfreq()
 924             iwfreq._setFrequency(freq[x:x+4])
 925             fq = iwfreq.getFrequency()
 926             if fq is not None:
 927                 self.frequencies.append(fq)
 928             i -= 1
 929             if i <= 0:
 930                 break
 931
 932 class Iwscan(object):
 933     """class to handle AP scanning"""
 934
 935     def __init__(self, ifname):
 936         self.ifname = ifname
 937         self.range = Iwrange(ifname)
 938         self.errorflag = 0
 939         self.error = ""
 940         self.stream = None
 941         self.aplist = None
 942
 943     def scan(self, fullscan=True):
 944         """Completes a scan for available access points,
 945            and returns them in Iwscanresult format
 946
 947            fullscan: If False, data is read from a cache of the last scan
 948                      If True, a scan is conducted, and then the data is read
 949         """
 950         # By default everything is fine, do not wait
 951         result = 1
 952         if fullscan:
 953             self.setScan()
 954             if self.errorflag > EPERM:
 955                 raise RuntimeError, 'setScan failure ' + str(self.errorflag) + " " + str(self.error)
 956                 return None
 957             elif self.errorflag < EPERM:
 958                 # Permission was NOT denied, therefore we must WAIT to get results
 959                 result = 250
 960
 961         while (result > 0):
 962             sleep(result/1000)
 963             result = self.getScan()
 964
 965         if result < 0 or self.errorflag != 0:
 966             raise RuntimeError, 'getScan failure ' + str(self.errorflag) + " " + str(self.error)
 967
 968         return self.aplist
 969
 970
 971     def setScan(self):
 972         """Triggers the scan, if we have permission
 973         """
 974         iwstruct = Iwstruct()
 975         s = iwstruct.pack('Pii', 0, 0, 0)
 976         i, result = iwstruct.iw_get_ext(self.ifname,
 977                                         SIOCSIWSCAN,s)
 978         if i > 0:
 979             self.errorflag = i
 980             self.error = result
 981         return result
 982
 983     def getScan(self):
 984         """Retreives results, stored from the most recent scan
 985            Returns 0 if successful, a delay if the data isn't ready yet
 986            or -1 if something really nasty happened
 987         """
 988         iwstruct = Iwstruct()
 989         i = E2BIG
 990         bufflen = IW_SCAN_MAX_DATA
 991
 992         # Keep resizing the buffer until it's large enough to hold the scan
 993         while (i == E2BIG):
 994             buff, s = iwstruct.pack_wrq(bufflen)
 995             i, result = iwstruct.iw_get_ext(self.ifname,
 996                                             SIOCGIWSCAN,
 997                                             data=s)
 998             if i == E2BIG:
 999                 pbuff, newlen = iwstruct.unpack('Pi', s)
1000                 if bufflen < newlen:
1001                     bufflen = newlen
1002                 else:
1003                     bufflen = bufflen * 2
1004
1005         if i == EAGAIN:
1006             return 100
1007         if i > 0:
1008             self.errorflag = i
1009             self.error = result
1010             return -1
1011
1012         pbuff, reslen = iwstruct.unpack('Pi', s)
1013         if reslen > 0:
1014             # Initialize the stream, and turn it into an enumerator
1015             self.aplist = self._parse(buff.tostring())
1016             return 0
1017
1018     def _parse(self, data):
1019         """Parse the event stream, and return a list of Iwscanresult objects
1020         """
1021         iwstruct = Iwstruct()
1022         scanresult = None
1023         aplist = []
1024
1025         # Run through the stream, until broken
1026         while 1:
1027             # If we're the stream doesn't have enough space left for a header, break
1028             if len(data) < IW_EV_LCP_LEN:
1029                 break;
1030
1031             # Unpack the header
1032             length, cmd = iwstruct.unpack('HH', data[:4])
1033             # If the header says the following data is shorter than the header, then break
1034             if length < IW_EV_LCP_LEN:
1035                 break;
1036
1037             # Put the events into their respective result data
1038             if cmd == SIOCGIWAP:
1039                 if scanresult is not None:
1040                     aplist.append(scanresult)
1041                 scanresult = Iwscanresult(data[IW_EV_LCP_LEN:length], self.range)
1042             elif scanresult is None:
1043                 raise RuntimeError, 'Attempting to add an event without AP data'
1044             else:
1045                 scanresult.addEvent(cmd, data[IW_EV_LCP_LEN:length])
1046
1047             # We're finished with the preveious event
1048             data = data[length:]
1049
1050         # Don't forgset the final result
1051         if scanresult.bssid != "00:00:00:00:00:00":
1052             aplist.append(scanresult)
1053         else:
1054             raise RuntimeError, 'Attempting to add an AP without a bssid'
1055         return aplist
1056
1057 class Iwscanresult(object):
1058     """An object to contain all the events associated with a single scanned AP
1059     """
1060
1061     def __init__(self, data, range):
1062         """Initialize the scan result with the access point data"""
1063         self.iwstruct = Iwstruct()
1064         self.range = range
1065         self.bssid = "%02X:%02X:%02X:%02X:%02X:%02X" % struct_unpack('BBBBBB', data[2:8])
1066         self.essid = None
1067         self.mode = None
1068         self.rate = []
1069         self.quality = Iwquality()
1070         self.frequency = None
1071         self.encode = None
1072         self.custom = []
1073         self.protocol = None
1074
1075     def addEvent(self, cmd, data):
1076         """Attempts to add the data from an event to a scanresult
1077            Only certain data is accept, in which case the result is True
1078            If the event data is invalid, None is returned
1079            If the data is valid but unused, False is returned
1080         """
1081         if cmd <= SIOCIWLAST:
1082             if cmd < SIOCIWFIRST:
1083                 return None
1084         elif cmd >= IWEVFIRST:
1085             if cmd > IWEVLAST:
1086                 return None
1087         else:
1088             return None
1089
1090         if cmd == SIOCGIWESSID:
1091             self.essid = data[4:]
1092         elif cmd == SIOCGIWMODE:
1093             self.mode = modes[self.iwstruct.unpack('i', data[:4])[0]]
1094         elif cmd == SIOCGIWRATE:
1095             # TODO, deal with multiple rates, or at least the highest rate
1096             freqsize = struct_calcsize("ihbb")
1097             while len(data) >= freqsize:
1098                 iwfreq = Iwfreq(data)
1099                 self.rate.append(iwfreq.getBitrate())
1100                 data = data[freqsize:]
1101         elif cmd == IWEVQUAL:
1102             self.quality.parse(data)
1103         elif cmd == SIOCGIWFREQ:
1104             self.frequency = Iwfreq(data)
1105         elif cmd == SIOCGIWENCODE:
1106             self.encode = data
1107         elif cmd == IWEVCUSTOM:
1108             self.custom.append(data[1:])
1109         elif cmd == SIOCGIWNAME:
1110             self.protocol = data[:len(data)-2]
1111         else:
1112             #print "Cmd:", cmd
1113             return False
1114         return True