wifiutil.h

/*
 * Orca-Robotics Project: Components for robotics 
 *               http://orca-robotics.sf.net/
 * Copyright (c) 2004-2009 Alex Brooks, Alexei Makarenko, Tobias Kaupp
 *
 * This distribution is licensed to you under the terms described in
 * the LICENSE file included in this distribution.
 *
 */
 
#ifndef WIFI_UTIL_H
#define WIFI_UTIL_H

#include <string>
#include <vector>

namespace wifiutil {

    enum Result
    {
        NoWirelessInterface,
        IoctlProblem,
        OtherError
    };
    
    class Exception : public std::exception
    {
    public:

        Exception(const char *message)
            : message_(message) {}
        Exception(const std::string &message)
            : message_(message) {}

        virtual ~Exception() throw() {}

        virtual const char* what() const throw() { return message_.c_str(); }
        
        virtual Result type() const { return OtherError; }

    protected:

        std::string  message_;
    };
    
    class NoWirelessInterfaceException : public Exception
    {  
        public:
            NoWirelessInterfaceException( const char * message )
                : Exception( message ) {}
            virtual Result type() const { return NoWirelessInterface; }        
    };
    
    class IoctlException : public Exception
    {  
        public:
            IoctlException( const char * message )
                : Exception( message ) {}
            virtual Result type() const { return IoctlProblem; }        
    };
    
    struct ProcData
    {
        std::string interfaceName;
        int status;
        int linkQuality;
        int signalLevel;
        int noiseLevel;
        int numInvalidNwid;
        int numInvalidCrypt;
        int numInvalidFrag;
        int numRetries;
        int numInvalidMisc;
        int numMissedBeacons;   
    };
    
    enum OperationMode
    {
        // unknown operating mode
        OperationModeUnknown,
        // driver decides the mode
        OperationModeAuto,
        // ad hoc mode
        OperationModeAdhoc,
        // infrastructure mode (multi cell network, roaming)
        OperationModeInfrastructure,
        // access point, master mode
        OperationModeMaster,
        // repeater mode
        OperationModeRepeat,
        // secondary/backup repeater
        OperationModeSecondRepeater
    };
    
    struct WirelessConfig
    {
        std::string interfaceName;
        OperationMode mode;
        int bitrate;
        std::string accessPoint;
    };
    
    enum LinkQualityType 
    {
        // link quality type is unknown
        LinkQualityTypeUnknown,
        // link quality is in dBm
        LinkQualityTypeDbm,
        // link quality is relative
        LinkQualityTypeRelative
    };
    
    struct IoctlData
    {
        std::string interfaceName;
        int throughPut;
        LinkQualityType linkType;
        int linkQuality;
        int signalLevel;
        int noiseLevel;
        int maxLinkQuality;
        int maxSignalLevel;
        int maxNoiseLevel;
    };
    
    void readFromProc( std::vector<ProcData> &wifiData );
    
    std::string toString( std::vector<ProcData> &wifiData );
    
    void readConfig( std::vector<WirelessConfig> &wifiConfigs );
    
    std::string toString( std::vector<WirelessConfig> &wifiConfigs );
    
    void readUsingIoctl( std::vector<IoctlData> &wifiDataIoctl );
    
    std::string toString( std::vector<IoctlData> &wifiDataIoctl );
    
    void getInterfaceNames( std::vector<std::string> &interfaceNames );

}
 
#endif