void
tap_plan(unsigned tests, unsigned flags, FILE * output)
{
LOCK;
tap_flags = flags;
tap_init(output != NULL ? output : stdout);
if (have_plan != 0) {
fprintf(stderr, "You tried to plan twice!\n");
test_died = 1;
UNLOCK;
exit(255);
}
if (tests == 0) {
fprintf(stderr, "You said to run 0 tests! You've got to run something.\n");
test_died = 1;
UNLOCK;
exit(255);
}
have_plan = 1;
_expected_tests(tests);
UNLOCK;
}
int
network_plt_init(void)
{
if (config.network_type == NetworkType_IPTunnelling) {
error("IP Tunnelling networking is not supported on Windows");
return 0;
}
if (config.bridgename == NULL) {
error("Bridge name not configured");
return 0;
}
if (config.macaddress) {
/* Parse supplied MAC address */
if (!network_macaddress_parse(config.macaddress, network_hwaddr)) {
error("Unable to parse '%s' as a MAC address", config.macaddress);
return 0;
}
} else {
network_hwaddr[0] = 0x06;
network_hwaddr[1] = 0x02;
network_hwaddr[2] = 0x03;
network_hwaddr[3] = 0x04;
network_hwaddr[4] = 0x05;
network_hwaddr[5] = 0x06;
}
tap_handle = tap_init(config.bridgename);
if (tap_handle == NULL) {
return 0;
} else {
return 1;
}
}
static int
diagv(const char *fmt, va_list ap)
{
int len;
tap_init(stdout);
fputs("# ", tap_out);
len = vfprintf(tap_out, fmt, ap);
fputs("\n", tap_out);
return len + 3;
}
/*
* Note that the plan is to skip all tests
*/
void
plan_skip_all(const char * reason)
{
LOCK;
tap_init(stdout);
skip_all = 1;
fprintf(tap_out, "1..0");
if(reason != NULL) {
fprintf(tap_out, " # Skip %s", reason);
}
fprintf(tap_out, "\n");
UNLOCK;
}
void
epan_init(void (*register_all_protocols_func)(register_cb cb, gpointer client_data),
void (*register_all_handoffs_func)(register_cb cb, gpointer client_data),
register_cb cb,
gpointer client_data,
void (*report_failure)(const char *, va_list),
void (*report_open_failure)(const char *, int, gboolean),
void (*report_read_failure)(const char *, int),
void (*report_write_failure)(const char *, int))
{
init_report_err(report_failure, report_open_failure,
report_read_failure, report_write_failure);
/* initialize memory allocation subsystem */
ep_init_chunk();
se_init_chunk();
/* initialize the GUID to name mapping table */
guids_init();
except_init();
#ifdef HAVE_LIBGNUTLS
gnutls_global_init();
#elif defined(HAVE_LIBGCRYPT)
gcry_check_version(NULL);
#endif
tvbuff_init();
tap_init();
prefs_init();
proto_init(register_all_protocols_func, register_all_handoffs_func,
cb, client_data);
packet_init();
dfilter_init();
final_registration_all_protocols();
host_name_lookup_init();
expert_init();
oids_init();
#ifdef HAVE_LUA_5_1
wslua_init(NULL);
#endif
#ifdef HAVE_GEOIP
geoip_db_init();
#endif
}
void
epan_init(void (*register_all_protocols_func)(register_cb cb, gpointer client_data),
void (*register_all_handoffs_func)(register_cb cb, gpointer client_data),
register_cb cb,
gpointer client_data,
void (*report_failure_fcn_p)(const char *, va_list),
void (*report_open_failure_fcn_p)(const char *, int, gboolean),
void (*report_read_failure_fcn_p)(const char *, int),
void (*report_write_failure_fcn_p)(const char *, int))
{
init_report_err(report_failure_fcn_p, report_open_failure_fcn_p,
report_read_failure_fcn_p, report_write_failure_fcn_p);
/* initialize memory allocation subsystems */
emem_init();
wmem_init();
/* initialize the GUID to name mapping table */
guids_init();
except_init();
#ifdef HAVE_LIBGCRYPT
/* initialize libgcrypt (beware, it won't be thread-safe) */
gcry_check_version(NULL);
gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
#endif
#ifdef HAVE_LIBGNUTLS
gnutls_global_init();
#endif
tap_init();
prefs_init();
expert_init();
proto_init(register_all_protocols_func, register_all_handoffs_func,
cb, client_data);
packet_init();
dfilter_init();
final_registration_all_protocols();
/*host_name_lookup_init();*//* We load the hostname file in cf_open, no need to do it here? */
expert_packet_init();
#ifdef HAVE_LUA
wslua_init(cb, client_data);
#endif
}
/*
* Note that there's no plan.
*/
void
plan_no_plan(void)
{
LOCK;
tap_init(stdout);
if(have_plan != 0) {
fprintf(stderr, "You tried to plan twice!\n");
test_died = 1;
UNLOCK;
exit(255);
}
have_plan = 1;
no_plan = 1;
UNLOCK;
}
/* FIXME: This should be passed through a struct. */
int tape_init(const tape_init_t *init)
{
if (tape_log == LOG_ERR) {
tape_log = log_open("Tape");
}
tape_internal_init();
tape_image_init();
lib_free(tape_image_dev1);
tape_image_dev1 = lib_calloc(1, sizeof(tape_image_t));
tap_init(init);
tape_init_vars(init);
tape_traps_install();
tape_is_initialized = 1;
return 0;
}
int addon_tap_init(struct addon_plugin *a) {
struct output_tap_priv *priv = tap_init();
if (!priv)
return POM_ERR;
addon_plugin_set_priv(a, priv);
if (addon_plugin_add_param(a, "ifname", "pom0", priv->p_ifname) != POM_OK)
goto err;
if (addon_plugin_add_param(a, "persistent", "no", priv->p_persistent) != POM_OK)
goto err;
return POM_OK;
err:
output_tap_cleanup(priv);
return POM_ERR;
}
void
epan_init(void (*register_all_protocols_func)(register_cb cb, gpointer client_data),
void (*register_all_handoffs_func)(register_cb cb, gpointer client_data),
register_cb cb,
gpointer client_data)
{
/* initialize memory allocation subsystem */
wmem_init();
/* initialize the GUID to name mapping table */
guids_init();
/* initialize name resolution (addr_resolv.c) */
addr_resolv_init();
except_init();
#ifdef HAVE_LIBGCRYPT
/* initialize libgcrypt (beware, it won't be thread-safe) */
gcry_check_version(NULL);
gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
#endif
#ifdef HAVE_LIBGNUTLS
gnutls_global_init();
#endif
tap_init();
prefs_init();
expert_init();
packet_init();
proto_init(register_all_protocols_func, register_all_handoffs_func,
cb, client_data);
packet_cache_proto_handles();
dfilter_init();
final_registration_all_protocols();
print_cache_field_handles();
expert_packet_init();
#ifdef HAVE_LUA
wslua_init(cb, client_data);
#endif
}
int output_tap_init(struct output *o) {
struct output_tap_priv *priv = tap_init();
if (!priv)
return POM_ERR;
output_set_priv(o, priv);
struct registry_instance *inst = output_get_reg_instance(o);
priv->perf_pkts_out = registry_instance_add_perf(inst, "pkts_out", registry_perf_type_counter, "Number of packets processed", "pkts");
priv->perf_bytes_out = registry_instance_add_perf(inst, "bytes_out", registry_perf_type_counter, "Number of bytes processed", "bytes");
if (!priv->perf_pkts_out || !priv->perf_bytes_out)
goto err;
struct registry_param *p = registry_new_param("ifname", "pom0", priv->p_ifname, "Name of the interface to create", 0);
if (output_add_param(o, p) != POM_OK)
goto err;
p = registry_new_param("persistent", "no", priv->p_persistent, "Create a persistent interface", 0);
if (output_add_param(o, p) != POM_OK)
goto err;
p = registry_new_param("filter", "", priv->p_filter, "Filter", REGISTRY_PARAM_FLAG_NOT_LOCKED_WHILE_RUNNING);
if (output_add_param(o, p) != POM_OK)
goto err;
registry_param_set_callbacks(p, priv, output_tap_filter_parse, output_tap_filter_update);
return POM_OK;
err:
output_tap_cleanup(priv);
return POM_ERR;
}
gboolean
epan_init(void (*register_all_protocols_func)(register_cb cb, gpointer client_data),
void (*register_all_handoffs_func)(register_cb cb, gpointer client_data),
register_cb cb,
gpointer client_data)
{
volatile gboolean status = TRUE;
/* initialize memory allocation subsystem */
wmem_init();
/* initialize the GUID to name mapping table */
guids_init();
/* initialize name resolution (addr_resolv.c) */
addr_resolv_init();
except_init();
#ifdef HAVE_LIBGCRYPT
/* initialize libgcrypt (beware, it won't be thread-safe) */
gcry_check_version(NULL);
gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
#endif
#ifdef HAVE_LIBGNUTLS
gnutls_global_init();
#endif
TRY {
tap_init();
prefs_init();
expert_init();
packet_init();
capture_dissector_init();
proto_init(register_all_protocols_func, register_all_handoffs_func,
cb, client_data);
packet_cache_proto_handles();
dfilter_init();
final_registration_all_protocols();
print_cache_field_handles();
expert_packet_init();
export_pdu_init();
#ifdef HAVE_LUA
wslua_init(cb, client_data);
#endif
}
CATCH(DissectorError) {
/*
* This is probably a dissector, or something it calls,
* calling REPORT_DISSECTOR_ERROR() in a registration
* routine or something else outside the normal dissection
* code path.
*/
const char *exception_message = GET_MESSAGE;
static const char dissector_error_nomsg[] =
"Dissector writer didn't bother saying what the error was";
report_failure("Dissector bug: %s",
exception_message == NULL ?
dissector_error_nomsg : exception_message);
if (getenv("WIRESHARK_ABORT_ON_DISSECTOR_BUG") != NULL)
abort();
status = FALSE;
}
ENDTRY;
return status;
}
int main(int argc, char **argv)
{
char dev_if[16];
int opt;
int err = 0;
int daemonize = 0;
int log_level = LOG_WARN;
char *log_file = NULL;
memset(dev_if, '\0', sizeof(dev_if));
strncpy(dev_if, PHOST_DEFAULT_TAP_DEVICE, sizeof(dev_if) - 1);
phost_set_program_name(basename(argv[0]));
/* parse options */
while(1){
opt = getopt(argc, argv, "Dd:i:p:l:n:v");
if(opt < 0){
break;
}
switch(opt){
case 'D':
daemonize = 1;
break;
case 'd':
if(optarg){
if(atoi(optarg) < LOG_LEVEL_MAX){
log_level = atoi(optarg);
}
else{
phost_print_usage();
exit(1);
}
}
else{
err |= 1;
}
break;
case 'i':
if(optarg){
memset(dev_if, '\0', sizeof(dev_if));
strncpy(dev_if, optarg, sizeof(dev_if) - 1);
}
else{
err |= 1;
}
break;
case 'p':
if(optarg){
memset(pid_dir, '\0', sizeof(pid_dir));
strncpy(pid_dir, optarg, sizeof(pid_dir) - 1);
}
else{
err |= 1;
}
break;
case 'l':
if(optarg){
memset(log_dir, '\0', sizeof(log_dir));
strncpy(log_dir, optarg, sizeof(log_dir) - 1);
}
else{
err |= 1;
}
break;
case 'n':
if(optarg){
memset(host_name, '\0', sizeof(host_name));
strncpy(host_name, optarg, sizeof(host_name) - 1);
}
else{
err |= 1;
}
break;
case 'v':
log_file = LOG_OUT_STDOUT;
log_level = LOG_DEBUG;
break;
default:
err |= 1;
}
}
if(err){
phost_print_usage();
exit(1);
}
if(log_file == NULL){
log_file = (char*)malloc(sizeof(char)*(strlen(log_dir)+strlen(PHOST_LOG_FILE)+strlen(dev_if)+3));
sprintf(log_file, "%s/%s.%s", log_dir, PHOST_LOG_FILE, dev_if);
}
/* check if this process is run with root privilege */
if(getuid() != 0){
fprintf(stderr, "[ERROR] `%s' must be run with root privilege.\n", program_name);
exit(1);
}
/* register signal handler */
signal(SIGINT, phost_handle_signals);
signal(SIGTERM, phost_handle_signals);
signal(SIGPIPE, SIG_IGN);
signal(SIGUSR1, SIG_IGN);
signal(SIGUSR2, SIG_IGN);
/* initializations */
if(log_init(log_level, log_file) < 0){
fprintf(stderr, "[ERROR] cannot initialize logger.\n");
exit(1);
}
if(daemonize && (phost_daemonize() < 0)){
fprintf(stderr, "[ERROR] cannot daemonize.\n");
exit(1);
}
if(strncmp(dev_if, "tap", 3) != 0){
if(ethdev_init(dev_if) < 0){
fprintf(stderr, "[ERROR] cannot initialize Ethernet device (%s).\n", dev_if);
exit(1);
}
trx_init(ethdev_read, ethdev_send);
}
else{
if(tap_init(dev_if) < 0){
fprintf(stderr, "[ERROR] cannot create tap device (%s).\n", dev_if);
exit(1);
}
trx_init(tap_read, tap_send);
}
phost_set_global_params();
phost_create_pid_file(host_name);
cmdif_init(dev_if, stats_udp_send_update);
arp_init(host_mac_addr, host_ip_addr);
ipv4_init(host_ip_addr, host_ip_mask);
udp_init(stats_udp_recv_update);
pkt_dump = (char*)malloc(sizeof(char)*PKT_BUF_SIZE*2);
while(run){
phost_run();
cmdif_run();
arp_age_entries();
}
free(pkt_dump);
cmdif_close();
tap_close();
phost_delete_pid_file(host_name);
phost_unset_global_params();
log_close();
return 0;
}
