wiretap/peektagged.c

   1 /* peektagged.c
   2  * Routines for opening files in what Savvius (formerly WildPackets) calls
   3  * the tagged file format in the description of their "PeekRdr Sample
   4  * Application" (C++ source code to read their capture files, downloading
   5  * of which requires a maintenance contract, so it's not free as in beer
   6  * and probably not as in speech, either).
   7  *
   8  * As that description says, it's used by AiroPeek and AiroPeek NX 2.0
   9  * and later, EtherPeek 6.0 and later, EtherPeek NX 3.0 and later,
  10  * EtherPeek VX 1.0 and later, GigaPeek NX 1.0 and later, Omni3 1.0
  11  * and later (both OmniPeek and the Remote Engine), and WANPeek NX
  12  * 1.0 and later.  They also say it'll be used by future Savvius
  13  * products.
  14  *
  15  * Wiretap Library
  16  * Copyright (c) 1998 by Gilbert Ramirez <gram@alumni.rice.edu>
  17  *
  18  * This program is free software; you can redistribute it and/or
  19  * modify it under the terms of the GNU General Public License
  20  * as published by the Free Software Foundation; either version 2
  21  * of the License, or (at your option) any later version.
  22  *
  23  * This program is distributed in the hope that it will be useful,
  24  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  25  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26  * GNU General Public License for more details.
  27  *
  28  * You should have received a copy of the GNU General Public License
  29  * along with this program; if not, write to the Free Software
  30  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  31  */
  32
  33 #include "config.h"
  34 #include <errno.h>
  35 #include <string.h>
  36 #include <stdlib.h>
  37 #include "wtap-int.h"
  38 #include "file_wrappers.h"
  39 #include "peektagged.h"
  40 #include <wsutil/frequency-utils.h>
  41
  42 /* CREDITS
  43  *
  44  * This file decoder could not have been writen without examining
  45  * http://www.varsanofiev.com/inside/airopeekv9.htm, the help from
  46  * Martin Regner and Guy Harris, and the etherpeek.c file (as it
  47  * was called before renaming it to peekclassic.c).
  48  */
  49
  50 /*
  51  * Section header.
  52  *
  53  * A Peek tagged file consists of multiple sections, each of which begins
  54  * with a header in the following format.
  55  *
  56  * The section ID is a 4-character string saying what type of section
  57  * it is.  The section length is a little-endian field giving the
  58  * length of the section, in bytes, including the section header
  59  * itself.  The other field of the section header is a little-endian
  60  * constant that always appears to be 0x00000200.
  61  *
  62  * Files we've seen have the following sections, in order:
  63  *
  64  * "\177vers" - version information.  The contents are XML, giving
  65  * the file format version and application version information.
  66  *
  67  * "sess" - capture session information.  The contents are XML, giving
  68  * various information about the capture session.
  69  *
  70  * "pkts" - captured packets.  The contents are binary records, one for
  71  * each packet, with the record being a list of tagged values followed
  72  * by the raw packet data.
  73  */
  74 typedef struct peektagged_section_header {
  75         gint8   section_id[4];          /* string identifying the section */
  76         guint32 section_len;            /* little-endian section length */
  77         guint32 section_const;          /* little-endian 0x00000200 */
  78 } peektagged_section_header_t;
  79
  80 /*
  81  * Network subtype values.
  82  *
  83  * XXX - do different network subtype values for 802.11 indicate different
  84  * network adapter types, with some adapters supplying the FCS and others
  85  * not supplying the FCS?
  86  */
  87 #define PEEKTAGGED_NST_ETHERNET         0
  88 #define PEEKTAGGED_NST_802_11           1       /* 802.11 with 0's at the end */
  89 #define PEEKTAGGED_NST_802_11_2         2       /* 802.11 with 0's at the end */
  90 #define PEEKTAGGED_NST_802_11_WITH_FCS  3       /* 802.11 with FCS at the end */
  91
  92 /* tags for fields in packet header */
  93 #define TAG_PEEKTAGGED_LENGTH                   0x0000
  94 #define TAG_PEEKTAGGED_TIMESTAMP_LOWER          0x0001
  95 #define TAG_PEEKTAGGED_TIMESTAMP_UPPER          0x0002
  96 #define TAG_PEEKTAGGED_FLAGS_AND_STATUS         0x0003  /* upper 24 bits unused? */
  97 #define TAG_PEEKTAGGED_CHANNEL                  0x0004
  98 #define TAG_PEEKTAGGED_DATA_RATE_OR_MCS_INDEX   0x0005
  99 #define TAG_PEEKTAGGED_SIGNAL_PERC              0x0006
 100 #define TAG_PEEKTAGGED_SIGNAL_DBM               0x0007
 101 #define TAG_PEEKTAGGED_NOISE_PERC               0x0008
 102 #define TAG_PEEKTAGGED_NOISE_DBM                0x0009
 103 #define TAG_PEEKTAGGED_UNKNOWN_0x000A           0x000A
 104 #define TAG_PEEKTAGGED_CENTER_FREQUENCY         0x000D  /* Frequency */
 105 #define TAG_PEEKTAGGED_UNKNOWN_0x000E           0x000E  /* "Band"? */
 106 #define TAG_PEEKTAGGED_UNKNOWN_0x000F           0x000F  /* antenna 2 signal dBm? */
 107 #define TAG_PEEKTAGGED_UNKNOWN_0x0010           0x0010  /* antenna 3 signal dBm? */
 108 #define TAG_PEEKTAGGED_UNKNOWN_0x0011           0x0011  /* antenna 4 signal dBm? */
 109 #define TAG_PEEKTAGGED_UNKNOWN_0x0012           0x0012  /* antenna 2 noise dBm? */
 110 #define TAG_PEEKTAGGED_UNKNOWN_0x0013           0x0013  /* antenna 3 noise dBm? */
 111 #define TAG_PEEKTAGGED_UNKNOWN_0x0014           0x0014  /* antenna 4 noise dBm? */
 112 #define TAG_PEEKTAGGED_EXT_FLAGS                0x0015  /* Extended flags for 802.11n and beyond */
 113
 114 #define TAG_PEEKTAGGED_SLICE_LENGTH             0xffff
 115
 116 /*
 117  * Flags.
 118  *
 119  * We're assuming here that the "remote Peek" flags from bug 9586 are
 120  * the same as the "Peek tagged" flags.
 121  */
 122 #define FLAGS_CONTROL_FRAME     0x01    /* Frame is a control frame */
 123 #define FLAGS_HAS_CRC_ERROR     0x02    /* Frame has a CRC error */
 124 #define FLAGS_HAS_FRAME_ERROR   0x04    /* Frame has a frame error */
 125
 126 /*
 127  * Status.
 128  *
 129  * Is this in the next 8 bits of the "flags and status" field?
 130  */
 131 #define STATUS_PROTECTED        0x0400  /* Frame is protected (encrypted) */
 132 #define STATUS_DECRYPT_ERROR    0x0800  /* Error decrypting protected frame */
 133 #define STATUS_SHORT_PREAMBLE   0x4000  /* Short preamble */
 134
 135 /*
 136  * Extended flags.
 137  *
 138  * Some determined from bug 10637, some determined from bug 9586,
 139  * and the ones present in both agree, so we're assuming that
 140  * the "remote Peek" protocol and the "Peek tagged" file format
 141  * use the same bits (which wouldn't be too surprising, as they
 142  * both come from Wildpackets).
 143  */
 144 #define EXT_FLAG_20_MHZ_LOWER                   0x00000001
 145 #define EXT_FLAG_20_MHZ_UPPER                   0x00000002
 146 #define EXT_FLAG_40_MHZ                         0x00000004
 147 #define EXT_FLAGS_BANDWIDTH                     0x00000007
 148 #define EXT_FLAG_HALF_GI                        0x00000008
 149 #define EXT_FLAG_FULL_GI                        0x00000010
 150 #define EXT_FLAGS_GI                            0x00000018
 151 #define EXT_FLAG_AMPDU                          0x00000020
 152 #define EXT_FLAG_AMSDU                          0x00000040
 153 #define EXT_FLAG_802_11ac                       0x00000080
 154 #define EXT_FLAG_MCS_INDEX_USED                 0x00000100
 155
 156 /* 64-bit time in nanoseconds from the (Windows FILETIME) epoch */
 157 typedef struct peektagged_utime {
 158         guint32 upper;
 159         guint32 lower;
 160 } peektagged_utime;
 161
 162 typedef struct {
 163         gboolean        has_fcs;
 164 } peektagged_t;
 165
 166 static gboolean peektagged_read(wtap *wth, int *err, gchar **err_info,
 167     gint64 *data_offset);
 168 static gboolean peektagged_seek_read(wtap *wth, gint64 seek_off,
 169     struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
 170
 171 static int wtap_file_read_pattern (wtap *wth, const char *pattern, int *err,
 172                                 gchar **err_info)
 173 {
 174     int c;
 175     const char *cp;
 176
 177     cp = pattern;
 178     while (*cp)
 179     {
 180         c = file_getc(wth->fh);
 181         if (c == EOF)
 182         {
 183             *err = file_error(wth->fh, err_info);
 184             if (*err != 0 && *err != WTAP_ERR_SHORT_READ)
 185                 return -1;      /* error */
 186             return 0;   /* EOF */
 187         }
 188         if (c == *cp)
 189             cp++;
 190         else
 191         {
 192             if (c == pattern[0])
 193                 cp = &pattern[1];
 194             else
 195                 cp = pattern;
 196         }
 197     }
 198     return (*cp == '\0' ? 1 : 0);
 199 }
 200
 201
 202 static int wtap_file_read_till_separator (wtap *wth, char *buffer, int buflen,
 203                                         const char *separators, int *err,
 204                                         gchar **err_info)
 205 {
 206     int c;
 207     char *cp;
 208     int i;
 209
 210     for (cp = buffer, i = 0; i < buflen; i++, cp++)
 211     {
 212         c = file_getc(wth->fh);
 213         if (c == EOF)
 214         {
 215             *err = file_error(wth->fh, err_info);
 216             if (*err != 0 && *err != WTAP_ERR_SHORT_READ)
 217                 return -1;      /* error */
 218             return 0;   /* EOF */
 219         }
 220         if (strchr (separators, c) != NULL)
 221         {
 222             *cp = '\0';
 223             break;
 224         }
 225         else
 226             *cp = c;
 227     }
 228     return i;
 229 }
 230
 231
 232 static int wtap_file_read_number (wtap *wth, guint32 *num, int *err,
 233                                 gchar **err_info)
 234 {
 235     int ret;
 236     char str_num[12];
 237     unsigned long value;
 238     char *p;
 239
 240     ret = wtap_file_read_till_separator (wth, str_num, sizeof (str_num)-1, "<",
 241                                          err, err_info);
 242     if (ret == 0 || ret == -1) {
 243         /* 0 means EOF, which means "not a valid Peek tagged file";
 244            -1 means error, and "err" has been set. */
 245         return ret;
 246     }
 247     value = strtoul (str_num, &p, 10);
 248     if (p == str_num || value > G_MAXUINT32)
 249         return 0;
 250     *num = (guint32)value;
 251     return 1;
 252 }
 253
 254
 255 wtap_open_return_val peektagged_open(wtap *wth, int *err, gchar **err_info)
 256 {
 257     peektagged_section_header_t ap_hdr;
 258     int ret;
 259     guint32 fileVersion = 0;
 260     guint32 mediaType;
 261     guint32 mediaSubType = 0;
 262     int file_encap;
 263     static const int peektagged_encap[] = {
 264         WTAP_ENCAP_ETHERNET,
 265         WTAP_ENCAP_IEEE_802_11_WITH_RADIO,
 266         WTAP_ENCAP_IEEE_802_11_WITH_RADIO,
 267         WTAP_ENCAP_IEEE_802_11_WITH_RADIO
 268     };
 269     #define NUM_PEEKTAGGED_ENCAPS (sizeof peektagged_encap / sizeof peektagged_encap[0])
 270     peektagged_t *peektagged;
 271
 272     if (!wtap_read_bytes(wth->fh, &ap_hdr, (int)sizeof(ap_hdr), err, err_info)) {
 273         if (*err != WTAP_ERR_SHORT_READ)
 274             return WTAP_OPEN_ERROR;
 275         return WTAP_OPEN_NOT_MINE;
 276     }
 277
 278     if (memcmp (ap_hdr.section_id, "\177ver", sizeof(ap_hdr.section_id)) != 0)
 279         return WTAP_OPEN_NOT_MINE;      /* doesn't begin with a "\177ver" section */
 280
 281     /*
 282      * XXX - we should get the length of the "\177ver" section, check
 283      * that it's followed by a little-endian 0x00000200, and then,
 284      * when reading the XML, make sure we don't go past the end of
 285      * that section, and skip to the end of that section when
 286      * we have the file version (and possibly check to make sure all
 287      * tags are properly opened and closed).
 288      */
 289     ret = wtap_file_read_pattern (wth, "<FileVersion>", err, err_info);
 290     if (ret == -1)
 291         return WTAP_OPEN_ERROR;
 292     if (ret == 0) {
 293         /* 0 means EOF, which means "not a valid Peek tagged file" */
 294         return WTAP_OPEN_NOT_MINE;
 295     }
 296     ret = wtap_file_read_number (wth, &fileVersion, err, err_info);
 297     if (ret == -1)
 298         return WTAP_OPEN_ERROR;
 299     if (ret == 0) {
 300         /* 0 means EOF, which means "not a valid Peek tagged file" */
 301         return WTAP_OPEN_NOT_MINE;
 302     }
 303
 304     /* If we got this far, we assume it's a Peek tagged file. */
 305     if (fileVersion != 9) {
 306         /* We only support version 9. */
 307         *err = WTAP_ERR_UNSUPPORTED;
 308         *err_info = g_strdup_printf("peektagged: version %u unsupported",
 309             fileVersion);
 310         return WTAP_OPEN_ERROR;
 311     }
 312
 313     /*
 314      * XXX - once we've skipped the "\177ver" section, we should
 315      * check for a "sess" section and fail if we don't see it.
 316      * Then we should get the length of the "sess" section, check
 317      * that it's followed by a little-endian 0x00000200, and then,
 318      * when reading the XML, make sure we don't go past the end of
 319      * that section, and skip to the end of the section when
 320      * we have the file version (and possibly check to make sure all
 321      * tags are properly opened and closed).
 322      */
 323     ret = wtap_file_read_pattern (wth, "<MediaType>", err, err_info);
 324     if (ret == -1)
 325         return WTAP_OPEN_ERROR;
 326     if (ret == 0) {
 327         *err = WTAP_ERR_BAD_FILE;
 328         *err_info = g_strdup("peektagged: <MediaType> tag not found");
 329         return WTAP_OPEN_ERROR;
 330     }
 331     /* XXX - this appears to be 0 in both the EtherPeek and AiroPeek
 332        files we've seen; should we require it to be 0? */
 333     ret = wtap_file_read_number (wth, &mediaType, err, err_info);
 334     if (ret == -1)
 335         return WTAP_OPEN_ERROR;
 336     if (ret == 0) {
 337         *err = WTAP_ERR_BAD_FILE;
 338         *err_info = g_strdup("peektagged: <MediaType> value not found");
 339         return WTAP_OPEN_ERROR;
 340     }
 341
 342     ret = wtap_file_read_pattern (wth, "<MediaSubType>", err, err_info);
 343     if (ret == -1)
 344         return WTAP_OPEN_ERROR;
 345     if (ret == 0) {
 346         *err = WTAP_ERR_BAD_FILE;
 347         *err_info = g_strdup("peektagged: <MediaSubType> tag not found");
 348         return WTAP_OPEN_ERROR;
 349     }
 350     ret = wtap_file_read_number (wth, &mediaSubType, err, err_info);
 351     if (ret == -1)
 352         return WTAP_OPEN_ERROR;
 353     if (ret == 0) {
 354         *err = WTAP_ERR_BAD_FILE;
 355         *err_info = g_strdup("peektagged: <MediaSubType> value not found");
 356         return WTAP_OPEN_ERROR;
 357     }
 358     if (mediaSubType >= NUM_PEEKTAGGED_ENCAPS
 359         || peektagged_encap[mediaSubType] == WTAP_ENCAP_UNKNOWN) {
 360         *err = WTAP_ERR_UNSUPPORTED;
 361         *err_info = g_strdup_printf("peektagged: network type %u unknown or unsupported",
 362             mediaSubType);
 363         return WTAP_OPEN_ERROR;
 364     }
 365
 366     ret = wtap_file_read_pattern (wth, "pkts", err, err_info);
 367     if (ret == -1)
 368         return WTAP_OPEN_ERROR;
 369     if (ret == 0) {
 370         *err = WTAP_ERR_SHORT_READ;
 371         return WTAP_OPEN_ERROR;
 372     }
 373
 374     /* skip 8 zero bytes */
 375     if (file_seek (wth->fh, 8L, SEEK_CUR, err) == -1)
 376         return WTAP_OPEN_NOT_MINE;
 377
 378     /*
 379      * This is an Peek tagged file.
 380      */
 381     file_encap = peektagged_encap[mediaSubType];
 382
 383     wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_PEEKTAGGED;
 384     wth->file_encap = file_encap;
 385     wth->subtype_read = peektagged_read;
 386     wth->subtype_seek_read = peektagged_seek_read;
 387     wth->file_tsprec = WTAP_TSPREC_NSEC;
 388
 389     peektagged = (peektagged_t *)g_malloc(sizeof(peektagged_t));
 390     wth->priv = (void *)peektagged;
 391     switch (mediaSubType) {
 392
 393     case PEEKTAGGED_NST_ETHERNET:
 394     case PEEKTAGGED_NST_802_11:
 395     case PEEKTAGGED_NST_802_11_2:
 396         peektagged->has_fcs = FALSE;
 397         break;
 398
 399     case PEEKTAGGED_NST_802_11_WITH_FCS:
 400         peektagged->has_fcs = TRUE;
 401         break;
 402     }
 403
 404     wth->snapshot_length   = 0; /* not available in header */
 405
 406     return WTAP_OPEN_MINE;
 407 }
 408
 409 /*
 410  * Read the packet.
 411  *
 412  * XXX - we should supply the additional radio information;
 413  * the pseudo-header should probably be supplied in a fashion
 414  * similar to the radiotap radio header, so that the 802.11
 415  * dissector can determine which, if any, information items
 416  * are present.
 417  */
 418 static int
 419 peektagged_read_packet(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr,
 420                        Buffer *buf, int *err, gchar **err_info)
 421 {
 422     peektagged_t *peektagged = (peektagged_t *)wth->priv;
 423     gboolean read_a_tag = FALSE;
 424     guint8 tag_value[6];
 425     guint16 tag;
 426     gboolean saw_length = FALSE;
 427     guint32 length = 0;
 428     guint32 sliceLength = 0;
 429     gboolean saw_timestamp_lower = FALSE;
 430     gboolean saw_timestamp_upper = FALSE;
 431     peektagged_utime timestamp;
 432     guint32 ext_flags = 0;
 433     gboolean saw_data_rate_or_mcs_index = FALSE;
 434     guint32 data_rate_or_mcs_index = 0;
 435     gint channel;
 436     guint frequency;
 437     struct ieee_802_11_phdr ieee_802_11;
 438     guint i;
 439     int skip_len = 0;
 440     guint64 t;
 441
 442     timestamp.upper = 0;
 443     timestamp.lower = 0;
 444     memset(&ieee_802_11, 0, sizeof ieee_802_11);
 445     ieee_802_11.fcs_len = -1; /* Unknown */
 446     ieee_802_11.decrypted = FALSE;
 447     ieee_802_11.datapad = FALSE;
 448     ieee_802_11.phy = PHDR_802_11_PHY_UNKNOWN;
 449
 450     /* Extract the fields from the packet header */
 451     do {
 452         /* Get the tag and value.
 453            XXX - this assumes all values are 4 bytes long. */
 454         if (!wtap_read_bytes_or_eof(fh, tag_value, sizeof tag_value, err, err_info)) {
 455             if (*err == 0) {
 456                 /*
 457                  * Short read if we've read something already;
 458                  * just an EOF if we haven't.
 459                  */
 460                 if (read_a_tag)
 461                     *err = WTAP_ERR_SHORT_READ;
 462             }
 463             return -1;
 464         }
 465         read_a_tag = TRUE;
 466         tag = pletoh16(&tag_value[0]);
 467         switch (tag) {
 468
 469         case TAG_PEEKTAGGED_LENGTH:
 470             if (saw_length) {
 471                 *err = WTAP_ERR_BAD_FILE;
 472                 *err_info = g_strdup("peektagged: record has two length fields");
 473                 return -1;
 474             }
 475             length = pletoh32(&tag_value[2]);
 476             saw_length = TRUE;
 477             break;
 478
 479         case TAG_PEEKTAGGED_TIMESTAMP_LOWER:
 480             if (saw_timestamp_lower) {
 481                 *err = WTAP_ERR_BAD_FILE;
 482                 *err_info = g_strdup("peektagged: record has two timestamp-lower fields");
 483                 return -1;
 484             }
 485             timestamp.lower = pletoh32(&tag_value[2]);
 486             saw_timestamp_lower = TRUE;
 487             break;
 488
 489         case TAG_PEEKTAGGED_TIMESTAMP_UPPER:
 490             if (saw_timestamp_upper) {
 491                 *err = WTAP_ERR_BAD_FILE;
 492                 *err_info = g_strdup("peektagged: record has two timestamp-upper fields");
 493                 return -1;
 494             }
 495             timestamp.upper = pletoh32(&tag_value[2]);
 496             saw_timestamp_upper = TRUE;
 497             break;
 498
 499         case TAG_PEEKTAGGED_FLAGS_AND_STATUS:
 500             /* XXX - not used yet */
 501             break;
 502
 503         case TAG_PEEKTAGGED_CHANNEL:
 504             ieee_802_11.has_channel = TRUE;
 505             ieee_802_11.channel = pletoh32(&tag_value[2]);
 506             break;
 507
 508         case TAG_PEEKTAGGED_DATA_RATE_OR_MCS_INDEX:
 509             data_rate_or_mcs_index = pletoh32(&tag_value[2]);
 510             saw_data_rate_or_mcs_index = TRUE;
 511             break;
 512
 513         case TAG_PEEKTAGGED_SIGNAL_PERC:
 514             ieee_802_11.has_signal_percent = TRUE;
 515             ieee_802_11.signal_percent = pletoh32(&tag_value[2]);
 516             break;
 517
 518         case TAG_PEEKTAGGED_SIGNAL_DBM:
 519             ieee_802_11.has_signal_dbm = TRUE;
 520             ieee_802_11.signal_dbm = pletoh32(&tag_value[2]);
 521             break;
 522
 523         case TAG_PEEKTAGGED_NOISE_PERC:
 524             ieee_802_11.has_noise_percent = TRUE;
 525             ieee_802_11.noise_percent = pletoh32(&tag_value[2]);
 526             break;
 527
 528         case TAG_PEEKTAGGED_NOISE_DBM:
 529             ieee_802_11.has_noise_dbm = TRUE;
 530             ieee_802_11.noise_dbm = pletoh32(&tag_value[2]);
 531             break;
 532
 533         case TAG_PEEKTAGGED_UNKNOWN_0x000A:
 534             /*
 535              * XXX - seen in some 802.11 captures.
 536              * Always seems to have the value 0 or 5.
 537              */
 538             break;
 539
 540         case TAG_PEEKTAGGED_CENTER_FREQUENCY:
 541             /* XXX - also seen in an EtherPeek capture; value unknown */
 542             ieee_802_11.has_frequency = TRUE;
 543             ieee_802_11.frequency = pletoh32(&tag_value[2]);
 544             break;
 545
 546         case TAG_PEEKTAGGED_UNKNOWN_0x000E:
 547             /*
 548              * XXX - seen in some 802.11 captures.
 549              * Usually has the value 4, but, in some packets, has the
 550              * values 6 or 302.
 551              *
 552              * Is this the mysterious "band" field that shows up in
 553              * some "Peek remote" protocol captures, with values in
 554              * the 30x or 40x ranges?  It's not always associated
 555              * with the "extended flags" tag for HT/VHT information,
 556              * so it's probably not 11n/11ac-specific.  Values other
 557              * than 4 appear, in my captures, only in packets with
 558              * the "extended flags" tag.  302 appeared in a packet
 559              * with EXT_FLAG_MCS_INDEX_USED; 6 appeared in packets
 560              * without EXT_FLAG_MCS_INDEX_USED.
 561              */
 562             break;
 563
 564         case TAG_PEEKTAGGED_UNKNOWN_0x000F:
 565             /*
 566              * XXX - seen in some 802.11 captures; dB or dBm value?
 567              * Multiple antennas?
 568              */
 569             break;
 570
 571         case TAG_PEEKTAGGED_UNKNOWN_0x0010:
 572             /*
 573              * XXX - seen in some 802.11 captures; dB or dBm value?
 574              * Multiple antennas?
 575              */
 576             break;
 577
 578         case TAG_PEEKTAGGED_UNKNOWN_0x0011:
 579             /*
 580              * XXX - seen in some 802.11 captures; dB or dBm value?
 581              * Multiple antennas?
 582              */
 583             break;
 584
 585         case TAG_PEEKTAGGED_UNKNOWN_0x0012:
 586             /*
 587              * XXX - seen in some 802.11 captures; dB or dBm value?
 588              * Multiple antennas?
 589              */
 590             break;
 591
 592         case TAG_PEEKTAGGED_UNKNOWN_0x0013:
 593             /*
 594              * XXX - seen in some 802.11 captures; dB or dBm value?
 595              * Multiple antennas?
 596              */
 597             break;
 598
 599         case TAG_PEEKTAGGED_UNKNOWN_0x0014:
 600             /*
 601              * XXX - seen in some 802.11 captures; dB or dBm value?
 602              * Multiple antennas?
 603              */
 604             break;
 605
 606         case TAG_PEEKTAGGED_EXT_FLAGS:
 607             /*
 608              * We assume this is present for HT and VHT frames and absent
 609              * for other frames.
 610              */
 611             ext_flags = pletoh32(&tag_value[2]);
 612             if (ext_flags & EXT_FLAG_802_11ac) {
 613                 ieee_802_11.phy = PHDR_802_11_PHY_11AC;
 614                 /*
 615                  * XXX - this probably has only one user, so only
 616                  * one MCS index and only one NSS, but where's the
 617                  * NSS?
 618                  */
 619                 for (i = 0; i < 4; i++)
 620                     ieee_802_11.phy_info.info_11ac.nss[i] = 0;
 621
 622                 switch (ext_flags & EXT_FLAGS_GI) {
 623
 624                 case EXT_FLAG_HALF_GI:
 625                     ieee_802_11.phy_info.info_11ac.has_short_gi = TRUE;
 626                     ieee_802_11.phy_info.info_11ac.short_gi = 1;
 627                     break;
 628
 629                 case EXT_FLAG_FULL_GI:
 630                     ieee_802_11.phy_info.info_11ac.has_short_gi = TRUE;
 631                     ieee_802_11.phy_info.info_11ac.short_gi = 0;
 632                     break;
 633
 634                 default:
 635                     /* Mutually exclusive flags set or nothing set */
 636                     break;
 637                 }
 638             } else {
 639                 ieee_802_11.phy = PHDR_802_11_PHY_11N;
 640                 switch (ext_flags & EXT_FLAGS_BANDWIDTH) {
 641
 642                 case 0:
 643                     ieee_802_11.phy_info.info_11n.has_bandwidth = TRUE;
 644                     ieee_802_11.phy_info.info_11n.bandwidth = PHDR_802_11_BANDWIDTH_20_MHZ;
 645                     break;
 646
 647                 case EXT_FLAG_20_MHZ_LOWER:
 648                     ieee_802_11.phy_info.info_11n.has_bandwidth = TRUE;
 649                     ieee_802_11.phy_info.info_11n.bandwidth = PHDR_802_11_BANDWIDTH_20_20L;
 650                     break;
 651
 652                 case EXT_FLAG_20_MHZ_UPPER:
 653                     ieee_802_11.phy_info.info_11n.has_bandwidth = TRUE;
 654                     ieee_802_11.phy_info.info_11n.bandwidth = PHDR_802_11_BANDWIDTH_20_20U;
 655                     break;
 656
 657                 case EXT_FLAG_40_MHZ:
 658                     ieee_802_11.phy_info.info_11n.has_bandwidth = TRUE;
 659                     ieee_802_11.phy_info.info_11n.bandwidth = PHDR_802_11_BANDWIDTH_40_MHZ;
 660                     break;
 661
 662                 default:
 663                     /* Mutually exclusive flags set */
 664                     break;
 665                 }
 666
 667                 switch (ext_flags & EXT_FLAGS_GI) {
 668
 669                 case EXT_FLAG_HALF_GI:
 670                     ieee_802_11.phy_info.info_11n.has_short_gi = TRUE;
 671                     ieee_802_11.phy_info.info_11n.short_gi = 1;
 672                     break;
 673
 674                 case EXT_FLAG_FULL_GI:
 675                     ieee_802_11.phy_info.info_11n.has_short_gi = TRUE;
 676                     ieee_802_11.phy_info.info_11n.short_gi = 0;
 677                     break;
 678
 679                 default:
 680                     /* Mutually exclusive flags set or nothing set */
 681                     break;
 682                 }
 683             }
 684             break;
 685
 686         case TAG_PEEKTAGGED_SLICE_LENGTH:
 687             sliceLength = pletoh32(&tag_value[2]);
 688             break;
 689
 690         default:
 691             break;
 692         }
 693     } while (tag != TAG_PEEKTAGGED_SLICE_LENGTH);       /* last tag */
 694
 695     if (!saw_length) {
 696         *err = WTAP_ERR_BAD_FILE;
 697         *err_info = g_strdup("peektagged: record has no length field");
 698         return -1;
 699     }
 700     if (!saw_timestamp_lower) {
 701         *err = WTAP_ERR_BAD_FILE;
 702         *err_info = g_strdup("peektagged: record has no timestamp-lower field");
 703         return -1;
 704     }
 705     if (!saw_timestamp_upper) {
 706         *err = WTAP_ERR_BAD_FILE;
 707         *err_info = g_strdup("peektagged: record has no timestamp-upper field");
 708         return -1;
 709     }
 710
 711     /*
 712      * If sliceLength is 0, force it to be the actual length of the packet.
 713      */
 714     if (sliceLength == 0)
 715         sliceLength = length;
 716
 717     if (sliceLength > WTAP_MAX_PACKET_SIZE) {
 718         /*
 719          * Probably a corrupt capture file; don't blow up trying
 720          * to allocate space for an immensely-large packet.
 721          */
 722         *err = WTAP_ERR_BAD_FILE;
 723         *err_info = g_strdup_printf("peektagged: File has %u-byte packet, bigger than maximum of %u",
 724             sliceLength, WTAP_MAX_PACKET_SIZE);
 725         return -1;
 726     }
 727
 728     phdr->rec_type = REC_TYPE_PACKET;
 729     phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN;
 730     phdr->len    = length;
 731     phdr->caplen = sliceLength;
 732
 733     /* calculate and fill in packet time stamp */
 734     t = (((guint64) timestamp.upper) << 32) + timestamp.lower;
 735     if (!nsfiletime_to_nstime(&phdr->ts, t)) {
 736         *err = WTAP_ERR_BAD_FILE;
 737         *err_info = g_strdup("peektagged: time stamp outside supported range");
 738         return -1;
 739     }
 740
 741     switch (wth->file_encap) {
 742
 743     case WTAP_ENCAP_IEEE_802_11_WITH_RADIO:
 744         if (saw_data_rate_or_mcs_index) {
 745             if (ext_flags & EXT_FLAG_MCS_INDEX_USED) {
 746                 /*
 747                  * It's an MCS index.
 748                  *
 749                  * XXX - what about 11ac?
 750                  */
 751                 if (!(ext_flags & EXT_FLAG_802_11ac)) {
 752                     ieee_802_11.phy_info.info_11n.has_mcs_index = TRUE;
 753                     ieee_802_11.phy_info.info_11n.mcs_index = data_rate_or_mcs_index;
 754                 }
 755             } else {
 756                 /* It's a data rate. */
 757                 ieee_802_11.has_data_rate = TRUE;
 758                 ieee_802_11.data_rate = data_rate_or_mcs_index;
 759             }
 760         }
 761         if (ieee_802_11.has_frequency && !ieee_802_11.has_channel) {
 762             /* Frequency, but no channel; try to calculate the channel. */
 763             channel = ieee80211_mhz_to_chan(ieee_802_11.frequency);
 764             if (channel != -1) {
 765                 ieee_802_11.has_channel = TRUE;
 766                 ieee_802_11.channel = channel;
 767             }
 768         } else if (ieee_802_11.has_channel && !ieee_802_11.has_frequency) {
 769             /*
 770              * If it's 11 legacy DHSS, 11b, or 11g, it's 2.4 GHz,
 771              * so we can calculate the frequency.
 772              *
 773              * If it's 11a, it's 5 GHz, so we can calculate the
 774              * frequency.
 775              */
 776             switch (ieee_802_11.phy) {
 777
 778             case PHDR_802_11_PHY_11_DSSS:
 779             case PHDR_802_11_PHY_11B:
 780             case PHDR_802_11_PHY_11G:
 781                 frequency = ieee80211_chan_to_mhz(ieee_802_11.channel, TRUE);
 782                 break;
 783
 784             case PHDR_802_11_PHY_11A:
 785                 frequency = ieee80211_chan_to_mhz(ieee_802_11.channel, FALSE);
 786                 break;
 787
 788             default:
 789                 /* We don't know the band. */
 790                 frequency = 0;
 791                 break;
 792             }
 793             if (frequency != 0) {
 794                 ieee_802_11.has_frequency = TRUE;
 795                 ieee_802_11.frequency = frequency;
 796             }
 797         }
 798         phdr->pseudo_header.ieee_802_11 = ieee_802_11;
 799         if (peektagged->has_fcs)
 800             phdr->pseudo_header.ieee_802_11.fcs_len = 4;
 801         else {
 802             if (phdr->len < 4 || phdr->caplen < 4) {
 803                 *err = WTAP_ERR_BAD_FILE;
 804                 *err_info = g_strdup_printf("peektagged: 802.11 packet has length < 4");
 805                 return FALSE;
 806             }
 807             phdr->pseudo_header.ieee_802_11.fcs_len = 0;
 808             phdr->len -= 4;
 809             phdr->caplen -= 4;
 810             skip_len = 4;
 811         }
 812         phdr->pseudo_header.ieee_802_11.decrypted = FALSE;
 813         phdr->pseudo_header.ieee_802_11.datapad = FALSE;
 814         break;
 815
 816     case WTAP_ENCAP_ETHERNET:
 817         /*
 818          * The last 4 bytes appear to be 0 in the captures I've seen;
 819          * are there any captures where it's an FCS?
 820          */
 821         if (phdr->len < 4 || phdr->caplen < 4) {
 822             *err = WTAP_ERR_BAD_FILE;
 823             *err_info = g_strdup_printf("peektagged: Ethernet packet has length < 4");
 824             return FALSE;
 825         }
 826         phdr->pseudo_header.eth.fcs_len = 0;
 827         phdr->len -= 4;
 828         phdr->caplen -= 4;
 829         skip_len = 4;
 830         break;
 831     }
 832
 833     /* Read the packet data. */
 834     if (!wtap_read_packet_bytes(fh, buf, phdr->caplen, err, err_info))
 835         return -1;
 836
 837     return skip_len;
 838 }
 839
 840 static gboolean peektagged_read(wtap *wth, int *err, gchar **err_info,
 841     gint64 *data_offset)
 842 {
 843     int skip_len;
 844
 845     *data_offset = file_tell(wth->fh);
 846
 847     /* Read the packet. */
 848     skip_len = peektagged_read_packet(wth, wth->fh, &wth->phdr,
 849                                       wth->frame_buffer, err, err_info);
 850     if (skip_len == -1)
 851         return FALSE;
 852
 853     if (skip_len != 0) {
 854         /* Skip extra junk at the end of the packet data. */
 855         if (!file_skip(wth->fh, skip_len, err))
 856             return FALSE;
 857     }
 858
 859     return TRUE;
 860 }
 861
 862 static gboolean
 863 peektagged_seek_read(wtap *wth, gint64 seek_off,
 864     struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info)
 865 {
 866     if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
 867         return FALSE;
 868
 869     /* Read the packet. */
 870     if (peektagged_read_packet(wth, wth->random_fh, phdr, buf, err, err_info) == -1) {
 871         if (*err == 0)
 872             *err = WTAP_ERR_SHORT_READ;
 873         return FALSE;
 874     }
 875     return TRUE;
 876 }
 877
 878 /*
 879  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
 880  *
 881  * Local variables:
 882  * c-basic-offset: 4
 883  * tab-width: 8
 884  * indent-tabs-mode: nil
 885  * End:
 886  *
 887  * vi: set shiftwidth=4 tabstop=8 expandtab:
 888  * :indentSize=4:tabSize=8:noTabs=true:
 889  */