## mark a section (Learn more)

/* * VoodooWirelessDevice.h * VoodooWireless * * Created by Prashant Vaibhav on 12/06/09. * Copyright 2009 Prashant Vaibhav. All rights reserved. * */ #ifndef _H_VOODOOWIRELESSDEVICE_H #define _H_VOODOOWIRELESSDEVICE_H #include <sys/types.h> #include <sys/kpi_mbuf.h> #include <IOKit/IOService.h> #include <IOKit/IOMessage.h> #include <IOKit/IOWorkLoop.h> #include <IOKit/apple80211/IO80211Controller.h> #include <IOKit/apple80211/IO80211Interface.h> #include <IOKit/apple80211/IO80211WorkLoop.h> #include <IOKit/network/IOOutputQueue.h> #include "VoodooWirelessFamily.h" #include "VoodooIEEE80211.h" #include "VoodooWirelessDevice_Types.h" using namespace org_voodoo_wireless; class VoodooWirelessDevice : public IO80211Controller { public: /* NOTE: None of the public functions need to be implemented by subclasses. Proper implementations * is already provided by this superclass */ /* Basic IOKit functions */ virtual bool start ( IOService* provider ); virtual void stop ( IOService* provider ); IOReturn registerWithPolicyMaker ( IOService* policyMaker ); /* Network driver and apple80211 functions */ SInt32 apple80211Request ( UInt32 request_type, int request_number, IO80211Interface* interface, void* data ); IOReturn enable ( IONetworkInterface* aNetif ); IOReturn disable ( IONetworkInterface* aNetif ); IOOutputQueue* createOutputQueue ( ); UInt32 outputPacket ( mbuf_t m, void* param ); IOReturn getMaxPacketSize ( UInt32 *maxSize ) const; const OSString* newVendorString ( ) const; const OSString* newModelString ( ) const; const OSString* newRevisionString ( ) const; IOReturn getHardwareAddress ( IOEthernetAddress* addr ); virtual IOReturn setPromiscuousMode ( IOEnetPromiscuousMode mode ); virtual IOReturn setMulticastMode ( IOEnetMulticastMode mode ); virtual IOReturn setMulticastList ( IOEthernetAddress* addr, UInt32 len ); virtual SInt32 monitorModeSetEnabled ( IO80211Interface * interface, bool enabled, UInt32 dlt ); protected: struct ExpansionData {}; // reserved, for internal use only ExpansionData* reserved; // reserved, for internal use only /* Functions to init / shutdown the HW */ virtual IOReturn allocateResources ( ); // Allocate hw rings, memory etc. needed for power up virtual void freeResources ( ); // Undo all allocations done in allocateResources() virtual IOReturn turnPowerOn ( ); // Make the card ready for action virtual IOReturn turnPowerOff ( ); // Turn the card off /* Functions for establishing connections, scanning etc. */ virtual IOReturn startScan ( const ScanParameters* params, const IEEE::ChannelList* channels ); virtual void abortScan ( ); virtual IOReturn associate ( const AssociationParameters* params ); virtual IOReturn disasssociate ( ); /* Various configuration functions */ virtual void getHardwareInfo ( HardwareInfo* info ); virtual IOReturn getConfiguration ( HardwareConfigType type, void* param ); virtual IOReturn setConfiguration ( HardwareConfigType type, void* param ); /* The following function should be called by subclasses to report events. */ void report ( DeviceResponseMessage msg, void* arg ); /* This is to be called by subclasses when it receives any frames from HW. * "data" should be raw 802.11 frame. * During scanning, beacon or probe response frames should be passed via this function */ void inputFrame ( RxFrameHeader hdr, mbuf_t data ); /* This function must be implemented by the subclass to output a raw 802.11 frame. * Note that the mbuf_t could either be a single mbuf or a chain of 2 or more mbufs. * The passed mbuf_t becomes property of the driver which should free it when it is no longer needed. */ virtual IOReturn outputFrame ( TxFrameHeader hdr, mbuf_t data ); private: HardwareInfo _hwInfo; uint32_t _flags; IOSimpleLock* _simpleLock; /* The following are reserved slots for future expansion */ OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 0); OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 1); OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 2); OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 3); OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 4); OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 5); OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 6); OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 7); OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 8); OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 9); OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 10); OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 11); OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 12); OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 13); OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 14); OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 15); OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 16); OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 17); OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 18); OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 19); OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 20); OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 21); OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 22); OSMetaClassDeclareReservedUnused(VoodooWirelessDevice, 23); }; #endif//_H_VOODOOWIRELESSDEVICE_H /* * VoodooWirelessDevice_Types.h * VoodooWireless * * Created by Prashant Vaibhav on 16/06/09. * Copyright 2009 Prashant Vaibhav. All rights reserved. * */ #ifndef _H_VOODOOWIRELESSDEVICE_TYPES_H #define _H_VOODOOWIRELESSDEVICE_TYPES_H #include <libkern/c++/OSSymbol.h> #include <libkern/c++/OSString.h> #include "VoodooWirelessFamily.h" #include "VoodooIEEE80211.h" namespace org_voodoo_wireless { struct ScanParameters { enum ScanType { scanTypeActive, scanTypePassive, scanTypeBackground }; ScanType scanType; // Type of scan (active/passive..) IEEE::PHYModes scanPhyMode; // 11a,b,g or n on which to scan IEEE::MACAddress bssid; // BSSID to which scan is directed OSSymbol* ssid; // SSID (network name) to which scan is directed uint32_t dwellTime; // Time to stay on each channel (ms) uint32_t restTime; // Time to wait between channels (ms) }; struct ScanResult { IEEE::Channel channel; // channel on which this AP is operating IEEE::Capability capability; // AP capability flags IEEE::MACAddress bssid; // BSSID of access point OSSymbol* ssid; // Network name int noiseLevel; // background noise int signalLevel; // signal strength IEEE::RateSet supportedRates; // rates that the AP supports uint32_t beaconInterval; // in ms uint32_t age; // how old is this result (in ms) IEList* extraIEs; // extra information elements sent in the probe response }; struct AssociationParameters { OSSymbol* ssid; // not needed usually, but providing anyway IEEE::MACAddress bssid; IEEE::Channel channel; IEEE::Capability capability; IEEE::RateSet supportedRates; // That the AP supports uint32_t beaconInterval; enum APMode { apModeAny, apModeAdHoc, apModeInfrastructure }; APMode connectionMode; enum AuthType { /* LSB signifies lower auth mode (to be OR'd with upper auth mode if needed) */ authTypeNone = 0, // Open authentication authTypeShared = 1, // WEP key shared authentication /* Upper auth modes (even number only as LSB is taken) */ authTypeWPA = 2, authTypeWPAPSK = 4, authTypeWPA2 = 6, authTypeWPA2PSK = 8, authtypeLEAP = 10, authType8021X = 12, authTypeWPS = 14 }; AuthType authType; IEEE::WEPKey wepKey; // if key is zero length, then no WEP IEList* extraIEs; // info elements used with RSN (WPA etc.) bool closedNetwork; // indicates assoc request is for directed scanned network }; struct RxFrameHeader { /* information about an incoming frame */ IEEE::Channel channel; IEEE::DataRate rate; int signalLevel; // signal strength bool decrypted; // whether HW has already decrypted this frame }; struct TxFrameHeader { IEEE::DataRate rate; // desired Tx rate (can be ignored by HW) bool encrypted; // whether this frame is already encrypted }; struct HardwareCapabilities { /* Which features does the hardware support */ bool WEP :1; // the cipher. if 0, will fall back to software cipher bool TKIP :1; // the cipher. if 0, will fall back to software cipher bool TKIP_MIC :1; // hardware TKIP MIC support. if 0, fall back to full software TKIP bool AES_CCMP :1; // the cipher. if 0, will fall back to software cipher bool WPA1 :1; // connecting to WPA1. if 0, WPA1 will not be available at all bool WPA2 :1; // connecting to WPA2. if 0, WPA2 will not be available at all bool AdHocMode :1; bool HostAPMode :1; bool MonitorMode :1; bool PowerManagement :1; // active 802.11 power management, not IOKit power management bool TxPowerManagement:1; // transmit power can be set bool WakeOneWireless :1; bool ShortSlot :1; bool ShortPreamble :1; bool FrameBursting :1; bool WMEQoS :1; bool ShortGuardInterval20MHz :1; bool ShortGuardInterval40MHz :1; bool hardwareRoaming :1; // hardware can migrate to different APs on its own }; enum PowerSavingModes { powerSaveAlwaysOn = 1, powerSaveNormal = 2, // middle-level power saving powerSaveMaximum = 4 // maximum power savings }; enum HardwareConfigType { /* Which kind of config to get/set, when get/setConfig is called. Any of this can be ignored */ configTxPower, // param = int txPower configRTSThreshold, // param = uint32_t threshInBytes configFragmentationThreshold, // param = uint32_t threshInBytes configShortRetryLimit, // param = uint32_t numRetries configLongRetryLimit, // param = uint32_t numRetries configCurrentTxRate, // param = IEEE::DataRate configRateSet, // param = IEEE::RateSet [working rates, not HW supported rates] configInterferenceMitigation, // param = bool turnOn [HW dependent, usually bluetooth interference] config11GProtection // param = bool turnOn [used in mixed 11bg networks] }; struct HardwareInfo { /* Note: strings should not have been allocated already, they will be allocated by the driver itself. Ownership is then passed to the superclass who must release the strings. In other words, this struct should be zero filled before being passed to subclass. */ OSString* manufacturer; OSString* model; OSString* hardwareRevision; OSString* driverVersion; OSString* firmwareVersion; IEEE::MACAddress hardwareAddress; IEEE::PHYModes supportedModes; // OR'd bits if it's multi-mode PHY IEEE::ChannelList supportedChannels; // independent of locale IEEE::RateSet supportedRates; // that hardware supports, not what it's using now unsigned int maxTxPower; // in dBm, independent of locale enum SNRUnit { unit_dBm, unit_Percent, unit_mW, unit_Other_Linear, unit_Other_Logarithmic }; SNRUnit snrUnit; // which units are noise/signal levels reported in PowerSavingModes powerSavingModes; // which modes does hardware support HardwareCapabilities capabilities; uint32_t maxPacketSize; // largest packet size which this HW can transmit uint32_t txQueueSize; // how many packets can be sent to HW's tx queue }; enum DeviceResponseMessage { msgNull = iokit_vendor_specific_msg(1), // XXX: not used msgPowerOff, // HW power was turned off without being requested msgPowerOn, // HW power was turned on without being requested msgRadioOff, // PHY was turned off by user or power saving msgRadioOn, // PHY was turned on by user or power saving msgScanAborted, // scan was aborted (by HW, not as response to client request) msgScanCompleted, // scanning all specified chanels is completed msgChannelScanned, // scanning a specific channel is completed (arg=Channel*) msgAuthenticationFailed, // authentication step failed msgAuthenticationDone, // authentication step was done msgAssociationFailed, // association with AP failed, arg=IEEE::ReasonCode* msgAssociationDone, // association was finished successfully msgDeassociationFailed, // deassoc request failed, arg=IEEE::ReasonCode* msgDeassociationDone, // deassociated from AP, arg=IEEE::ReasonCode* msgDeauthenticated, // deauthenticated from AP, arg=IEEE::ReasonCode* msgNoiseLevelReport, // reporting noise level, arg=int* noiseLevel msgSignalStrengthReport, // reporting signal strength, arg=int* signalStrength msgChannelSwitch, // reporting AP channel switch, arg=Channel* newChan msgLinkQualityReport, // reporting link quality, arg=int* qualityLevel msgBeaconMissed, // reporting missed beacon, arg=uint32_t* howManyMissed msgConfigChanged, // reporting a change in HW config (without being requested) // arg=HardwareConfigType* type, client may call getConfig after this msgMaxMessageNumber // XXX: used to check if msg num was out of bound }; }; #endif /* * VoodooIEEE80211_Types.h * VoodooWireless * * Created by Prashant Vaibhav on 16/06/09. * Copyright 2009 Prashant Vaibhav. All rights reserved. * */ #ifndef _H_VOODOOIEEE80211_TYPES_H #define _H_VOODOOIEEE80211_TYPES_H #include "VoodooWirelessFamily.h" namespace org_voodoo_wireless { namespace IEEE { struct MACAddress { /* Defining this again here because families should not have to use another family's headers, and IOEthernetAddress is defined in IOEthernetFamily */ uint8_t bytes[6]; }; struct WEPKey { uint8_t index; // 0 to 3 OSString* key; // 40 or 104 bits (5 or 13 bytes) }; enum PHYModes { dot11A = 1, // 5GHz OFDM dot11B = 2, // 2.4GHz CCK dot11G = 4, // 2.4GHz OFDM dot11N = 8, // 2.4GHz or 5GHz MIMO }; const size_t MAX_CHANNELS = 64; const size_t MAX_RATES = 32; struct Channel { uint8_t number; // Channel number uint16_t flags; // Channel type flags enum Flags { supportsActiveScanning = 0x1, band2GHz = 0x2, band5GHz = 0x4, width10MHz = 0x8, width20MHz = 0x10, width40MHz = 0x20, requiresDFS = 0x40, // dynamic frequency selection for 11a supportsHostAPMode = 0x80, supportsAdHocMode = 0x100, extensionChannelIsAbove = 0x200 // in 11n mode, if ext. ch is above this ch. (otherwise below) }; }; struct ChannelList { size_t numItems; Channel channel[MAX_CHANNELS]; }; enum DataRate { rateIsBasic = 128, // basic rates should be OR'd with this value (ie. bit 7 = 1) /* Rates are just uint32_t, in 0.5 Mbps units */ rate1Mbps = 2, // 1 Mbps CCK rate2Mbps = 4, // 2 Mbps CCK rate5Mbps = 10, // 5.5 Mbps CCK rate6Mbps = 12, // 6 Mbps OFDM rate9Mbps = 18, // 9 Mbps OFDM rate11Mbps = 22, // 11 Mbps CCK rate12Mbps = 24, // 12 Mbps OFDM rate18Mbps = 36, // 18 Mbps OFDM rate24Mbps = 48, // 24 Mbps OFDM rate36Mbps = 72, // 36 Mbps OFDM rate48Mbps = 96, // 48 Mbps OFDM rate54Mbps = 108, // 54 Mbps OFDM /* 11n MIMO rates to be added later */ }; struct RateSet { size_t numItems; DataRate rate[MAX_RATES]; }; enum ReasonCode { // § 7.3.1.7 Table 7-22 reasonUnspecified = 1, reasonPreviousAuthExpired = 2, reasonDeauthBecauseSTALeft = 3, reasonDisassocDueToInactivity = 4, reasonAPFull = 5, reasonClass2FrameRxWithoutAuth = 6, reasonClass3FrameRxWithoutAssoc = 7, reasonDisassocBecauseSTALeft = 8, reasonNotAuthorized = 9, reasonPowerCapsUnacceptable = 10, reasonSupportedChannelsUnacceptable = 11, reasonInvalidIE = 13, /* 12 is reserved */ reasonMICFailure = 14, reason4WayHandshakeTimeout = 15, reasonGroupKeyHandshakeTimeout = 16, reasonIEMismatch = 17, reasonInvalidGroupCipher = 18, reasonInvalidPairwiseCipher = 19, reasonInvalidAKMP = 20, reasonUnsupportedRSNIE = 21, reasonInvalidRSNIECaps = 22, reason8021XAuthFailed = 23, reasonCipherSuiteRejected = 24, reasonQoS = 32, /* 25-31 reserved */ reasonQoSBandwidthUnavailable = 33, reasonTooManyACKs = 34, reasonTXOPsOutsideLimits = 35, reasonPeerSTALeaving = 36, reasonPeerSTAMechanismRejected = 37, reasonPeerSTAMechanismNeedsSetup= 38, reasonPeerSTATimeout = 39, reasonPeerSTACipherUnsupported = 45, /* 40-44 reserved */ reasonPrivateUnspecified = 0xffff /* our own unspecified failure code */ }; struct IE { enum ID { /* § 7.3.2 Table 7-26 */ ieSSID = 0, ieSupportedRates = 1, ieFHParamSet = 2, ieDSParamSet = 3, ieCFParamSet = 4, ieTIM = 5, ieIBSSParamSet = 6, ieCountry = 7, ieHoppingPatternParams = 8, ieHoppingPatternTable = 9, ieRequest = 10, ieBSSLoad = 11, ieEDCAParamSet = 12, ieTSPEC = 13, ieTCLAS = 14, ieSchedule = 15, ieChallengeText = 16, /* 17-31 reserved */ iePowerConstraint = 32, iePowerCapability = 33, ieTPCRequest = 34, ieTPCReport = 35, ieSupportedChannels = 36, ieChannelSwitchAnnounce = 37, ieMeasurementRequest = 38, ieMeasurementReport = 39, ieQuiet = 40, ieIBSSDFS = 41, ieERPInformation = 42, ieTSDelay = 43, ieTCLASProcessing = 44, /* 45 reserved */ ieQoSCapability = 46, /* 47 reserved */ ieRSN = 48, /* 49 reserved */ ieExtendedSupportedRates= 50, /* 51-125 reserved */ /* 126 reserved */ ieExtendedCapabilities = 127, /* 128-220 reserved */ ieVendorSpecific = 221, /* 222-255 reserved */ }; uint8_t id; // type codes specified in enum ID uint8_t length; // length in bytes of data that follows uint8_t data[0]; // variable length up to 255 bytes } __packed; union Capability { struct { /* § 7.3.1.4 */ bool ESS :1; bool IBSS :1; // indicates Ad-hoc mode bool CFPollable :1; bool CFPollRequest :1; bool Privacy :1; // indicates WEP on/off bool ShortPreamble :1; bool PBCC :1; bool ChannelAgility :1; bool SpectrumMgmt :1; bool QoS :1; bool ShortSlotTime :1; bool APSD :1; bool Reserved :1; bool DSSSOFDM :1; // indicates 11g mode on/off bool DelayedBlockAck :1; bool ImmediateBlockAck:1; } bits __packed; uint16_t value; } __packed; /* Following is the structure of a MAC header present in ALL frames. The remaining * contents of the frame depend on the type/subtype etc. § 7.2 onwards */ struct WiFiFrameHeader { enum FrameType { ManagementFrame = 0, ControlFrame = 1, DataFrame = 2, ReservedFrame = 3 }; enum FrameSubtype { /* Subtype for Management frames: */ AssocRequest = 0, AssocResponse = 1, ReassocRequest = 2, ReassocResponse = 3, ProbeRequest = 4, ProbeResponse = 5, /* 6-7 are reserved */ Beacon = 8, ATIM = 9, Disassoc = 10, Authentication = 11, DeAuthentication= 12, Action = 13, /* 14-15 are reserved */ /* Subtypes for Control frames: */ /* 0-7 are reserved */ BlockAckReq = 8, BlockAck = 9, PSPoll = 10, RTS = 11, CTS = 12, ACK = 13, CFEnd = 14, CFEndPoll = 15, /* Subtypes for Data frames: */ Data = 0, DataCFAck = 1, DataCFPoll = 2, DataCFAckPoll = 3, Null = 4, CFAck = 5, CFPoll = 6, CFAckPoll = 7, QoSData = 8, QoSDataCFAck = 9, QoSDataCFPoll = 10, QoSDataCFAckPoll = 11, QoSNull = 12, /* 13 is reserved */ QoSCFPoll = 14, QoSCFAckCFPoll = 15 }; uint8_t protocolVersion :2; FrameType type :2; FrameSubtype subtype :4; bool toDS :1; bool fromDS :1; bool moreFrag :1; bool retry :1; bool powerSaveMode :1; // Called PwrMgt in spec bool moreData :1; bool protectedFrame :1; bool order :1; uint16_t durationID :16; /* The following is also present in all MAC headers, but we won't * put in here because its meaning depends on the particular frame type IOEthernetAddress addr1; */ } __packed; struct SequenceControl { uint8_t fragmentNumber :4; uint16_t sequenceNumber :12; } __packed; struct ManagementFrameHeader { WiFiFrameHeader hdr; uint8_t da[6]; uint8_t sa[6]; uint8_t bssid[6]; SequenceControl sequenceControl; } __packed; struct ProbeResponseFrameHeader { ManagementFrameHeader mgmt; uint64_t timestamp; uint16_t beaconInterval; uint16_t capability; /* Then follows a variable number of information elements */ uint8_t ieData[0]; } __packed; struct TxDataFrameHeader { WiFiFrameHeader hdr; uint8_t bssid[6]; uint8_t sa[6]; // source MAC addr uint8_t da[6]; // dest MAC addr uint16_t seq; uint8_t data[0]; // variable length } __packed; struct TxQoSDataFrameHeader { WiFiFrameHeader hdr; uint8_t bssid[6]; uint8_t sa[6]; // source MAC addr uint8_t da[6]; // dest MAC addr uint16_t seq; uint16_t qos; uint8_t data[0]; // variable length } __packed; struct EthernetFrameHeader { uint8_t da[6]; uint8_t sa[6]; uint8_t frameType[2]; // always = 0x80 0x00 uint8_t data[0]; // variable length } __packed; } } #endif

This paste will be private.