/* wifidump.c
 * wifidump is an extcap tool used to capture Wi-Fi frames using a remote ssh host
 *
 * Adapted from sshdump.
 *
 * Copyright 2022, Adrian Granados <adrian@intuitibits.com>
 *
 * Wireshark - Network traffic analyzer
 * By Gerald Combs <gerald@wireshark.org>
 * Copyright 1998 Gerald Combs
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */

#include "config.h"
#define WS_LOG_DOMAIN "wifidump"

#include <extcap/extcap-base.h>
#include <extcap/ssh-base.h>
#include <wsutil/interface.h>
#include <wsutil/file_util.h>
#include <wsutil/strtoi.h>
#include <wsutil/filesystem.h>
#include <wsutil/privileges.h>
#include <wsutil/please_report_bug.h>
#include <wsutil/wslog.h>

#include <errno.h>
#include <string.h>
#include <fcntl.h>

#include <cli_main.h>

static gchar* wifidump_extcap_interface;
#ifdef _WIN32
#define DEFAULT_WIFIDUMP_EXTCAP_INTERFACE "wifidump.exe"
#else
#define DEFAULT_WIFIDUMP_EXTCAP_INTERFACE "wifidump"
#endif

#define WIFIDUMP_VERSION_MAJOR "1"
#define WIFIDUMP_VERSION_MINOR "0"
#define WIFIDUMP_VERSION_RELEASE "0"

#define SSH_READ_BLOCK_SIZE 256

enum {
	EXTCAP_BASE_OPTIONS_ENUM,
	OPT_HELP,
	OPT_VERSION,
	OPT_REMOTE_HOST,
	OPT_REMOTE_PORT,
	OPT_REMOTE_USERNAME,
	OPT_REMOTE_PASSWORD,
	OPT_REMOTE_INTERFACE,
	OPT_REMOTE_CHANNEL_FREQUENCY,
	OPT_REMOTE_CHANNEL_WIDTH,
	OPT_REMOTE_FILTER,
	OPT_SSHKEY,
	OPT_SSHKEY_PASSPHRASE,
	OPT_PROXYCOMMAND,
	OPT_REMOTE_COUNT
};

static struct ws_option longopts[] = {
	EXTCAP_BASE_OPTIONS,
	{ "help", ws_no_argument, NULL, OPT_HELP},
	{ "version", ws_no_argument, NULL, OPT_VERSION},
	SSH_BASE_OPTIONS,
	{ "remote-channel-frequency", ws_required_argument, NULL, OPT_REMOTE_CHANNEL_FREQUENCY},
	{ "remote-channel-width", ws_required_argument, NULL, OPT_REMOTE_CHANNEL_WIDTH},
	{ 0, 0, 0, 0}
};

static const char * remote_capture_functions =
"\n"
"function iface_down {\n"
"  local iface=$1\n"
"  sudo ip link set $iface down > /dev/null 2>&1\n"
"}\n"
"\n"
"function iface_up {\n"
"  local iface=$1\n"
"  sudo ip link set $iface up > /dev/null 2>&1\n"
"}\n"
"\n"
"function iface_monitor {\n"
"  local iface=$1\n"
"  sudo iw dev $iface set monitor control otherbss > /dev/null 2>&1 ||\n"
"  sudo iw dev $iface set type monitor control otherbss > /dev/null 2>&1\n"
"}\n"
"\n"
"function iface_scan {\n"
"  local iface=$1\n"
"  iface_down $iface &&\n"
"  sudo iw dev $iface set type managed > /dev/null 2>&1 &&\n"
"  iface_up $iface &&\n"
"  sudo iw dev $iface scan > /dev/null 2>&1\n"
"}\n"
"\n"
"function iface_config {\n"
"  local iface=$1\n"
"  local freq=$2\n"
"  local ch_width=$3\n"
"  local center_freq=$4\n"
"  if [ $freq -eq $center_freq ]; then\n"
"    sudo iw dev $1 set freq $freq $ch_width 2>&1\n"
"  else\n"
"    sudo iw dev $1 set freq $freq $ch_width $center_freq 2>&1\n"
"  fi\n"
"}\n"
"\n"
"function iface_start {\n"
"  local iface=$1\n"
"  local count=$2\n"
"  local filter=\"${@:3}\"\n"
"  if [ $count -gt 0 ]; then\n"
"    sudo tcpdump -i $iface -U -w - -c $count $filter\n"
"  else\n"
"    sudo tcpdump -i $iface -U -w - $filter\n"
"  fi\n"
"}\n"
"\n"
"function capture_generic {\n"
"  local iface=$1\n"
"  local freq=$2\n"
"  local ch_width=$3\n"
"  local center_freq=$4\n"
"  local count=$5\n"
"  local filter=\"${@:6}\"\n"
"  if ! { iwconfig $iface | grep Monitor > /dev/null 2>&1; }; then\n"
"    iface_down    $iface &&\n"
"    iface_monitor $iface &&\n"
"    iface_up      $iface\n"
"  else\n"
"    iface_monitor $iface\n"
"  fi\n"
"  iface_config  $iface $freq $ch_width $center_freq &&\n"
"  iface_start   $iface $count $filter\n"
"}\n"
"\n"
"function capture_iwlwifi {\n"
"  local iface=$1\n"
"  local freq=$2\n"
"  local ch_width=$3\n"
"  local center_freq=$4\n"
"  local count=$5\n"
"  local filter=\"${@:6}\"\n"
"  INDEX=`sudo iw dev $iface info | grep wiphy | grep -Eo '[0-9]+'`\n"
"  sudo iw phy phy${INDEX} channels | grep $freq | grep -i disabled > /dev/null 2>&1 &&\n"
"  iface_scan $iface\n"
"  MON=${iface}mon\n"
"  sudo iw $iface interface add $MON type monitor flags none > /dev/null 2>&1\n"
"  iface_up $MON &&\n"
"  iface_down $iface &&\n"
"  iface_config $MON $freq $ch_width $center_freq &&\n"
"  iface_start $MON $count $filter\n"
"}\n"
"\n"
"function capture {\n"
"  local iface=$1\n"
"  local freq=$2\n"
"  local ch_width=$3\n"
"  local center_freq=$4\n"
"  local count=$5\n"
"  local filter=\"${@:6}\"\n"
"  if [ \"$iface\" == \"auto\" ]; then\n"
"    iface=`sudo iw dev | grep -i interface | awk '{ print $2 }' | sort | head -n 1`\n"
"  fi\n"
"  local driver=`/usr/sbin/ethtool -i $iface | grep driver | awk '{ print $2 }'`\n"
"  if [ $driver = \"iwlwifi\" ]; then\n"
"    capture_iwlwifi $iface $freq $ch_width $center_freq $count $filter\n"
"  else\n"
"    capture_generic $iface $freq $ch_width $center_freq $count $filter\n"
"  fi\n"
"}\n"
"\n";

static unsigned int wifi_freqs_2dot4_5ghz[] = {
	2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457, 2462,
	2467, 2472, 2484,
	5180, 5200, 5220, 5240, 5260, 5280, 5300, 5320, 5500, 5520, 5540, 5560, 5580,
  5600, 5620, 5640, 5660, 5680, 5700, 5720, 5745, 5765, 5785, 5805, 5825,
	0
};

static unsigned int freq_to_channel(unsigned int freq_mhz) {
	if (freq_mhz == 2484)
		return 14;
	else if (freq_mhz >= 2412 && freq_mhz <= 2484)
		return ((freq_mhz - 2412) / 5) + 1;
	else if (freq_mhz >= 5160 && freq_mhz <= 5885)
		return ((freq_mhz - 5180) / 5) + 36;
	else if (freq_mhz >= 5955 && freq_mhz <= 7115)
		return ((freq_mhz - 5955) / 5) + 1;
	else
		return 0;
}

static const char *freq_to_band(unsigned int freq_mhz)
{
	if (freq_mhz >= 2412 && freq_mhz <= 2484)
		return "2.4 GHz";
	else if (freq_mhz >= 5160 && freq_mhz <= 5885)
		return "5 GHz";
	else if (freq_mhz >= 5955 && freq_mhz <= 7115)
		return "6 GHz";
	else
	 return NULL;
}

static unsigned int center_freq(unsigned int freq_mhz, unsigned int ch_width_mhz) {

	unsigned int start_freq;

	if (ch_width_mhz == 20) {
		return freq_mhz;
	}
  else if (ch_width_mhz == 40) {
    if (freq_mhz >= 5180 && freq_mhz <= 5720) {
			for (start_freq = 5180; start_freq <= 5700; start_freq += ch_width_mhz) {
      	if (freq_mhz >= start_freq && freq_mhz <= (start_freq + 20))
        	return ((start_freq * 2) + 20) / 2;
			}
		}
    else if (freq_mhz >= 5745 && freq_mhz <= 5765)
      return 5755;
    else if (freq_mhz >= 5785 && freq_mhz <= 5805)
      return 5795;
    else if (freq_mhz >= 5955 && freq_mhz <= 7095) {
			for (start_freq = 5955; start_freq <= 7075; start_freq += ch_width_mhz) {
        if (freq_mhz >= start_freq && freq_mhz <= (start_freq + 20))
          return ((start_freq * 2) + 20) / 2;
			}
		}
	}
  else if (ch_width_mhz == 80) {
    if (freq_mhz >= 5180 && freq_mhz <= 5660) {
			for (start_freq = 5180; start_freq <= 5660; start_freq += ch_width_mhz) {
      	if (freq_mhz >= start_freq && freq_mhz <= (start_freq + 60))
        	return ((start_freq * 2) + 60) / 2;
			}
		}
    else if (freq_mhz >= 5745 && freq_mhz <= 5805)
      return 5775;
    else if (freq_mhz >= 5955 && freq_mhz <= 7055) {
			for (start_freq = 5955; start_freq <= 6995; start_freq += ch_width_mhz) {
        if (freq_mhz >= start_freq && freq_mhz <= (start_freq + 60))
        	return ((start_freq * 2) + 60) / 2;
			}
		}
	}
  else if (ch_width_mhz == 160) {
    if (freq_mhz >= 5180 && freq_mhz <= 5640) {
			for (start_freq = 5180; start_freq <= 5500; start_freq += ch_width_mhz) {
        if (freq_mhz >= start_freq && freq_mhz <= (start_freq + 140))
          return ((start_freq * 2) + 140) / 2;
			}
		}
    else if (freq_mhz >= 5955 && freq_mhz <= 7055) {
			for (start_freq = 5955; start_freq <= 6915; start_freq += ch_width_mhz) {
      	if (freq_mhz >= start_freq && freq_mhz <= (start_freq + 140))
        	return ((start_freq * 2) + 140) / 2;
			}
		}
	}

  return -1;
}

static int ssh_loop_read(ssh_channel channel, FILE* fp)
{
	int nbytes;
	int ret = EXIT_SUCCESS;
	char buffer[SSH_READ_BLOCK_SIZE];

	/* read from stdin until data are available */
	while (ssh_channel_is_open(channel) && !ssh_channel_is_eof(channel)) {
		nbytes = ssh_channel_read(channel, buffer, SSH_READ_BLOCK_SIZE, 0);
		if (nbytes < 0) {
			ws_warning("Error reading from channel");
			goto end;
		}
		if (nbytes == 0) {
			break;
		}
		if (fwrite(buffer, 1, nbytes, fp) != (guint)nbytes) {
			ws_warning("Error writing to fifo");
			ret = EXIT_FAILURE;
			goto end;
		}
		fflush(fp);
	}

	/* read loop finished... maybe something wrong happened. Read from stderr */
	while (ssh_channel_is_open(channel) && !ssh_channel_is_eof(channel)) {
		nbytes = ssh_channel_read(channel, buffer, SSH_READ_BLOCK_SIZE, 1);
		if (nbytes < 0) {
			ws_warning("Error reading from channel");
			goto end;
		}
		if (fwrite(buffer, 1, nbytes, stderr) != (guint)nbytes) {
			ws_warning("Error writing to stderr");
			break;
		}
	}

end:
	if (ssh_channel_send_eof(channel) != SSH_OK) {
		ws_warning("Error sending EOF in ssh channel");
		ret = EXIT_FAILURE;
	}
	return ret;
}

static ssh_channel run_ssh_command(ssh_session sshs, const char* capture_functions,
	const char* iface, const guint16 channel_frequency, const guint16 channel_width,
	const guint16 center_frequency, const char* cfilter, const guint32 count)
{
	gchar* cmdline;
	ssh_channel channel;
	char* quoted_iface = NULL;
	char* quoted_filter = NULL;
	char* count_str = NULL;
	unsigned int remote_port = 22;

	channel = ssh_channel_new(sshs);
	if (!channel) {
		ws_warning("Can't create channel");
		return NULL;
	}

	if (ssh_channel_open_session(channel) != SSH_OK) {
		ws_warning("Can't open session");
		ssh_channel_free(channel);
		return NULL;
	}

	ssh_options_get_port(sshs, &remote_port);

	quoted_iface = iface ? g_shell_quote(iface) : NULL;
	quoted_filter = g_shell_quote(cfilter ? cfilter : "");
	cmdline = ws_strdup_printf("%s capture %s %u %u %u %u %s",
		capture_functions,
		quoted_iface ? quoted_iface : "auto",
		channel_frequency,
		channel_width,
		center_frequency,
		count,
		quoted_filter);

	ws_debug("Running: %s", cmdline);
	if (ssh_channel_request_exec(channel, cmdline) != SSH_OK) {
		ws_warning("Can't request exec");
		ssh_channel_close(channel);
		ssh_channel_free(channel);
		channel = NULL;
	}

	g_free(quoted_iface);
	g_free(quoted_filter);
	g_free(cmdline);
	g_free(count_str);

	return channel;
}

static int ssh_open_remote_connection(const ssh_params_t* params, const char* capture_functions,
	const char* iface, const guint16 channel_frequency, const guint16 channel_width,
	const guint16 center_frequency, const char* cfilter, const guint32 count, const char* fifo)
{
	ssh_session sshs = NULL;
	ssh_channel channel = NULL;
	FILE* fp = stdout;
	int ret = EXIT_FAILURE;
	char* err_info = NULL;

	if (g_strcmp0(fifo, "-")) {
		/* Open or create the output file */
		fp = fopen(fifo, "wb");
		if (fp == NULL) {
			ws_warning("Error creating output file: %s (%s)", fifo, g_strerror(errno));
			return EXIT_FAILURE;
		}
	}

	sshs = create_ssh_connection(params, &err_info);

	if (!sshs) {
		ws_warning("Error creating connection.");
		goto cleanup;
	}

	channel = run_ssh_command(sshs, capture_functions, iface, channel_frequency,
		channel_width, center_frequency, cfilter, count);

	if (!channel) {
		ws_warning("Can't run ssh command.");
		goto cleanup;
	}

	/* read from channel and write into fp */
	if (ssh_loop_read(channel, fp) != EXIT_SUCCESS) {
		ws_warning("Error in read loop.");
		ret = EXIT_FAILURE;
		goto cleanup;
	}

	ret = EXIT_SUCCESS;
cleanup:
	if (err_info)
		ws_warning("%s", err_info);
	g_free(err_info);

	/* clean up and exit */
	ssh_cleanup(&sshs, &channel);

	if (g_strcmp0(fifo, "-"))
		fclose(fp);
	return ret;
}

static int list_config(char *interface)
{
	unsigned inc = 0;
	int i, psc;

	if (!interface) {
		ws_warning("ERROR: No interface specified.");
		return EXIT_FAILURE;
	}

	if (g_strcmp0(interface, wifidump_extcap_interface)) {
		ws_warning("ERROR: interface must be %s", wifidump_extcap_interface);
		return EXIT_FAILURE;
	}

	// Server tab
	printf("arg {number=%u}{call=--remote-host}{display=Remote SSH server address}"
		"{type=string}{tooltip=The remote SSH host. It can be both "
		"an IP address or a hostname}{required=true}{group=Server}\n", inc++);
	printf("arg {number=%u}{call=--remote-port}{display=Remote SSH server port}"
		"{type=unsigned}{tooltip=The remote SSH host port (1-65535)}"
		"{range=1,65535}{group=Server}\n", inc++);

	// Authentication tab
	printf("arg {number=%u}{call=--remote-username}{display=Remote SSH server username}"
		"{type=string}{tooltip=The remote SSH username. If not provided, "
		"the current user will be used}{group=Authentication}\n", inc++);
	printf("arg {number=%u}{call=--remote-password}{display=Remote SSH server password}"
		"{type=password}{tooltip=The SSH password, used when other methods (SSH agent "
		"or key files) are unavailable.}{group=Authentication}\n", inc++);
	printf("arg {number=%u}{call=--sshkey}{display=Path to SSH private key}"
		"{type=fileselect}{tooltip=The path on the local filesystem of the private ssh key}"
		"{mustexist=true}{group=Authentication}\n", inc++);
	printf("arg {number=%u}{call=--sshkey-passphrase}{display=SSH key passphrase}"
		"{type=password}{tooltip=Passphrase to unlock the SSH private key}{group=Authentication}\n",
		inc++);

	// Capture tab
	printf("arg {number=%u}{call=--remote-interface}{display=Remote interface}"
		"{type=string}{tooltip=The remote network interface used to capture"
		"}{default=auto}{group=Capture}\n", inc++);
	printf("arg {number=%u}{call=--remote-channel-frequency}{display=Remote channel}"
		"{type=selector}{tooltip=The remote channel used to capture}{group=Capture}\n", inc);

	unsigned int freq = 0;
	for (i = 0; (freq = wifi_freqs_2dot4_5ghz[i]); i++) {
		printf("value {arg=%u}{value=%u}{display=%s, Channel %u}\n", inc, freq, freq_to_band(freq), freq_to_channel(freq));
	}

	for (freq = 5955, psc = 3; freq <= 7115; freq += 20, psc++) {
		printf("value {arg=%u}{value=%u}{display=%s, Channel %u%s}\n", inc, freq,
			freq_to_band(freq), freq_to_channel(freq), (psc % 4 == 0) ? " (PSC)" : "");
	}
	inc++;

	printf("arg {number=%u}{call=--remote-channel-width}{display=Remote channel width}"
		"{type=selector}{tooltip=The remote channel width used to capture}"
		"{group=Capture}\n", inc);
	printf("value {arg=%u}{value=20}{display=20 MHz}\n", inc);
	printf("value {arg=%u}{value=40}{display=40 MHz}\n", inc);
	printf("value {arg=%u}{value=80}{display=80 MHz}\n", inc);
	printf("value {arg=%u}{value=160}{display=160 MHz}\n", inc);
	inc++;

	printf("arg {number=%u}{call=--remote-filter}{display=Remote capture filter}{type=string}"
		"{tooltip=The remote capture filter}{group=Capture}\n", inc++);
	printf("arg {number=%u}{call=--remote-count}{display=Frames to capture}"
		"{type=unsigned}{tooltip=The number of remote frames to capture.}"
		"{group=Capture}\n", inc++);

	extcap_config_debug(&inc);

	return EXIT_SUCCESS;
}

static char* concat_filters(const char* extcap_filter, const char* remote_filter)
{
	if (!extcap_filter && remote_filter)
		return g_strdup(remote_filter);

	if (!remote_filter && extcap_filter)
		return g_strdup(extcap_filter);

	if (!remote_filter && !extcap_filter)
		return NULL;

	return ws_strdup_printf("(%s) and (%s)", extcap_filter, remote_filter);
}

int main(int argc, char *argv[])
{
	char* err_msg;
	int result;
	int option_idx = 0;
	ssh_params_t* ssh_params = ssh_params_new();
	char* remote_interface = NULL;
	guint16 remote_channel_frequency = 0;
	guint16 remote_channel_width = 0;
	guint16 remote_center_frequency = 0;
	char* remote_filter = NULL;
	guint32 count = 0;
	int ret = EXIT_FAILURE;
	extcap_parameters* extcap_conf = g_new0(extcap_parameters, 1);
	char* help_url;
	char* help_header = NULL;
	gchar* interface_description = g_strdup("Wi-Fi remote capture");

	/* Initialize log handler early so we can have proper logging during startup. */
	extcap_log_init("wifidump");

	wifidump_extcap_interface = g_path_get_basename(argv[0]);

	/*
	 * Get credential information for later use.
	 */
	init_process_policies();

	/*
	 * Attempt to get the pathname of the directory containing the
	 * executable file.
	 */
	err_msg = configuration_init(argv[0], NULL);
	if (err_msg != NULL) {
		ws_warning("Can't get pathname of directory containing the extcap program: %s.",
			err_msg);
		g_free(err_msg);
	}

	help_url = data_file_url("wifidump.html");
	extcap_base_set_util_info(extcap_conf, argv[0], WIFIDUMP_VERSION_MAJOR, WIFIDUMP_VERSION_MINOR,
		WIFIDUMP_VERSION_RELEASE, help_url);
	g_free(help_url);
	add_libssh_info(extcap_conf);
	if (g_strcmp0(wifidump_extcap_interface, DEFAULT_WIFIDUMP_EXTCAP_INTERFACE)) {
		gchar* temp = interface_description;
		interface_description = ws_strdup_printf("%s, custom version", interface_description);
		g_free(temp);
	}
	extcap_base_register_interface(extcap_conf, wifidump_extcap_interface, interface_description, 147, "Remote capture dependent DLT");
	g_free(interface_description);

	help_header = ws_strdup_printf(
		" %s --extcap-interfaces\n"
		" %s --extcap-interface=%s --extcap-dlts\n"
		" %s --extcap-interface=%s --extcap-config\n"
		" %s --extcap-interface=%s --remote-host myhost --remote-port 22222 "
		"--remote-username myuser --remote-interface wlan0 --remote-channel-frequency 5180 "
		"--remote-channel-width 40 --fifo=FILENAME --capture\n", argv[0], argv[0], wifidump_extcap_interface, argv[0],
		wifidump_extcap_interface, argv[0], wifidump_extcap_interface);
	extcap_help_add_header(extcap_conf, help_header);
	g_free(help_header);
	extcap_help_add_option(extcap_conf, "--help", "print this help");
	extcap_help_add_option(extcap_conf, "--version", "print the version");
	extcap_help_add_option(extcap_conf, "--remote-host <host>", "the remote SSH host");
	extcap_help_add_option(extcap_conf, "--remote-port <port>", "the remote SSH port");
	extcap_help_add_option(extcap_conf, "--remote-username <username>", "the remote SSH username");
	extcap_help_add_option(extcap_conf, "--remote-password <password>", "the remote SSH password. If not specified, ssh-agent and ssh-key are used");
	extcap_help_add_option(extcap_conf, "--sshkey <public key path>", "the path of the ssh key");
	extcap_help_add_option(extcap_conf, "--sshkey-passphrase <public key passphrase>", "the passphrase to unlock public ssh");
	extcap_help_add_option(extcap_conf, "--remote-interface <iface>", "the remote capture interface");
	extcap_help_add_option(extcap_conf, "--remote-channel-frequency <channel_frequency>", "the remote channel frequency in MHz");
	extcap_help_add_option(extcap_conf, "--remote-channel-width <channel_width>", "the remote channel width in MHz");
	extcap_help_add_option(extcap_conf, "--remote-filter <filter>", "a filter for remote capture");
	extcap_help_add_option(extcap_conf, "--remote-count <count>", "the number of frames to capture");

	ws_opterr = 0;
	ws_optind = 0;

	if (argc == 1) {
		extcap_help_print(extcap_conf);
		goto end;
	}

	while ((result = ws_getopt_long(argc, argv, ":", longopts, &option_idx)) != -1) {

		switch (result) {

		case OPT_HELP:
			extcap_help_print(extcap_conf);
			ret = EXIT_SUCCESS;
			goto end;

		case OPT_VERSION:
			extcap_version_print(extcap_conf);
			ret = EXIT_SUCCESS;
			goto end;

		case OPT_REMOTE_HOST:
			g_free(ssh_params->host);
			ssh_params->host = g_strdup(ws_optarg);
			break;

		case OPT_REMOTE_PORT:
			if (!ws_strtou16(ws_optarg, NULL, &ssh_params->port) || ssh_params->port == 0) {
				ws_warning("Invalid port: %s", ws_optarg);
				goto end;
			}
			break;

		case OPT_REMOTE_USERNAME:
			g_free(ssh_params->username);
			ssh_params->username = g_strdup(ws_optarg);
			break;

		case OPT_REMOTE_PASSWORD:
			g_free(ssh_params->password);
			ssh_params->password = g_strdup(ws_optarg);
			memset(ws_optarg, 'X', strlen(ws_optarg));
			break;

		case OPT_SSHKEY:
			g_free(ssh_params->sshkey_path);
			ssh_params->sshkey_path = g_strdup(ws_optarg);
			break;

		case OPT_SSHKEY_PASSPHRASE:
			g_free(ssh_params->sshkey_passphrase);
			ssh_params->sshkey_passphrase = g_strdup(ws_optarg);
			memset(ws_optarg, 'X', strlen(ws_optarg));
			break;

		case OPT_REMOTE_INTERFACE:
			g_free(remote_interface);
			remote_interface = g_strdup(ws_optarg);
			break;

		case OPT_REMOTE_CHANNEL_FREQUENCY:
			if (!ws_strtou16(ws_optarg, NULL, &remote_channel_frequency)) {
				ws_warning("Invalid channel frequency: %s", ws_optarg);
				goto end;
			}
			break;

		case OPT_REMOTE_CHANNEL_WIDTH:
			if (!ws_strtou16(ws_optarg, NULL, &remote_channel_width)) {
				ws_warning("Invalid channel width: %s", ws_optarg);
				goto end;
			}
			break;

		case OPT_REMOTE_FILTER:
			g_free(remote_filter);
			remote_filter = g_strdup(ws_optarg);
			break;

		case OPT_REMOTE_COUNT:
			if (!ws_strtou32(ws_optarg, NULL, &count)) {
				ws_warning("Invalid value for count: %s", ws_optarg);
				goto end;
			}
			break;

		case ':':
			/* missing option argument */
			ws_warning("Option '%s' requires an argument", argv[ws_optind - 1]);
			break;

		default:
			if (!extcap_base_parse_options(extcap_conf, result - EXTCAP_OPT_LIST_INTERFACES, ws_optarg)) {
				ws_warning("Invalid option: %s", argv[ws_optind - 1]);
				goto end;
			}
		}
	}

	extcap_cmdline_debug(argv, argc);

	if (extcap_base_handle_interface(extcap_conf)) {
		ret = EXIT_SUCCESS;
		goto end;
	}

	if (extcap_conf->show_config) {
		ret = list_config(extcap_conf->interface);
		goto end;
	}

	err_msg = ws_init_sockets();
	if (err_msg != NULL) {
		ws_warning("ERROR: %s", err_msg);
		g_free(err_msg);
		ws_warning("%s", please_report_bug());
		goto end;
	}

	if (extcap_conf->capture) {
		char* filter;

		if (!ssh_params->host) {
			ws_warning("Missing parameter: --remote-host");
			goto end;
		}
		remote_center_frequency = center_freq(remote_channel_frequency, remote_channel_width);
		filter = concat_filters(extcap_conf->capture_filter, remote_filter);
		ssh_params->debug = extcap_conf->debug;
		ret = ssh_open_remote_connection(ssh_params, remote_capture_functions,
			remote_interface, remote_channel_frequency, remote_channel_width, remote_center_frequency,
			filter, count, extcap_conf->fifo);
		g_free(filter);
	} else {
		ws_debug("You should not come here... maybe some parameter missing?");
		ret = EXIT_FAILURE;
	}

end:
	/* clean up stuff */
	ssh_params_free(ssh_params);
	g_free(remote_interface);
	g_free(remote_filter);
	extcap_base_cleanup(&extcap_conf);
	return ret;
}

/*
 * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 *
 * Local variables:
 * c-basic-offset: 8
 * tab-width: 8
 * indent-tabs-mode: t
 * End:
 *
 * vi: set shiftwidth=8 tabstop=8 noexpandtab:
 * :indentSize=8:tabSize=8:noTabs=false:
 */