vendor/quadtree/LICENSE


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

MIT License

Copyright (c) 2019 Pierre Vigier

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
#include "helpers.h"
#include <errno.h>
#include <libwifi.h>
#include <pcap.h>
#include <pcap/pcap.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>

#define PCAP_SAVEFILE "/tmp/debug.pcap"
#define FILTER ""
#define MODE_BEACON 1
#define MODE_PROBE_RESPONSE 2
#define MODE_PROBE_REQUEST 3
#define MODE_EAPOL 4
#define MODE_DEAUTH 5
#define MODE_DISASSOC 6
#define MODE_ASSOC_RESPONSE 7
#define MODE_ASSOC_REQUEST 8
#define MODE_REASSOC_REQUEST 9
#define MODE_REASSOC_RESPONSE 10
#define MODE_DATA 11
#define MODE_ALL 99

static pcap_t *handle;
pcap_dumper_t *pd;
static struct bpf_program *filter;
static int got_radiotap;
static unsigned long packet_num = 0;
static int mode = 0;
static int parse_radiotap_header = 0;

struct libwifi_bss bss = {0};
struct libwifi_sta sta = {0};

void help(const char *);
void parse_packet(unsigned char *args, const struct pcap_pkthdr *header, const unsigned char *packet);
void print_bss_info(struct libwifi_bss *bss);
void print_sta_info(struct libwifi_sta *sta);
void print_tag_info(unsigned char *data, size_t data_len);

void interrupted(int signum) {
    pcap_dump_close(pd);
    pcap_close(handle);
}

void print_bss_info(struct libwifi_bss *bss) {
    if (bss == NULL) {
        return;
    }

    printf("=== BSS Parsing ===\n");
    printf("ESSID: %s\n", bss->hidden ? "(hidden)" : bss->ssid);
    printf("BSSID: " MACSTR "\n", MAC2STR(bss->bssid));
    printf("Receiver: " MACSTR "\n", MAC2STR(bss->receiver));
    printf("Transmitter: " MACSTR "\n", MAC2STR(bss->transmitter));
    printf("Channel: %d\n", bss->channel);
    printf("WPS: %s\n", bss->wps ? "yes" : "no");

    char sec_buf[LIBWIFI_SECURITY_BUF_LEN];
    libwifi_get_security_type(bss, sec_buf);
    printf("Encryption: %s\n", sec_buf);

    libwifi_get_group_ciphers(bss, sec_buf);
    printf("\tGroup Ciphers: %s\n", sec_buf);

    libwifi_get_pairwise_ciphers(bss, sec_buf);
    printf("\tPairwise Ciphers: %s\n", sec_buf);

    libwifi_get_auth_key_suites(bss, sec_buf);
    printf("\tAuth Key Suites: %s\n", sec_buf);

    if (bss->rsn_info.rsn_capabilities & LIBWIFI_RSN_CAPAB_MFP_CAPABLE) {
        printf("\tMFP Capable: Yes\n");
    }
    if (bss->rsn_info.rsn_capabilities & LIBWIFI_RSN_CAPAB_MFP_REQUIRED) {
        printf("\tMFP Required: Yes\n");
    }

    if (bss->tags.length) {
        printf("Tagged Parameters:\n");
        print_tag_info(bss->tags.parameters, bss->tags.length);
    } else {
        printf("Tagged Parameters: None\n");
    }

    printf("=== BSS End ===\n");
    printf("\n\n");
}

void print_sta_info(struct libwifi_sta *sta) {
    if (sta == NULL) {
        return;
    }

    printf("=== STA Parsing ===\n");

    if (sta->broadcast_ssid) {
        printf("ESSID: <broadcast>\n");
    } else {
        printf("ESSID: %s\n", sta->ssid);
    }
    printf("Channel: %u\n", sta->channel);
    printf("BSSID: " MACSTR "\n", MAC2STR(sta->bssid));
    printf("MAC: " MACSTR "\n", MAC2STR(sta->transmitter));

    printf("=== STA End ===\n");
    printf("\n\n");
}

void print_tag_info(unsigned char *data, size_t data_len) {
    struct libwifi_tag_iterator it;
    if (libwifi_tag_iterator_init(&it, data, data_len) != 0) {
        printf("Couldn't initialise tag iterator\n");
        return;
    }
    do {
        printf("\tTag: %d (Size: %d)\n", it.tag_header->tag_num, it.tag_header->tag_len);

        int max_size = 16;
        if (it.tag_header->tag_len < 16) {
            max_size = it.tag_header->tag_len;
        }
        printf("\t%d bytes of Tag Data: ", max_size);
        for (size_t i = 0; i < max_size; i++) {
            printf("%02x ", it.tag_data[i]);
        }
        printf("\n");
    } while (libwifi_tag_iterator_next(&it) != -1);
}

void parse_radiotap(const unsigned char *packet) {
    struct libwifi_radiotap_info rtap_info;
    libwifi_parse_radiotap_info(&rtap_info, packet);

    printf("=== Radiotap Parsing ===\n");
    printf("Radiotap Channel: %d\n", rtap_info.channel.freq);
    printf("Radiotap Channel Flags: 0x%04x\n", rtap_info.channel.flags);
    printf("Radiotap Rate: %.2f Mb/s\n", rtap_info.rate);
    printf("Radiotap Rate Raw: 0x%02x\n", rtap_info.rate_raw);
    printf("Radiotap Signal: %d dBm\n", rtap_info.signal);
    for (int i = 0; i < rtap_info.antenna_count; i++) {
        printf("Radiotap Antenna %d: %d dBm\n", rtap_info.antennas[i].antenna_number, rtap_info.antennas[i].signal);
    }
    printf("Radiotap Flags: 0x%04x\n", rtap_info.flags);
    printf("Radiotap Extended Flags: 0x%08x\n", rtap_info.extended_flags);
    printf("Radiotap RX Flags: 0x%04x\n", rtap_info.rx_flags);
    printf("Radiotap TX Flags: 0x%04x\n", rtap_info.tx_flags);
    printf("Radiotap TX Power: %d\n", rtap_info.tx_power);
    printf("Radiotap RTS Retries: %d\n", rtap_info.rts_retries);
    printf("Radiotap Data Retries: %d\n", rtap_info.data_retries);
    printf("=== Radiotap End ===\n");
}

void parse_beacon(struct libwifi_frame frame, unsigned char *args, const struct pcap_pkthdr *header, const unsigned char *packet) {
    if (frame.frame_control.type == TYPE_MANAGEMENT && frame.frame_control.subtype == SUBTYPE_BEACON) {
        printf("Packet : %lu\n", packet_num);
        int ret = libwifi_parse_beacon(&bss, &frame);
        if (ret != 0) {
            printf("Failed to parse beacon: %d\n", ret);
            pcap_dump(args, header, packet);
            return;
        }

        if (got_radiotap && parse_radiotap_header) {
            parse_radiotap(packet);
        }

        print_bss_info(&bss);
    }
}

void parse_probe_request(struct libwifi_frame frame, unsigned char *args, const struct pcap_pkthdr *header, const unsigned char *packet) {
    if (frame.frame_control.type == TYPE_MANAGEMENT && frame.frame_control.subtype == SUBTYPE_PROBE_REQ) {
        printf("Packet : %lu\n", packet_num);
        int ret = libwifi_parse_probe_req(&sta, &frame);
        if (ret != 0) {
            printf("Failed to parse probe request: %d\n", ret);
            pcap_dump(args, header, packet);
            return;
        }

        if (got_radiotap && parse_radiotap_header) {
            parse_radiotap(packet);
        }

        print_sta_info(&sta);
    }
}
void parse_probe_response(struct libwifi_frame frame, unsigned char *args, const struct pcap_pkthdr *header, const unsigned char *packet) {
    if (frame.frame_control.type == TYPE_MANAGEMENT && frame.frame_control.subtype == SUBTYPE_PROBE_RESP) {
        printf("Packet : %lu\n", packet_num);
        int ret = libwifi_parse_probe_resp(&bss, &frame);
        if (ret != 0) {
            printf("Failed to parse probe response: %d\n", ret);
            pcap_dump(args, header, packet);
            return;
        }

        if (got_radiotap && parse_radiotap_header) {
            parse_radiotap(packet);
        }

        print_bss_info(&bss);
    }
}
void parse_deauth(struct libwifi_frame frame, unsigned char *args, const struct pcap_pkthdr *header, const unsigned char *packet) {
    if (frame.frame_control.type == TYPE_MANAGEMENT && frame.frame_control.subtype == SUBTYPE_DEAUTH) {
        printf("Packet : %lu\n", packet_num);
        struct libwifi_parsed_deauth deauth;
        int ret = libwifi_parse_deauth(&deauth, &frame);
        if (ret != 0) {
            printf("Failed to parse deauthentication: %d\n", ret);
            pcap_dump(args, header, packet);
            return;
        }

        if (got_radiotap && parse_radiotap_header) {
            parse_radiotap(packet);
        }

        printf("=== Deauthentication Frame ===\n");
        if (deauth.ordered) {
            printf("Address 1: " MACSTR "\n", MAC2STR(deauth.frame_header.ordered.addr1));
            printf("Address 2: " MACSTR "\n", MAC2STR(deauth.frame_header.ordered.addr2));
            printf("Address 3: " MACSTR "\n", MAC2STR(deauth.frame_header.ordered.addr3));
        } else {
            printf("Address 1: " MACSTR "\n", MAC2STR(deauth.frame_header.unordered.addr1));
            printf("Address 2: " MACSTR "\n", MAC2STR(deauth.frame_header.unordered.addr2));
            printf("Address 3: " MACSTR "\n", MAC2STR(deauth.frame_header.unordered.addr3));
        }

        printf("Reason: %d (0x%04x)\n", deauth.fixed_parameters.reason_code, deauth.fixed_parameters.reason_code);

        if (deauth.tags.length) {
            printf("Tagged Parameters:\n");
            print_tag_info(deauth.tags.parameters, deauth.tags.length);
        } else {
            printf("Tagged Parameters: None\n");
        }

        printf("=== End Deauthentication Frame ===\n");
        printf("\n\n");
    }
}
void parse_disassoc(struct libwifi_frame frame, unsigned char *args, const struct pcap_pkthdr *header, const unsigned char *packet) {
    if (frame.frame_control.type == TYPE_MANAGEMENT && frame.frame_control.subtype == SUBTYPE_DISASSOC) {
        printf("Packet : %lu\n", packet_num);
        struct libwifi_parsed_disassoc disassoc;
        int ret = libwifi_parse_disassoc(&disassoc, &frame);
        if (ret != 0) {
            printf("Failed to parse diassociation: %d\n", ret);
            pcap_dump(args, header, packet);
            return;
        }

        if (got_radiotap && parse_radiotap_header) {
            parse_radiotap(packet);
        }

        printf("=== Disassociation Frame ===\n");
        if (disassoc.ordered) {
            printf("Address 1: " MACSTR "\n", MAC2STR(disassoc.frame_header.ordered.addr1));
            printf("Address 2: " MACSTR "\n", MAC2STR(disassoc.frame_header.ordered.addr2));
            printf("Address 3: " MACSTR "\n", MAC2STR(disassoc.frame_header.ordered.addr3));
        } else {
            printf("Address 1: " MACSTR "\n", MAC2STR(disassoc.frame_header.unordered.addr1));
            printf("Address 2: " MACSTR "\n", MAC2STR(disassoc.frame_header.unordered.addr2));
            printf("Address 3: " MACSTR "\n", MAC2STR(disassoc.frame_header.unordered.addr3));
        }

        printf("Reason: %d (0x%04x)\n", disassoc.fixed_parameters.reason_code, disassoc.fixed_parameters.reason_code);

        printf("Tagged Parameters:\n");
        if (disassoc.tags.length == 0) {
            printf("\tNo Tags\n");
        } else {
            printf("\tTags Found\n");
        }

        printf("=== End Disassociation Frame ===\n");
        printf("\n\n");
    }
}
void parse_assoc_request(struct libwifi_frame frame, unsigned char *args, const struct pcap_pkthdr *header, const unsigned char *packet) {
    if (frame.frame_control.type == TYPE_MANAGEMENT && frame.frame_control.subtype == SUBTYPE_ASSOC_REQ) {
        printf("Packet : %lu\n", packet_num);
        int ret = libwifi_parse_assoc_req(&sta, &frame);
        if (ret != 0) {
            printf("Failed to parse association request: %d\n", ret);
            pcap_dump(args, header, packet);
            return;
        }

        if (got_radiotap && parse_radiotap_header) {
            parse_radiotap(packet);
        }

        print_sta_info(&sta);
    }
}
void parse_assoc_response(struct libwifi_frame frame, unsigned char *args, const struct pcap_pkthdr *header, const unsigned char *packet) {
    if (frame.frame_control.type == TYPE_MANAGEMENT && frame.frame_control.subtype == SUBTYPE_ASSOC_RESP) {
        printf("Packet : %lu\n", packet_num);
        int ret = libwifi_parse_assoc_resp(&bss, &frame);
        if (ret != 0) {
            printf("Failed to parse association response: %d\n", ret);
            pcap_dump(args, header, packet);
            return;
        }

        if (got_radiotap && parse_radiotap_header) {
            parse_radiotap(packet);
        }

        print_bss_info(&bss);
    }
}
void parse_reassoc_request(struct libwifi_frame frame, unsigned char *args, const struct pcap_pkthdr *header, const unsigned char *packet) {
    if (frame.frame_control.type == TYPE_MANAGEMENT && frame.frame_control.subtype == SUBTYPE_REASSOC_REQ) {
        printf("Packet : %lu\n", packet_num);
        int ret = libwifi_parse_reassoc_req(&sta, &frame);
        if (ret != 0) {
            printf("Failed to parse reassociation request: %d\n", ret);
            pcap_dump(args, header, packet);
            return;
        }

        if (got_radiotap && parse_radiotap_header) {
            parse_radiotap(packet);
        }

        print_sta_info(&sta);
    }
}
void parse_reassoc_response(struct libwifi_frame frame, unsigned char *args, const struct pcap_pkthdr *header, const unsigned char *packet) {
    if (frame.frame_control.type == TYPE_MANAGEMENT && frame.frame_control.subtype == SUBTYPE_REASSOC_RESP) {
        printf("Packet : %lu\n", packet_num);
        int ret = libwifi_parse_reassoc_resp(&bss, &frame);
        if (ret != 0) {
            printf("Failed to parse reassociation response: %d\n", ret);
            pcap_dump(args, header, packet);
            return;
        }

        if (got_radiotap && parse_radiotap_header) {
            parse_radiotap(packet);
        }

        print_bss_info(&bss);
    }
}
void parse_data_eapol(struct libwifi_frame frame, unsigned char *args, const struct pcap_pkthdr *header, const unsigned char *packet) {
    if (frame.frame_control.type == TYPE_DATA) {
        if (libwifi_check_wpa_handshake(&frame) > 0) {
            printf("=== EAPOL ===\n");
            printf("WPA Handshake\n");
            int part = libwifi_check_wpa_message(&frame);
            printf("WPA Handshake Message: %s\n", libwifi_get_wpa_message_string(&frame));

            struct libwifi_wpa_auth_data data = {0};
            libwifi_get_wpa_data(&frame, &data);

            printf("EAPOL: Version: %d\n", data.version);
            printf("EAPOL: Type: %d\n", data.type);
            printf("EAPOL: Length: %d\n", data.length);
            printf("EAPOL: Descriptor: %d\n", data.descriptor);
            printf("EAPOL: Key Info: Information: 0x%04x\n", data.key_info.information);
            printf("EAPOL: Key Info: Key Length: %d\n", data.key_info.key_length);
            printf("EAPOL: Key Info: Replay Counter: %lu\n", data.key_info.replay_counter);
            printf("EAPOL: Key Info: Nonce: ");
            for (size_t i = 0; i < sizeof(data.key_info.nonce); ++i) printf("%02x ", data.key_info.nonce[i]);
                printf("\n");
            printf("EAPOL: Key Info: IV: ");
            for (size_t i = 0; i < sizeof(data.key_info.iv); ++i) printf("%02x ", data.key_info.iv[i]);
                printf("\n");
            printf("EAPOL: Key Info: RSC: ");
            for (size_t i = 0; i < sizeof(data.key_info.rsc); ++i) printf("%02x ", data.key_info.rsc[i]);
                printf("\n");
            printf("EAPOL: Key Info: ID: ");
            for (size_t i = 0; i < sizeof(data.key_info.id); ++i) printf("%02x ", data.key_info.id[i]);
                printf("\n");
            printf("EAPOL: Key Info: MIC: ");
            for (size_t i = 0; i < sizeof(data.key_info.mic); ++i) printf("%02x ", data.key_info.mic[i]);
                printf("\n");
            printf("EAPOL: Key Info: Key Data Length: %d\n", data.key_info.key_data_length);
            if (data.key_info.key_data_length) {
                printf("EAPOL: Key Info: Key Data: ");
                for (size_t i = 0; i < data.key_info.key_data_length; ++i) printf("%02x ", data.key_info.key_data[i]);
                    printf("\n");
            }

            libwifi_free_wpa_data(&data);

            printf("\n\n");
        }
    }
}

void parse_data(struct libwifi_frame frame, unsigned char *args, const struct pcap_pkthdr *header, const unsigned char *packet) {
    if (frame.frame_control.type == TYPE_DATA) {
        if (frame.flags & LIBWIFI_FLAGS_IS_QOS) {
            printf("Receiver: " MACSTR "\n", MAC2STR(frame.header.data_qos.addr1));
            printf("Transmitter: " MACSTR "\n", MAC2STR(frame.header.data_qos.addr2));
        } else {
            printf("Receiver: " MACSTR "\n", MAC2STR(frame.header.data.addr1));
            printf("Transmitter: " MACSTR "\n", MAC2STR(frame.header.data.addr2));
        }
        printf("Body Length: %zu\n", frame.len - frame.header_len);
        printf("Body:\n");
        hexdump(frame.body, frame.len - frame.header_len);
    }
}

void parse_packet(unsigned char *args, const struct pcap_pkthdr *header, const unsigned char *packet) {
    ++packet_num;
    unsigned long data_len = header->caplen;
    unsigned char *data = (unsigned char *) packet;

    struct libwifi_frame frame = {0};
    int ret = libwifi_get_wifi_frame(&frame, data, data_len, 1);
    if (ret != 0) {
        printf("[!] Error getting libwifi_frame: %d\n", ret);
        return;
    }

    memset(&bss, 0, sizeof(struct libwifi_bss));
    memset(&sta, 0, sizeof(struct libwifi_sta));

    switch (mode) {
        case MODE_BEACON:
            parse_beacon(frame, args, header, packet);
            break;
        case MODE_PROBE_REQUEST:
            parse_probe_request(frame, args, header, packet);
            break;
        case MODE_PROBE_RESPONSE:
            parse_probe_response(frame, args, header, packet);
            break;
        case MODE_DEAUTH:
            parse_deauth(frame, args, header, packet);
            break;
        case MODE_DISASSOC:
            parse_disassoc(frame, args, header, packet);
            break;
        case MODE_ASSOC_REQUEST:
            parse_assoc_request(frame, args, header, packet);
            break;
        case MODE_ASSOC_RESPONSE:
            parse_assoc_response(frame, args, header, packet);
            break;
        case MODE_REASSOC_REQUEST:
            parse_reassoc_request(frame, args, header, packet);
            break;
        case MODE_REASSOC_RESPONSE:
            parse_reassoc_response(frame, args, header, packet);
            break;
        case MODE_EAPOL:
            parse_data_eapol(frame, args, header, packet);
            break;
        case MODE_DATA:
            parse_data(frame, args, header, packet);
            break;
        case MODE_ALL:
            parse_beacon(frame, args, header, packet);
            parse_probe_request(frame, args, header, packet);
            parse_probe_response(frame, args, header, packet);
            parse_deauth(frame, args, header, packet);
            parse_disassoc(frame, args, header, packet);
            parse_assoc_request(frame, args, header, packet);
            parse_assoc_response(frame, args, header, packet);
            parse_reassoc_request(frame, args, header, packet);
            parse_reassoc_response(frame, args, header, packet);
            parse_data_eapol(frame, args, header, packet);
            parse_data(frame, args, header, packet);
        default:
            break;
    }

    libwifi_free_bss(&bss);
    libwifi_free_wifi_frame(&frame);
}

void help(const char *name) {
    fprintf(stderr, "Usage:\n");
    fprintf(stderr, "\t%s --interface [interface] [--mode] [--radiotap]\n", name);
    fprintf(stderr, "\t\tor\n");
    fprintf(stderr, "\t%s --file [capture file] [--mode] [--radiotap]\n", name);
    fprintf(stderr, "\n");
    fprintf(stderr, "Modes:\n");
    fprintf(stderr, "\t--beacon\n");
    fprintf(stderr, "\t--probe-req\n");
    fprintf(stderr, "\t--probe-resp\n");
    fprintf(stderr, "\t--deauth\n");
    fprintf(stderr, "\t--disassoc\n");
    fprintf(stderr, "\t--assoc-req\n");
    fprintf(stderr, "\t--assoc-resp\n");
    fprintf(stderr, "\t--reassoc-req\n");
    fprintf(stderr, "\t--reassoc-resp\n");
    fprintf(stderr, "\t--eapol\n");
}

void handle_args(int argc, const char *argv[]) {
    char errbuf[PCAP_ERRBUF_SIZE];

    if (argc < 4) {
        help(argv[0]);
        exit(EXIT_SUCCESS);
    }

    if (strcmp(argv[1], "--file") == 0) {
        if ((handle = pcap_open_offline(argv[2], errbuf)) == NULL) {
            fprintf(stderr, "Couldn't read file %s: %s\n", argv[2], errbuf);
            exit(EXIT_FAILURE);
        }
    } else if (strcmp(argv[1], "--interface") == 0) {
        if ((handle = pcap_create(argv[2], errbuf)) == NULL) {
            fprintf(stderr, "Failed to open interface \"%s\" for sniffing: %s\n", argv[2], errbuf);
            exit(EXIT_FAILURE);
        }
        if (pcap_activate(handle) == 0) {
            printf("[+] Started sniffing on %s\n", argv[2]);
        } else {
            fprintf(stderr, "[!] Couldn't activate capture: %s.\n", pcap_geterr(handle));
            pcap_close(handle);
            exit(EXIT_FAILURE);
        }
    } else {
        help(argv[0]);
        exit(EXIT_SUCCESS);
    }

    if (strcmp(argv[3], "--beacon") == 0) {
        mode = MODE_BEACON;
    } else if (strcmp(argv[3], "--probe-req") == 0) {
        mode = MODE_PROBE_REQUEST;
    } else if (strcmp(argv[3], "--probe-resp") == 0) {
        mode = MODE_PROBE_RESPONSE;
    } else if (strcmp(argv[3], "--deauth") == 0) {
        mode = MODE_DEAUTH;
    } else if (strcmp(argv[3], "--disassoc") == 0) {
        mode = MODE_DISASSOC;
    } else if (strcmp(argv[3], "--assoc-req") == 0) {
        mode = MODE_ASSOC_REQUEST;
    } else if (strcmp(argv[3], "--assoc-resp") == 0) {
        mode = MODE_ASSOC_RESPONSE;
    } else if (strcmp(argv[3], "--reassoc-req") == 0) {
        mode = MODE_REASSOC_REQUEST;
    } else if (strcmp(argv[3], "--reassoc-resp") == 0) {
        mode = MODE_REASSOC_RESPONSE;
    } else if (strcmp(argv[3], "--eapol") == 0) {
        mode = MODE_EAPOL;
    } else if (strcmp(argv[3], "--data") == 0) {
        mode = MODE_DATA;
    } else if (strcmp(argv[3], "--all") == 0) {
        mode = MODE_ALL;
    } else {
        help(argv[0]);
        exit(EXIT_SUCCESS);
    }

    if (argc > 4) {
        if (strcmp(argv[4], "--radiotap") == 0) {
            parse_radiotap_header = 1;
        }
    }
}

int main(int argc, const char *argv[]) {
    packet_num = 0;
    char errbuf[PCAP_ERRBUF_SIZE];

    handle_args(argc, argv);

    int linktype = pcap_datalink(handle);
    if (linktype == DLT_IEEE802_11_RADIO) {
        got_radiotap = 1;
    } else if (linktype == DLT_IEEE802_11) {
        got_radiotap = 0;
    } else {
        fprintf(stderr, "[!] 802.11 and radiotap headers not provided (%d)\n", pcap_datalink(handle));
        pcap_close(handle);
        exit(EXIT_FAILURE);
    }

    if ((filter = malloc(sizeof(struct bpf_program))) == NULL) {
        perror("Malloc failure");
        pcap_close(handle);
        exit(EXIT_FAILURE);
    }
    printf("[*] Compiling and optimizing frame filter, this can take a second\n");
    if (pcap_compile(handle, filter, FILTER, 0, 0) != 0) {
        fprintf(stderr, "[!] Couldn't compile filter: %s\n", pcap_geterr(handle));
        pcap_close(handle);
        free(filter);
        exit(EXIT_FAILURE);
    }
    if (pcap_setfilter(handle, filter) != 0) {
        fprintf(stderr, "[!] Couldn't set filter: %s\n", pcap_geterr(handle));
        pcap_close(handle);
        free(filter);
        exit(EXIT_FAILURE);
    }
    printf("[+] Complete\n");

    pd = pcap_dump_open(handle, PCAP_SAVEFILE);
    pcap_loop(handle, -1 /*INFINITY*/, &parse_packet, (unsigned char *) pd);

    return 0;
}