Ticket #65: libtrace3_wireless_support2.patch

lib/link_wireless.c

@@ +1 @@
+/*
+ * This file is part of libtrace
+ *
+ * link_wireless.c
+ * Implements the trace_get_wireless_* methods defined in libtrace.h
+ *
+ * Copyright (c) 2006 The University of Waikato, Hamilton, New Zealand.
+ * Authors: Scott Raynel 
+ *          Perry Lorier 
+ *          
+ * All rights reserved.
+ *
+ * This code has been developed by the University of Waikato WAND 
+ * research group. For further information please see http://www.wand.net.nz/
+ *
+ * libtrace is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * libtrace is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with libtrace; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include "libtrace.h"
+#include "libtrace_int.h" 
+
+/* Used for Radiotap fields which must be naturally aligned */
+#define ALIGN_NATURAL_64(_p,_s) \
+    while ( (_p - _s) % sizeof(uint64_t)) _p++
+#define ALIGN_NATURAL_32(_p,_s) \
+    while ( (_p - _s) % sizeof(uint32_t)) _p++
+#define ALIGN_NATURAL_16(_p,_s) \
+    while ( (_p - _s) % sizeof(uint16_t)) _p++
+
+/** Gets a field from a Radiotap header.
+ * @param link the radiotap header
+ * @param field the radiotap field we want to access
+ * @return a void pointer to the field. It is up to the caller to cast to the
+ * appropriate type.
+ * @note Radiotap fields are always little-endian
+ */
+static void *trace_get_radiotap_field(void *link, libtrace_radiotap_field_t field)
+{
+    struct libtrace_radiotap_t *rtap = (struct libtrace_radiotap_t *)link;
+    uint8_t *p;
+    uint8_t *s;
+    
+    /* Check if the field exists in the radiotap header before proceeding
+     */
+    if (rtap->it_present & (1 << field) == 0) return NULL;
+
+    /* Skip over any extended bitmasks */
+    p = (uint8_t *) &(rtap->it_present);
+    
+    while ( *((uint32_t*)p) & (1 << TRACE_RADIOTAP_EXT) ) {
+        p += sizeof (uint32_t);
+    }
+
+    /* Point p at the first field of radiotap data and remember it for later
+     * when we're doing field alignment 
+     */
+    p += sizeof(uint32_t);
+    s = p;
+    
+    if (field == TRACE_RADIOTAP_TSFT) 
+        /* Always aligned */
+        return (void*)p;
+    if (rtap->it_present & (1 << TRACE_RADIOTAP_TSFT))
+        p += sizeof (uint64_t);
+
+    if (field == TRACE_RADIOTAP_FLAGS)
+        /* Always aligned */
+        return (void*)p;
+    if (rtap->it_present & (1 << TRACE_RADIOTAP_FLAGS))
+        p += sizeof (uint8_t);
+
+    if (field == TRACE_RADIOTAP_RATE)
+        /* Always aligned */
+        return (void*)p;
+    if (rtap->it_present & (1 << TRACE_RADIOTAP_RATE))
+        p+= sizeof (uint8_t);
+
+    if (field == TRACE_RADIOTAP_CHANNEL)
+    {
+        ALIGN_NATURAL_16(p,s);
+        return (void *)p;
+    }
+    if (rtap->it_present & (1 << TRACE_RADIOTAP_CHANNEL))
+        p+= sizeof (uint32_t);
+
+    if (field == TRACE_RADIOTAP_FHSS)
+    {
+        ALIGN_NATURAL_16(p,s);
+        return (void *)p;
+    }
+    if (rtap->it_present & (1 << TRACE_RADIOTAP_FHSS))
+        p+= sizeof (uint16_t);
+
+    if (field == TRACE_RADIOTAP_DBM_ANTSIGNAL)
+        return (void *)p;
+    if (rtap->it_present & (1 << TRACE_RADIOTAP_DBM_ANTSIGNAL))
+        p+= sizeof (uint8_t);
+
+    if (field == TRACE_RADIOTAP_DBM_ANTNOISE)
+        return (void *)p;
+    if (rtap->it_present & (1 << TRACE_RADIOTAP_DBM_ANTNOISE))
+        p+= sizeof (uint8_t);
+
+    if (field == TRACE_RADIOTAP_LOCK_QUALITY)
+    {
+        ALIGN_NATURAL_16(p,s);
+        return (void *)p;
+    }
+    if (rtap->it_present & (1 << TRACE_RADIOTAP_LOCK_QUALITY))
+        p+= sizeof (uint16_t);
+
+    if (field == TRACE_RADIOTAP_TX_ATTENUATION)
+    {
+        ALIGN_NATURAL_16(p,s);
+        return (void *)p;
+    }
+    if (rtap->it_present & (1 << TRACE_RADIOTAP_TX_ATTENUATION))
+        p+= sizeof (uint16_t);
+
+    if (field == TRACE_RADIOTAP_DB_TX_ATTENUATION)
+    {
+        ALIGN_NATURAL_16(p,s);
+        return (void *)p;
+    }
+    if (rtap->it_present & (1 << TRACE_RADIOTAP_DB_TX_ATTENUATION))
+        p+= sizeof (uint16_t);
+
+    if (field == TRACE_RADIOTAP_DBM_TX_POWER)
+        return (void *)p;
+    if (rtap->it_present & (1 << TRACE_RADIOTAP_DBM_TX_POWER))
+        p+= sizeof (uint8_t);
+    
+    if (field == TRACE_RADIOTAP_ANTENNA)
+        return (void *)p;
+    if (rtap->it_present & (1 << TRACE_RADIOTAP_ANTENNA))
+        p+= sizeof (uint8_t);
+
+    if (field == TRACE_RADIOTAP_DB_ANTSIGNAL)
+        return (void *)p;
+    if (rtap->it_present & (1 << TRACE_RADIOTAP_DB_ANTSIGNAL))
+        p+= sizeof (uint8_t);
+
+    if (field == TRACE_RADIOTAP_DB_ANTNOISE)
+        return (void *) p;
+    if (rtap->it_present & (1 << TRACE_RADIOTAP_DB_ANTNOISE))
+        p+= sizeof (uint8_t);
+    
+    if (field == TRACE_RADIOTAP_FCS)
+        ALIGN_NATURAL_32(p,s);
+        return (void *)p;
+
+    /* Unknown field */
+    return NULL;
+} 
+    
+DLLEXPORT bool trace_get_wireless_tsft(void *link, 
+        libtrace_linktype_t linktype, uint64_t *tsft)
+{
+    uint64_t *p;
+
+    if (link == NULL || tsft == NULL) return false;
+
+    switch (linktype) {
+        case TRACE_TYPE_80211_RADIO:
+            if( p = (uint64_t *) trace_get_radiotap_field(link, 
+                        TRACE_RADIOTAP_TSFT)) {
+                *tsft = bswap_le_to_host64(*p);
+                return true;
+            } else break;
+            
+        case TRACE_TYPE_80211_PRISM:
+            return false;
+    }
+    /* Unsupported link type */
+    return false;
+}
+
+DLLEXPORT bool trace_get_wireless_flags(void *link, 
+        libtrace_linktype_t linktype, uint8_t *flags)
+{
+    uint8_t *p;
+    
+    if (link == NULL || flags == NULL) return false;
+    
+    switch(linktype) {
+        case TRACE_TYPE_80211_RADIO:
+            if ( p = (uint8_t *) trace_get_radiotap_field(link,
+                TRACE_RADIOTAP_FLAGS)) {
+                *flags = *p;
+                return true;
+            } else break;
+    }
+    /* Unsupported link type */
+    return false;
+}
+
+DLLEXPORT bool trace_get_wireless_rate(void *link, 
+        libtrace_linktype_t linktype, uint8_t *rate)
+{
+    uint8_t * p;
+    if (link == NULL || rate == NULL) return false ;
+    switch (linktype) {
+        case TRACE_TYPE_80211_RADIO:
+            if ( p = (uint8_t *) trace_get_radiotap_field(link,
+                TRACE_RADIOTAP_RATE)) {
+                *rate = *p;
+                return true;
+            } else break;
+            
+    }
+    return false;
+}
+
+DLLEXPORT bool trace_get_wireless_freq(void *link, 
+        libtrace_linktype_t linktype, uint16_t *freq)
+{
+    uint16_t *p;
+
+    if (link == NULL || freq == NULL) return false;
+    switch (linktype) {
+        case TRACE_TYPE_80211_RADIO:
+            /* NB: The channel field is actually two 16 bit fields. 
+             * The chan_freq field is the first of those two, so we
+             * just cast it to a uint16_t.
+             */
+            if ( p = (uint16_t *) trace_get_radiotap_field(link,
+                    TRACE_RADIOTAP_CHANNEL)) {
+                *freq = bswap_le_to_host16(*p);
+                return true;
+            } else break;
+    }
+    return false;
+}
+   
+DLLEXPORT bool trace_get_wireless_channel_flags(void *link,
+        libtrace_linktype_t linktype, uint16_t *flags)
+{
+    uint16_t *p;
+    if (link == NULL || flags == NULL) return false;
+    switch (linktype) {
+        case TRACE_TYPE_80211_RADIO:
+            /* NB: The channel field is actually two 16 bit fields.
+             * The chan_flags field is the second of the two, so we need
+             * to take the pointer returned by getting the channel field
+             * and increment it.
+             */
+            if (p = (uint16_t *) trace_get_radiotap_field(link,
+                    TRACE_RADIOTAP_CHANNEL)) {
+                *flags = bswap_le_to_host16(*(p++));
+                return true;
+            } else break;
+    }
+    return false;
+}
+
+DLLEXPORT bool trace_get_wireless_fhss_hopset(void *link,
+        libtrace_linktype_t linktype, uint8_t *hopset)
+{
+    uint8_t *p;
+    
+    if (link == NULL || hopset == NULL) return false;
+    switch(linktype) {
+        case TRACE_TYPE_80211_RADIO:
+            /* NB: As above with the channel field, the fhss field is
+             * similar.
+             */
+            if( p = (uint8_t *) trace_get_radiotap_field(link,
+                    TRACE_RADIOTAP_FHSS)) {
+                *hopset = *p;
+                return true;
+            } else break;
+    }
+    return false;
+}
+
+DLLEXPORT bool trace_get_wireless_fhss_hoppattern(void *link,
+        libtrace_linktype_t linktype, uint8_t *hoppattern)
+{
+    uint8_t *p;
+    if (link == NULL || hoppattern == NULL) return false;
+    switch (linktype) {
+        case TRACE_TYPE_80211_RADIO:
+            if(p = (uint8_t *) trace_get_radiotap_field(link,
+                    TRACE_RADIOTAP_FHSS)) {
+                *hoppattern = *(p++);
+                return true;
+            } else break;
+    }
+    return false;
+}
+
+DLLEXPORT bool trace_get_wireless_signal_strength_dbm(void *link,
+        libtrace_linktype_t linktype, int8_t *strength)
+{
+    int8_t *p;
+    
+    if (link == NULL || strength == NULL) return false;
+    switch(linktype) {
+        case TRACE_TYPE_80211_RADIO:
+            if (p =  (int8_t *) trace_get_radiotap_field(link,
+                    TRACE_RADIOTAP_DBM_ANTSIGNAL)) {
+                *strength = *p;
+                return true;
+            } else break;
+    }
+    return false;
+}
+
+DLLEXPORT bool trace_get_wireless_noise_strength_dbm(void *link,
+        libtrace_linktype_t linktype, int8_t *strength)
+{
+    uint8_t *p;
+    if (link == NULL || strength == NULL) return false;
+    switch (linktype) {
+        case TRACE_TYPE_80211_RADIO:
+            if ( p = (int8_t *) trace_get_radiotap_field(link,
+                    TRACE_RADIOTAP_DBM_ANTNOISE)) {
+                *strength = *p;
+                return true;
+            } else break;
+    }
+    return false;
+}
+
+DLLEXPORT bool trace_get_wireless_signal_strength_db(void *link,
+        libtrace_linktype_t linktype, uint8_t *strength)
+{
+    uint8_t *p;
+    
+    if (link == NULL || strength == NULL) return false;
+    switch (linktype) {
+        case TRACE_TYPE_80211_RADIO:
+            if (p =  (uint8_t *) trace_get_radiotap_field(link,
+                    TRACE_RADIOTAP_DB_ANTSIGNAL)) {
+                *strength = *p;
+                return true;
+            } else break;
+    }
+    return false ;
+}
+
+DLLEXPORT bool trace_get_wireless_noise_strength_db(void *link,
+        libtrace_linktype_t linktype, uint8_t *strength)
+{
+    uint8_t *p;
+    
+    if (link == NULL || strength == NULL) return false;
+    switch (linktype) {
+        case TRACE_TYPE_80211_RADIO:
+            if (p = (uint8_t *) trace_get_radiotap_field(link,
+                    TRACE_RADIOTAP_DB_ANTNOISE)) {
+                *strength = *p;
+                return true;
+            } else break;
+    }
+    return false;
+}
+
+DLLEXPORT bool trace_get_wireless_lock_quality(void *link,
+        libtrace_linktype_t linktype, uint16_t *quality)
+{
+    uint16_t *p;
+    
+    if (link == NULL || quality == NULL) return false;
+    switch (linktype) {
+        case TRACE_TYPE_80211_RADIO:
+            if(p = (uint16_t *) trace_get_radiotap_field(link,
+                    TRACE_RADIOTAP_LOCK_QUALITY)) {
+                *quality = bswap_le_to_host16(*p);
+                return true;
+            } else break;
+    }
+    return false;
+}
+
+DLLEXPORT bool trace_get_wireless_tx_attenuation(void *link,
+        libtrace_linktype_t linktype, uint16_t *attenuation)
+{
+    uint16_t *p;
+    if (link == NULL || attenuation == 0) return false;
+    switch (linktype) {
+        case TRACE_TYPE_80211_RADIO:
+            if (p = (uint16_t *) trace_get_radiotap_field(link,
+                    TRACE_RADIOTAP_TX_ATTENUATION)) {
+                *attenuation = bswap_le_to_host16(*p);
+                return true;
+            } else break;
+    }
+    return false;
+}
+
+DLLEXPORT bool trace_get_wireless_tx_attenuation_db(void *link,
+        libtrace_linktype_t linktype, uint16_t *attenuation)
+{
+    uint16_t *p;
+    if (link == NULL || attenuation == NULL) return false;
+    switch (linktype) {
+        case TRACE_TYPE_80211_RADIO:
+            if (p = (uint16_t *) trace_get_radiotap_field(link,
+                    TRACE_RADIOTAP_DB_TX_ATTENUATION)) {
+                *attenuation = bswap_le_to_host16(*p);
+                return true;
+            } else break;
+    }
+    return false;
+}
+
+DLLEXPORT bool trace_get_wireless_tx_power_dbm(void *link,
+        libtrace_linktype_t linktype, int8_t *txpower)
+{
+    int8_t *p;
+    
+    if (link == NULL || txpower == NULL) return false;
+    switch (linktype) {
+        case TRACE_TYPE_80211_RADIO:
+            if (p=(int8_t *) trace_get_radiotap_field(link,
+                    TRACE_RADIOTAP_DBM_TX_POWER)) {
+                *txpower = *p;
+                return true;
+            } else break;
+    }
+    return false;
+}
+
+
+DLLEXPORT bool trace_get_wireless_antenna(void *link,
+        libtrace_linktype_t linktype, uint8_t *antenna)
+{
+    uint8_t *p;
+    if (link == NULL || antenna == NULL) return false;
+    switch (linktype) {
+        case TRACE_TYPE_80211_RADIO:
+            if (p = (uint8_t *) trace_get_radiotap_field(link,
+                    TRACE_RADIOTAP_ANTENNA)) {
+                *antenna = *p;
+                return true;
+            } else break;
+    }
+    return false;
+}
+
+DLLEXPORT bool trace_get_wireless_fcs(void *link,
+        libtrace_linktype_t linktype, uint32_t *fcs)
+{
+    uint32_t *p;
+    if (link == NULL || fcs == NULL) return false;
+    switch (linktype) {
+        case TRACE_TYPE_80211_RADIO:
+            if (p = (uint32_t *) trace_get_radiotap_field(link,
+                    TRACE_RADIOTAP_FCS)) {
+                *fcs = bswap_le_to_host32(*p);
+                return true;
+            } else break;
+    }
+    return false;
+}
+

lib/protocols.c

@@ -170 +170 @@
                 uint16_t *type, uint32_t *remaining)
 {
         libtrace_pflog_header_t *pflog = (libtrace_pflog_header_t*)link;
-        if (remaining) {
+    if (remaining) {
                 if (*remaining<sizeof(*pflog)) 
                         return NULL;
                 *remaining-=sizeof(*pflog);
@@ -187 +187 @@
         return (void*)((char*)pflog+ sizeof(*pflog));
 }
 
+/* Returns the 'payload' of the prism header, which is the 802.11 frame */
+static void *trace_get_payload_from_prism (void *link,
+        uint16_t *type, uint32_t *remaining)
+{
+    if (remaining) {
+        if (*remaining<144) 
+            return NULL;
+        *remaining-=144;
+    }
+
+    if (type) *type = 0;
+
+    return (void *) ((char*)link+144);
+}
+
+/* Returns the 'payload' of the radiotap header, which is the 802.11 frame */
+static void *trace_get_payload_from_radiotap (void *link, 
+        uint16_t *type, uint32_t *remaining)
+{
+    struct libtrace_radiotap_t *rtap = (struct libtrace_radiotap_t*)link;
+    if (remaining) {
+                if (*remaining<rtap->it_len) 
+                        return NULL;
+                *remaining-=rtap->it_len;
+        }
+
+        if (type) *type = 0;
+    
+        return (void*) ((char*)link + rtap->it_len);
+}
+        
 void *trace_get_payload_from_link(void *link, libtrace_linktype_t linktype, 
                 uint16_t *type, uint32_t *remaining)
 {
+    void *l;
+    
         switch(linktype) {
                 case TRACE_TYPE_80211_PRISM:
-                        return trace_get_payload_from_80211((char*)link+144,
-                                        type,remaining);
+            l = trace_get_payload_from_prism(link,type,remaining);
+            l ? trace_get_payload_from_80211(l,type,remaining) : NULL;
+        case TRACE_TYPE_80211_RADIO:
+            l = trace_get_payload_from_radiotap(link,type,remaining);
+            l ? trace_get_payload_from_80211(l,type,remaining) : NULL ;
                 case TRACE_TYPE_80211:
                         return trace_get_payload_from_80211(link,type,remaining);
                 case TRACE_TYPE_ETH:

lib/libtrace.h.in

@@ -216 +216 @@
         TRACE_DLT_ATM_RFC1483 = 11,
         TRACE_DLT_IEEE802_11 = 105,
         TRACE_DLT_LINUX_SLL = 113,
-        TRACE_DLT_PFLOG = 117
+        TRACE_DLT_PFLOG = 117,
+    TRACE_DLT_IEEE802_11_RADIO = 127 /**< Radiotap */
 } libtrace_dlt_t ;
 
 /** Enumeration of link layer types supported by libtrace */
@@ -235 +236 @@
     /* TRACE_TYPE_LEGACY_ETH            Obsolete */
        TRACE_TYPE_80211_PRISM = 12,
        TRACE_TYPE_AAL5 = 13,
-       TRACE_TYPE_DUCK = 14             /**< Pseudo link layer for DUCK packets */
+       TRACE_TYPE_DUCK = 14,            /**< Pseudo link layer for DUCK packets */
+       TRACE_TYPE_80211_RADIO = 15 /**< Radiotap + 802.11 */
      } libtrace_linktype_t;
 
 /** Trace directions 
@@ -814 +816 @@
                 uint32_t *remaining);
 
 
-/** Gets a pointer to the payload given a pointer to the IP header
+/** Gets a pointer to the payload given a pointer to the Radiotap header
+ * @param link a pointer to the Radiotap header
+ * @param[out] type     An output variable of the ethernet type
+ * @param[in,out] remaining Updated with the number of bytes remaining
+ *
+ * @return a pointer to the 802.11 header, or NULL if header isn't
+ * present.
+ *
+ * Remaining may be NULL.  If Remaining is not NULL it must point to the number
+ * of bytes captured of the linklayer and beyond.  It will be updated after
+ * this function to the number of bytes remaining after the Radiotap header has been 
+ * removed.
+ *
+ * type may be NULL if not needed.
+ */
+DLLEXPORT void *trace_get_payload_from_radiotap(void *link,
+                uint16_t *type, uint32_t *remaining);
+
+
+/** Gets a pointer to the payload given a pointer to the Prism monitoring header
+ * @param link a pointer to the Prism monitoring header
+ * @param[out] type     An output variable of the ethernet type
+ * @param[in,out] remaining Updated with the number of bytes remaining
+ *
+ * @return a pointer to the 802.11 header, or NULL if header isn't
+ * present.
+ *
+ * Remaining may be NULL.  If Remaining is not NULL it must point to the number
+ * of bytes captured of the linklayer and beyond.  It will be updated after
+ * this function to the number of bytes remaining after the Radiotap header has been 
+ * removed.
+ *
+ * type may be NULL if not needed.
+ */
+DLLEXPORT void *trace_get_payload_from_prism(void *link,
+                uint16_t *type, uint32_t *remaining);
+
+
+/** Gets a pointer to the payload given a pointer to the link header
  * @param ip            The link pointer
  * @param[out] type     An output variable of the ethernet type
  * @param[in,out] remaining Updated with the number of bytes remaining
@@ -828 +868 @@
  * IP options) have been removed.
  *
  * type may be NULL if not needed.
+ *
  */
 DLLEXPORT void *trace_get_payload_from_link(void *link,
                 libtrace_linktype_t linktype, 
@@ -1298 +1339 @@
 void trace_construct_packet(libtrace_packet_t *packet,
                 libtrace_linktype_t linktype, const void *data, uint16_t len);
 
+/*@}*/
 
+/** @name Wireless trace support
+ * Functions to access wireless information from packets that have wireless
+ * monitoring headers such as Radiotap or Prism.
+ * 
+ * The trace_get_wireless_* functions provide an abstract interface for
+ * retrieving information from wireless traces. They take a pointer to the
+ * wireless monitoring header (usually found with trace_get_link(packet)) and
+ * the linktype of the header passed in.
+ * 
+ * All of the trace_get_wireless_* functions return false if the requested
+ * information was unavailable, or true if it was. The actual data is stored
+ * in an output variable supplied by the caller. Values returned into the 
+ * output variable will always be returned in host byte order.
+ * @{
+ */
+
+
+#ifndef ARPHRD_80211_RADIOTAP
+/* libc doesn't define this yet, but it seems to be what everyone is using
+ */
+#define ARPHRD_80211_RADIOTAP 803
+#endif
+
+/** Radiotap field selectors
+ */
+typedef enum {
+    TRACE_RADIOTAP_TSFT = 0,
+    TRACE_RADIOTAP_FLAGS = 1,
+    TRACE_RADIOTAP_RATE = 2,
+    TRACE_RADIOTAP_CHANNEL = 3,
+    TRACE_RADIOTAP_FHSS = 4,
+    TRACE_RADIOTAP_DBM_ANTSIGNAL = 5,
+    TRACE_RADIOTAP_DBM_ANTNOISE = 6,
+    TRACE_RADIOTAP_LOCK_QUALITY = 7,
+    TRACE_RADIOTAP_TX_ATTENUATION = 8,
+    TRACE_RADIOTAP_DB_TX_ATTENUATION = 9,
+    TRACE_RADIOTAP_DBM_TX_POWER = 10,
+    TRACE_RADIOTAP_ANTENNA = 11,
+    TRACE_RADIOTAP_DB_ANTSIGNAL = 12,
+    TRACE_RADIOTAP_DB_ANTNOISE = 13,
+    TRACE_RADIOTAP_FCS = 14,
+    TRACE_RADIOTAP_EXT = 31,
+} libtrace_radiotap_field_t;
+
+/** The Radiotap header pre-amble
+ *
+ * All Radiotap headers start with this pre-amble, followed by the fields
+ * specified in the it_present bitmask. If bit 31 of it_present is set, then
+ * another bitmask follows.
+ * NB: All of the radiotap data fields are in little-endian byte-order.
+ */
+typedef struct libtrace_radiotap_t {
+    uint8_t     it_version; /**< Radiotap version */
+    uint8_t     it_pad; /**< Padding for natural alignment */
+    uint16_t    it_len; /**< Length in bytes of the entire Radiotap header */
+    uint32_t    it_present; /**< Which Radiotap fields are present */
+} libtrace_radiotap_t;
+
+/** Get the wireless Timer Syncronisation Function
+ *
+ * Gets the value of the timer syncronisation function for this frame, which
+ * is a value in microseconds indicating the time that the first bit of the
+ * MPDU was received by the MAC.
+ *
+ * @param link the wireless header
+ * @param linktype the linktype of the wireless header passed in 
+ * @param[out] tsft the value of the timer syncronisation function. 
+ * @return true if the field was available, false if not.
+ */
+DLLEXPORT bool trace_get_wireless_tsft(void *link,
+        libtrace_linktype_t linktype, uint64_t *tsft);
+
+/** Get the wireless flags 
+ * @param link the wireless header
+ * @param linktype the linktype of the wireless header passed in
+ * @param[out] flags the wireless flags.
+ * @return true if the field was available, false if not.
+ */
+DLLEXPORT bool trace_get_wireless_flags(void *link,
+        libtrace_linktype_t linktype, uint8_t *flags);
+
+/** Get the wireless rate 
+ * @param link the wireless header
+ * @param linktype the linktype of the wireless header passed in
+ * @param[out] rate the data-rate of the frame in units of 500kbps
+ * @return true if the field was available, false if not.
+ */
+DLLEXPORT bool trace_get_wireless_rate(void *link,
+        libtrace_linktype_t linktype, uint8_t *rate);
+
+/** Get the wireless channel frequency
+ * @param link the wireless header
+ * @param linktype the linktype of the wireless header passed in
+ * @param[out] freq the frequency in MHz of the channel the frame was transmitted
+ * or received on.
+ * @return true if the field was available, false if not.
+ */
+DLLEXPORT bool trace_get_wireless_freq(void *link,
+        libtrace_linktype_t linktype, uint16_t *freq);
+
+/** Get the wireless channel flags
+ * @param link the wireless header
+ * @param linktype the linktype of the wireless header passed in
+ * @param[out] flags the channel flags
+ * @return true if the field was available, false if not.
+ */
+DLLEXPORT bool trace_get_wireless_channel_flags(void *link,
+        libtrace_linktype_t linktype, uint16_t *flags);
+
+/** Get the wireless FHSS Hop Set 
+ * @param link the wireless header
+ * @param linktype the linktype of the wireless header passed in
+ * @param[out] hopset the fhss hop set
+ * @return true if the field was available, false if not.
+ */
+DLLEXPORT bool trace_get_wireless_fhss_hopset(void *link,
+        libtrace_linktype_t linktype, uint8_t *hopset);
+        
+/** Get the wireless FHSS Hop Pattern 
+ * @param link the wireless header
+ * @param linktype the linktype of the wireless header passed in
+ * @param[out] hoppattern the fhss hoppattern
+ * @return true if the field was available, false if not.
+ */
+DLLEXPORT bool trace_get_wireless_fhss_hoppattern(void *link,
+        libtrace_linktype_t linktype, uint8_t *hoppattern);
+
+/** Get the wireless signal strength in dBm 
+ * @param link the wireless header
+ * @param linktype the linktype of the wireless header passed in
+ * @param[out] strength the RF signal power at the antenna, in dB difference
+ * from 1mW.
+ * @return true if the field was available, false if not.
+ */
+DLLEXPORT bool trace_get_wireless_signal_strength_dbm(void *link,
+        libtrace_linktype_t linktype, int8_t *strength);
+
+/** Get the wireless noise strength in dBm
+ * @param link the wireless header
+ * @param linktype the linktype of the wireless header passed in
+ * @param[out] strength the RF noise power at the antenna, in dB difference 
+ * from 1mW. 
+ * @return true if the field was available, false if not.
+ */
+DLLEXPORT bool trace_get_wireless_noise_strength_dbm(void *link,
+        libtrace_linktype_t linktype, int8_t *strength);
+
+/** Get the wireless signal strength in dB
+ * @param link the wireless header
+ * @param linktype the linktype of the wireless header passed in
+ * @param[out] strength the RF signal power at the antenna,in dB difference 
+ * from a fixed reference. 
+ * @return true if the field was available, false if not.
+ */
+DLLEXPORT bool trace_get_wireless_signal_strength_db(void *link,
+        libtrace_linktype_t linktype, uint8_t *strength);
+
+/** Get the wireless noise strength in dB 
+ * @param link the wireless header
+ * @param linktype the linktype of the wireless header passed in
+ * @param[out] strength the RF noise power at the antenna, in dB difference 
+ * from a fixed reference. 
+ * @return true if the field was available, false if not.
+ */
+DLLEXPORT bool trace_get_wireless_noise_strength_db(void *link,
+        libtrace_linktype_t linktype, uint8_t *strength);
+
+/** Get the wireless Barker code lock quality 
+ * @param link the wireless header
+ * @param linktype the linktype of the wireless header passed in
+ * @param[out] quality the quality of the Barker Code lock.
+ * @return true if the field was available, false if not.
+ */
+DLLEXPORT bool trace_get_wireless_lock_quality(void *link,
+        libtrace_linktype_t linktype, uint16_t *quality);
+
+/** Get the wireless transmit attenuation 
+ * @param link the wireless header
+ * @param linktype the linktype of the wireless header passed in
+ * @param[out] attenuation the transmit power as a unitless distance from maximum 
+ * power set at factory calibration. 0 indicates maximum transmission power.
+ * @return true if the field was available, false if not.
+ */
+DLLEXPORT bool trace_get_wireless_tx_attenuation(void *link,
+        libtrace_linktype_t linktype, uint16_t *attenuation);
+
+/** Get the wireless transmit attenuation in dB
+ * @param link the wireless header
+ * @param linktype the linktype of the wireless header passed in
+ * @param[out] attenuation the transmit power as dB difference from maximum power 
+ * set at factory calibration. 0 indicates maximum power.
+ * @return true if the field was available, false if not.
+ */
+DLLEXPORT bool trace_get_wireless_tx_attenuation_db(void *link,
+        libtrace_linktype_t linktype, uint16_t *attenuation);
+
+/** Get the wireless transmit power in dBm 
+ * @param link the wireless header
+ * @param linktype the linktype of the wireless header passed in
+ * @param[out] txpower the transmit power as dB from a 1mW reference. This is the 
+ * absolute power level measured at the antenna port.
+ * @return true if the field was available, false if not.
+ */
+DLLEXPORT bool trace_get_wireless_tx_power_dbm(void *link,
+        libtrace_linktype_t linktype, int8_t *txpower);
+
+/** Get the wireless antenna 
+ * @param link the wireless header
+ * @param linktype the linktype of the wireless header passed in
+ * @param[out] antenna which antenna was used to transmit or receive the frame.
+ * @return true if the field was available, false if not.
+ */
+DLLEXPORT bool trace_get_wireless_antenna(void *link,
+        libtrace_linktype_t linktype, uint8_t *antenna);
+
+/** Get the wireless Frame Check Sequence field
+ * @param link the wireless header
+ * @param linktype the linktype of the wireless header passed in
+ * @param[out] fcs the Frame Check Sequence of the frame. 
+ * @return true if the field was available, false if not.
+ */
+DLLEXPORT bool trace_get_wireless_fcs(void *link,
+        libtrace_linktype_t linktype, uint32_t *fcs);
+
+/*@}*/
+
 #ifdef __cplusplus
 } /* extern "C" */
 #endif /* #ifdef __cplusplus */

lib/format_linux.c

@@ -50 +50 @@
 #include <sys/ioctl.h>
 #include <errno.h>
 
+
 struct libtrace_format_data_t {
         int fd;
         int snaplen;
@@ -308 +309 @@
                         return TRACE_TYPE_ETH;
                 case ARPHRD_PPP:
                         return TRACE_TYPE_NONE;
+        case ARPHRD_80211_RADIOTAP:
+            return TRACE_TYPE_80211_RADIO;
                 default: /* shrug, beyond me! */
                         printf("unknown Linux ARPHRD type 0x%04x\n",linktype);
                         return (libtrace_linktype_t)~0U;

lib/linktypes.c

@@ -35 +35 @@
                 case TRACE_DLT_IEEE802_11: return TRACE_TYPE_80211;
                 case TRACE_DLT_LINUX_SLL: return TRACE_TYPE_LINUX_SLL;
                 case TRACE_DLT_PFLOG: return TRACE_TYPE_PFLOG;
+        case TRACE_DLT_IEEE802_11_RADIO: return TRACE_TYPE_80211_RADIO;
         }
         return ~0;
 }
@@ -48 +49 @@
                 case TRACE_TYPE_80211: return TRACE_DLT_IEEE802_11;
                 case TRACE_TYPE_LINUX_SLL: return TRACE_DLT_LINUX_SLL;
                 case TRACE_TYPE_PFLOG: return TRACE_DLT_PFLOG;
+        case TRACE_TYPE_80211_RADIO: return TRACE_DLT_IEEE802_11_RADIO;
         }
         return ~0;
 }

lib/Makefile.am

@@ -19 +19 @@
                 format_rt.c format_helper.c format_helper.h format_pcapfile.c \
                 format_duck.c $(NATIVEFORMATS) \
                 parse_cmd.c parse_cmd.h libtrace_int.h lt_inttypes.h \
-                linktypes.c protocols.c libtraceio.h 
+                linktypes.c protocols.c libtraceio.h link_wireless.c 
 
 if DAG2_4
 nodist_libtrace_la_SOURCES = dagopts.c dagapi.c