wlantest/readpcap.c

   1 /*
   2  * PCAP capture file reader
   3  * Copyright (c) 2010, Jouni Malinen <j@w1.fi>
   4  *
   5  * This software may be distributed under the terms of the BSD license.
   6  * See README for more details.
   7  */
   8
   9 #include "utils/includes.h"
  10 #include <pcap.h>
  11
  12 #include "utils/common.h"
  13 #include "wlantest.h"
  14
  15
  16 static void write_pcap_with_radiotap(struct wlantest *wt,
  17                                      const u8 *data, size_t data_len)
  18 {
  19         struct pcap_pkthdr h;
  20         u8 rtap[] = {
  21                 0x00 /* rev */,
  22                 0x00 /* pad */,
  23                 0x0a, 0x00, /* header len */
  24                 0x02, 0x00, 0x00, 0x00, /* present flags */
  25                 0x00, /* flags */
  26                 0x00 /* pad */
  27         };
  28         u8 *buf;
  29         size_t len;
  30
  31         if (wt->assume_fcs)
  32                 rtap[8] |= 0x10;
  33
  34         os_memset(&h, 0, sizeof(h));
  35         h.ts = wt->write_pcap_time;
  36         len = sizeof(rtap) + data_len;
  37         buf = os_malloc(len);
  38         if (buf == NULL)
  39                 return;
  40         os_memcpy(buf, rtap, sizeof(rtap));
  41         os_memcpy(buf + sizeof(rtap), data, data_len);
  42         h.caplen = len;
  43         h.len = len;
  44         pcap_dump(wt->write_pcap_dumper, &h, buf);
  45         os_free(buf);
  46 }
  47
  48
  49 int read_cap_file(struct wlantest *wt, const char *fname)
  50 {
  51         char errbuf[PCAP_ERRBUF_SIZE];
  52         pcap_t *pcap;
  53         unsigned int count = 0;
  54         struct pcap_pkthdr *hdr;
  55         const u_char *data;
  56         int res;
  57         int dlt;
  58
  59         pcap = pcap_open_offline(fname, errbuf);
  60         if (pcap == NULL) {
  61                 wpa_printf(MSG_ERROR, "Failed to read pcap file '%s': %s",
  62                            fname, errbuf);
  63                 return -1;
  64         }
  65         dlt = pcap_datalink(pcap);
  66         if (dlt != DLT_IEEE802_11_RADIO && dlt != DLT_PRISM_HEADER &&
  67             dlt != DLT_IEEE802_11) {
  68                 wpa_printf(MSG_ERROR, "Unsupported pcap datalink type: %d",
  69                            dlt);
  70                 pcap_close(pcap);
  71                 return -1;
  72         }
  73         wpa_printf(MSG_DEBUG, "pcap datalink type: %d", dlt);
  74
  75         for (;;) {
  76                 clear_notes(wt);
  77                 os_free(wt->decrypted);
  78                 wt->decrypted = NULL;
  79
  80                 res = pcap_next_ex(pcap, &hdr, &data);
  81                 if (res == -2)
  82                         break; /* No more packets */
  83                 if (res == -1) {
  84                         wpa_printf(MSG_INFO, "pcap_next_ex failure: %s",
  85                                    pcap_geterr(pcap));
  86                         break;
  87                 }
  88                 if (res != 1) {
  89                         wpa_printf(MSG_INFO, "Unexpected pcap_next_ex return "
  90                                    "value %d", res);
  91                         break;
  92                 }
  93
  94                 /* Packet was read without problems */
  95                 wpa_printf(MSG_EXCESSIVE, "pcap hdr: ts=%d.%06d "
  96                            "len=%u/%u",
  97                            (int) hdr->ts.tv_sec, (int) hdr->ts.tv_usec,
  98                            hdr->caplen, hdr->len);
  99                 if (wt->write_pcap_dumper) {
 100                         wt->write_pcap_time = hdr->ts;
 101                         if (dlt == DLT_IEEE802_11)
 102                                 write_pcap_with_radiotap(wt, data, hdr->caplen);
 103                         else
 104                                 pcap_dump(wt->write_pcap_dumper, hdr, data);
 105                         if (wt->pcap_no_buffer)
 106                                 pcap_dump_flush(wt->write_pcap_dumper);
 107                 }
 108                 if (hdr->caplen < hdr->len) {
 109                         add_note(wt, MSG_DEBUG, "pcap: Dropped incomplete "
 110                                  "frame (%u/%u captured)",
 111                                  hdr->caplen, hdr->len);
 112                         write_pcapng_write_read(wt, dlt, hdr, data);
 113                         continue;
 114                 }
 115                 count++;
 116                 switch (dlt) {
 117                 case DLT_IEEE802_11_RADIO:
 118                         wlantest_process(wt, data, hdr->caplen);
 119                         break;
 120                 case DLT_PRISM_HEADER:
 121                         wlantest_process_prism(wt, data, hdr->caplen);
 122                         break;
 123                 case DLT_IEEE802_11:
 124                         wlantest_process_80211(wt, data, hdr->caplen);
 125                         break;
 126                 }
 127                 write_pcapng_write_read(wt, dlt, hdr, data);
 128         }
 129
 130         pcap_close(pcap);
 131
 132         wpa_printf(MSG_DEBUG, "Read %s: %u packets", fname, count);
 133
 134         return 0;
 135 }
 136
 137
 138 int read_wired_cap_file(struct wlantest *wt, const char *fname)
 139 {
 140         char errbuf[PCAP_ERRBUF_SIZE];
 141         pcap_t *pcap;
 142         unsigned int count = 0;
 143         struct pcap_pkthdr *hdr;
 144         const u_char *data;
 145         int res;
 146
 147         pcap = pcap_open_offline(fname, errbuf);
 148         if (pcap == NULL) {
 149                 wpa_printf(MSG_ERROR, "Failed to read pcap file '%s': %s",
 150                            fname, errbuf);
 151                 return -1;
 152         }
 153
 154         for (;;) {
 155                 res = pcap_next_ex(pcap, &hdr, &data);
 156                 if (res == -2)
 157                         break; /* No more packets */
 158                 if (res == -1) {
 159                         wpa_printf(MSG_INFO, "pcap_next_ex failure: %s",
 160                                    pcap_geterr(pcap));
 161                         break;
 162                 }
 163                 if (res != 1) {
 164                         wpa_printf(MSG_INFO, "Unexpected pcap_next_ex return "
 165                                    "value %d", res);
 166                         break;
 167                 }
 168
 169                 /* Packet was read without problems */
 170                 wpa_printf(MSG_EXCESSIVE, "pcap hdr: ts=%d.%06d "
 171                            "len=%u/%u",
 172                            (int) hdr->ts.tv_sec, (int) hdr->ts.tv_usec,
 173                            hdr->caplen, hdr->len);
 174                 if (hdr->caplen < hdr->len) {
 175                         wpa_printf(MSG_DEBUG, "pcap: Dropped incomplete frame "
 176                                    "(%u/%u captured)",
 177                                    hdr->caplen, hdr->len);
 178                         continue;
 179                 }
 180                 count++;
 181                 wlantest_process_wired(wt, data, hdr->caplen);
 182         }
 183
 184         pcap_close(pcap);
 185
 186         wpa_printf(MSG_DEBUG, "Read %s: %u packets", fname, count);
 187
 188         return 0;
 189 }