text: /* Sniffer example.
     This example code is in the Public Domain (or CC0 licensed, at your option.)
  
     Unless required by applicable law or agreed to in writing, this
     software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
     CONDITIONS OF ANY KIND, either express or implied.
  */
  
  #include <stdio.h>
  #include <string.h>
  #include <stdlib.h>
  #include "linenoise/linenoise.h"
  #include "argtable3/argtable3.h"
  #include "tcpip_adapter.h"
  #include "esp_console.h"
  #include "esp_event_loop.h"
  #include "esp_vfs_dev.h"
  #include "esp_vfs_fat.h"
  #include "esp_wifi.h"
  #include "esp_err.h"
  #include "esp_log.h"
  #include "driver/uart.h"
  #include "driver/sdmmc_host.h"
  #include "driver/sdspi_host.h"
  #include "nvs_flash.h"
  #include "sdmmc_cmd.h"
  #include "cmd_decl.h"
  #include "sdkconfig.h"
  
  #if CONFIG_STORE_HISTORY
  #define HISTORY_MOUNT_POINT "/data"
  #define HISTORY_FILE_PATH HISTORY_MOUNT_POINT "/history.txt"
  #endif
  
  static const char *TAG = "example";
  
  #if CONFIG_STORE_HISTORY
  /* Initialize filesystem for command history store */
  static void initialize_filesystem()
  {
      static wl_handle_t wl_handle;
      const esp_vfs_fat_mount_config_t mount_config = {
          .max_files = 4,
          .format_if_mount_failed = true
      };
      esp_err_t err = esp_vfs_fat_spiflash_mount(HISTORY_MOUNT_POINT, "storage", &mount_config, &wl_handle);
      if (err != ESP_OK) {
          ESP_LOGE(TAG, "Failed to mount FATFS (%s)", esp_err_to_name(err));
          return;
      }
  }
  #endif
  
  static void initialize_nvs()
  {
      esp_err_t err = nvs_flash_init();
      if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND) {
          ESP_ERROR_CHECK(nvs_flash_erase());
          err = nvs_flash_init();
      }
      ESP_ERROR_CHECK(err);
  }
  
  /* Initialize wifi with tcp/ip adapter */
  static void initialize_wifi()
  {
      tcpip_adapter_init();
      ESP_ERROR_CHECK(esp_event_loop_init(NULL, NULL));
      wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
      ESP_ERROR_CHECK(esp_wifi_init(&cfg));
      ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));
      ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_NULL));
  }
  
  /* Initialize console component */
  static void initialize_console()
  {
      /* Disable buffering on stdin */
      setvbuf(stdin, NULL, _IONBF, 0);
  
      /* Minicom, screen, idf_monitor send CR when ENTER key is pressed */
      esp_vfs_dev_uart_set_rx_line_endings(ESP_LINE_ENDINGS_CR);
      /* Move the caret to the beginning of the next line on '\n' */
      esp_vfs_dev_uart_set_tx_line_endings(ESP_LINE_ENDINGS_CRLF);
  
      /* Install UART driver for interrupt-driven reads and writes */
      ESP_ERROR_CHECK(uart_driver_install(CONFIG_CONSOLE_UART_NUM,
                                          256, 0, 0, NULL, 0));
  
      /* Tell VFS to use UART driver */
      esp_vfs_dev_uart_use_driver(CONFIG_CONSOLE_UART_NUM);
  
      /* Initialize the console */
      esp_console_config_t console_config = {
          .max_cmdline_args = 8,
          .max_cmdline_length = 256,
  #if CONFIG_LOG_COLORS
          .hint_color = atoi(LOG_COLOR_CYAN)
  #endif
      };
      ESP_ERROR_CHECK(esp_console_init(&console_config));
  
      /* Configure linenoise line completion library */
      /* Enable multiline editing. If not set, long commands will scroll within
       * single line.
       */
      linenoiseSetMultiLine(1);
  
      /* Tell linenoise where to get command completions and hints */
      linenoiseSetCompletionCallback(&esp_console_get_completion);
      linenoiseSetHintsCallback((linenoiseHintsCallback *)&esp_console_get_hint);
  
      /* Set command history size */
      linenoiseHistorySetMaxLen(100);
  
  #if CONFIG_STORE_HISTORY
      /* Load command history from filesystem */
      linenoiseHistoryLoad(HISTORY_FILE_PATH);
  #endif
  }
  
  #if CONFIG_SNIFFER_PCAP_DESTINATION_SD
  static struct {
      struct arg_str *device;
      struct arg_end *end;
  } mount_args;
  
  /** 'mount' command */
  static int mount(int argc, char **argv)
  {
      int nerrors = arg_parse(argc, argv, (void **)&mount_args);
      if (nerrors != 0) {
          arg_print_errors(stderr, mount_args.end, argv[0]);
          return 1;
      }
      /* mount sd card */
      if (!strncmp(mount_args.device->sval[0], "sd", 2)) {
          ESP_LOGI(TAG, "Initializing SD card");
          ESP_LOGI(TAG, "Using SDMMC peripheral");
          sdmmc_host_t host = SDMMC_HOST_DEFAULT();
          sdmmc_slot_config_t slot_config = SDMMC_SLOT_CONFIG_DEFAULT();
  
          gpio_set_pull_mode(15, GPIO_PULLUP_ONLY); // CMD, needed in 4- and 1-line modes
          gpio_set_pull_mode(2, GPIO_PULLUP_ONLY);  // D0, needed in 4- and 1-line modes
          gpio_set_pull_mode(4, GPIO_PULLUP_ONLY);  // D1, needed in 4-line mode only
          gpio_set_pull_mode(12, GPIO_PULLUP_ONLY); // D2, needed in 4-line mode only
          gpio_set_pull_mode(13, GPIO_PULLUP_ONLY); // D3, needed in 4- and 1-line modes
  
          esp_vfs_fat_sdmmc_mount_config_t mount_config = {
              .format_if_mount_failed = true,
              .max_files = 4,
              .allocation_unit_size = 16 * 1024
          };
  
          // initialize SD card and mount FAT filesystem.
          sdmmc_card_t *card;
          esp_err_t ret = esp_vfs_fat_sdmmc_mount(CONFIG_SNIFFER_MOUNT_POINT, &host, &slot_config, &mount_config, &card);
          if (ret != ESP_OK) {
              if (ret == ESP_FAIL) {
                  ESP_LOGE(TAG, "Failed to mount filesystem. "
                           "If you want the card to be formatted, set format_if_mount_failed = true.");
              } else {
                  ESP_LOGE(TAG, "Failed to initialize the card (%s). "
                           "Make sure SD card lines have pull-up resistors in place.",
                           esp_err_to_name(ret));
              }
              return 1;
          }
          /* print card info if mount successfully */
          sdmmc_card_print_info(stdout, card);
      }
      return 0;
  }
  
  static void register_mount()
  {
      mount_args.device = arg_str1(NULL, NULL, "<sd>", "choose a proper device to mount/unmount");
      mount_args.end = arg_end(1);
      const esp_console_cmd_t cmd = {
          .command = "mount",
          .help = "mount the filesystem",
          .hint = NULL,
          .func = &mount,
          .argtable = &mount_args
      };
      ESP_ERROR_CHECK(esp_console_cmd_register(&cmd));
  }
  
  static int unmount(int argc, char **argv)
  {
      int nerrors = arg_parse(argc, argv, (void **)&mount_args);
      if (nerrors != 0) {
          arg_print_errors(stderr, mount_args.end, argv[0]);
          return 1;
      }
      /* unmount sd card */
      if (!strncmp(mount_args.device->sval[0], "sd", 2)) {
          if (esp_vfs_fat_sdmmc_unmount() != ESP_OK) {
              ESP_LOGE(TAG, "Card unmount failed");
              return -1;
          }
          ESP_LOGI(TAG, "Card unmounted");
      }
      return 0;
  }
  
  static void register_unmount()
  {
      mount_args.device = arg_str1(NULL, NULL, "<sd>", "choose a proper device to mount/unmount");
      mount_args.end = arg_end(1);
      const esp_console_cmd_t cmd = {
          .command = "unmount",
          .help = "unmount the filesystem",
          .hint = NULL,
          .func = &unmount,
          .argtable = &mount_args
      };
      ESP_ERROR_CHECK(esp_console_cmd_register(&cmd));
  }
  #endif // CONFIG_SNIFFER_PCAP_DESTINATION_SD
  
  void app_main(void)
  {
      initialize_nvs();
  
  #if CONFIG_STORE_HISTORY
      initialize_filesystem();
  #endif
  
      /* Initialize WiFi */
      initialize_wifi();
      /* Initialize Console component */
      initialize_console();
  
      /* Register commands */
      esp_console_register_help_command();
  #if CONFIG_SNIFFER_PCAP_DESTINATION_SD
      register_mount();
      register_unmount();
  #endif
      register_sniffer();
      register_system();
  
      /* Prompt to be printed before each line.
       * This can be customized, made dynamic, etc.
       */
      const char *prompt = LOG_COLOR_I "esp32> " LOG_RESET_COLOR;
  
      printf("\n =======================================================\n");
      printf(" |       Steps to sniffer WiFi packets                 |\n");
      printf(" |                                                     |\n");
      printf(" |  1. Enter 'help' to check all commands' usage       |\n");
      printf(" |  2. Enter 'mount <device>' to mount filesystem      |\n");
      printf(" |  3. Enter 'sniffer' to start capture packets        |\n");
      printf(" |  4. Enter 'unmount <device>' to unmount filesystem  |\n");
      printf(" |                                                     |\n");
      printf(" =======================================================\n\n");
  
      /* Figure out if the terminal supports escape sequences */
      int probe_status = linenoiseProbe();
      if (probe_status) {
          /* zero indicates success */
          printf("\n"
                 "Your terminal application does not support escape sequences.\n"
                 "Line editing and history features are disabled.\n"
                 "On Windows, try using Putty instead.\n");
          linenoiseSetDumbMode(1);
  #if CONFIG_LOG_COLORS
          /* Since the terminal doesn't support escape sequences,
           * don't use color codes in the prompt.
           */
          prompt = "esp32> ";
  #endif //CONFIG_LOG_COLORS
      }
  
      /* Main loop */
      while (true) {
          /* Get a line using linenoise.
           * The line is returned when ENTER is pressed.
           */
          char *line = linenoise(prompt);
          if (line == NULL) {
              /* Ignore empty lines */
              continue;
          }
          /* Add the command to the history */
          linenoiseHistoryAdd(line);
  
  #if CONFIG_STORE_HISTORY
          /* Save command history to filesystem */
          linenoiseHistorySave(HISTORY_FILE_PATH);
  #endif
          /* Try to run the command */
          int ret;
          esp_err_t err = esp_console_run(line, &ret);
          if (err == ESP_ERR_NOT_FOUND) {
              printf("Unrecognized command\n");
          } else if (err == ESP_OK && ret != ESP_OK) {
              printf("Command returned non-zero error code: 0x%x\n", ret);
          } else if (err != ESP_OK) {
              printf("Internal error: %s\n", esp_err_to_name(err));
          }
          /* linenoise allocates line buffer on the heap, so need to free it */
          linenoiseFree(line);
      }
  }
  