void execution_context::report_big_relations(unsigned threshold, std::ostream & out) const {
unsigned n = register_count();
svector<std::pair<unsigned, unsigned> > sizes;
size_t total_bytes = 0;
for(unsigned i = 0; i < n; i++) {
unsigned sz = reg(i) ? reg(i)->get_size_estimate_bytes() : 0;
total_bytes += sz;
sizes.push_back(std::make_pair(i, sz));
}
std::sort(sizes.begin(), sizes.end(), compare_size_proc());
out << "bytes " << total_bytes << "\n";
out << "bytes\trows\tannotation\n";
for(unsigned i = 0; i < n; i++) {
unsigned sz = sizes[i].second;
unsigned rg = sizes[i].first;
unsigned rows = reg(rg) ? reg(rg)->get_size_estimate_rows() : 0;
if (sz < threshold) {
continue;
}
std::string annotation;
get_register_annotation(i, annotation);
out << sz << "\t" << rows << "\t" << annotation << "\n";
}
}
void
Init_bit_utils(void)
{
VALUE rb_mCImpl;
rb_mBitUtils = rb_define_module("BitUtils");
rb_mCImpl = rb_define_module_under(rb_mBitUtils, "CImpl");
register_count(rb_mCImpl);
register_trailing_zeros(rb_mCImpl);
register_each_bit(rb_mCImpl);
}
SplashOverlay::SplashOverlay(QWidget *parent) :
QWidget(parent),
so_ui_(new Ui::SplashOverlay),
blurred_(false),
last_action_(RA_NONE),
register_cur_(0)
{
so_ui_->setupUi(this);
// Number of register action transitions (e.g. RA_NONE -> RA_DISSECTORS,
// RA_DISSECTORS -> RA_PLUGIN_REGISTER) minus two.
int register_add = 5;
#ifdef HAVE_LUA
register_add += wslua_count_plugins(); /* get count of lua plugins */
#endif
so_ui_->progressBar->setMaximum((int)register_count() + register_add);
elapsed_timer_.start();
QColor bg = QColor(tango_aluminium_6);
bg.setAlphaF(0.4);
QPalette pal;
pal.setColor(QPalette::Background, bg);
setPalette(pal);
setAutoFillBackground(true);
setStyleSheet(QString(
"QLabel {"
" color: white;"
" background: rgba(0,0,0,0);"
"}"
"QProgressBar {"
" height: 1em;"
" width: 20em;"
" border: 0.1em solid white;"
" border-radius: 0.2em;"
" color: white;"
" background: rgba(0,0,0,0);"
"}"
"QProgressBar::chunk {"
" width: 0.1em;"
" background: rgba(255, 255, 255, 50%);"
"}"
));
#ifndef THROTTLE_STARTUP
// Check for a remote connection
if (display_is_remote())
info_update_freq_ = 1000;
#endif
connect(wsApp, SIGNAL(splashUpdate(register_action_e,const char*)),
this, SLOT(splashUpdate(register_action_e,const char*)));
}
static void
net_ping_threads (void)
{
mutex_lock (&_net_thrd_r.mutex);
p_md_obj ptr = _net_thrd_r.first;
while (ptr)
{
po_thrd thrd = (po_thrd) ptr->ptr;
mutex_lock (&thrd->mutex);
if (thrd->status & F_THRD_STATUS_SUSPENDED)
{
if ((register_count (&thrd->in_objects) > (off_t) 0
|| register_count (&thrd->proc_objects) > (off_t) 0))
{
pthread_kill (thrd->pt, SIGUSR1);
if (gfl & F_OPT_VERBOSE)
{
print_str ("D6: [%X]: waking up worker\n", thrd->pt);
}
}
}
else
{
if ((thrd->timers.act_f & F_TTIME_ACT_T0)
&& (time (NULL) - thrd->timers.t0) > T_THRD_PROC_TIMEOUT)
{
pthread_kill (thrd->pt, SIGUSR1);
print_str ("D2: [%X]: thread not responding\n", thrd->pt);
}
}
pthread_mutex_unlock (&thrd->mutex);
ptr = ptr->next;
}
pthread_mutex_unlock (&_net_thrd_r.mutex);
}
SplashOverlay::SplashOverlay(QWidget *parent) :
QWidget(parent),
so_ui_(new Ui::SplashOverlay),
last_action_(RA_NONE),
register_cur_(0)
{
so_ui_->setupUi(this);
/* additional 6 for:
* dissectors, listeners,
* registering plugins, handingoff plugins,
* preferences and configuration
*/
int register_add = 6;
#ifdef HAVE_LUA
register_add++; /* additional one for lua plugins */
#endif
so_ui_->progressBar->setMaximum((int)register_count() + register_add);
time_.start();
setPalette(Qt::transparent);
setStyleSheet(QString(
"QLabel {"
" color: white;"
" background: rgba(0,0,0,0);"
"}"
"QProgressBar {"
" height: 1em;"
" width: 20em;"
" border: 0.1em solid white;"
" border-radius: 0.2em;"
" color: white;"
" background: rgba(0,0,0,0);"
"}"
"QProgressBar::chunk {"
" width: 0.1em;"
" background: rgba(255, 255, 255, 50%);"
"}"
));
#ifndef THROTTLE_STARTUP
// Check for a remote connection
if (strlen (get_conn_cfilter()) > 0)
info_update_freq_ = 1000;
#endif
connect(wsApp, SIGNAL(splashUpdate(register_action_e,const char*)),
this, SLOT(splashUpdate(register_action_e,const char*)));
}
static void
net_def_sig_handler (int signal)
{
if (!(gfl & F_OPT_KILL_GLOBAL) && register_count (&_sock_r) == 0)
{
print_str (
"NOTICE: net_def_sig_handler: [%ld]: nothing left to process [%d]\n",
syscall (SYS_gettid), signal);
mutex_lock (&mutex_glob00);
gfl |= F_OPT_KILL_GLOBAL;
pthread_mutex_unlock (&mutex_glob00);
}
else
{
//print_str("D6: net_def_sig_handler: pinging threads..\n");
//net_ping_threads ();
//sleep(1000);
}
return;
}
int
net_deploy (void)
{
if (((int) net_opts.thread_l + (int) net_opts.thread_r)
> net_opts.max_worker_threads)
{
print_str (
"ERROR: net_deploy: requested thread count exceeds 'max_worker_threads' [%d/%d]\n",
((int) net_opts.thread_l + (int) net_opts.thread_r),
net_opts.max_worker_threads);
return -1;
}
//_m_tid = getpid();
/*#ifdef M_ARENA_TEST
mallopt (M_ARENA_TEST, 1);
#endif*/
#ifdef M_ARENA_MAX
mallopt (M_ARENA_MAX, 1);
#endif
struct sigaction sa_wthrd, sa_mthrd;
sa_wthrd.sa_handler = sig_handler_null;
sa_wthrd.sa_flags = SA_RESTART;
sigfillset (&sa_wthrd.sa_mask);
//sigaddset(&sa_wthrd.sa_mask, SIGIO);
//sigaddset(&sa_wthrd.sa_mask, SIGUSR1);
sigaction (SIGIO, &sa_wthrd, NULL);
sigaction (SIGURG, &sa_wthrd, NULL);
sigaction (SIGUSR1, &sa_wthrd, NULL);
sa_mthrd.sa_handler = net_def_sig_handler;
sa_mthrd.sa_flags = SA_RESTART;
sigfillset (&sa_mthrd.sa_mask);
//sigaddset(&sa_mthrd.sa_mask, SIGUSR2);
sigaction (SIGUSR2, &sa_mthrd, NULL);
sigset_t set;
sigemptyset (&set);
sigaddset (&set, SIGPIPE);
sigaddset (&set, SIGURG);
sigaddset (&set, SIGIO);
sigaddset (&set, SIGUSR1);
sigaddset (&set, SIGHUP);
int sr = pthread_sigmask (SIG_BLOCK, &set, NULL);
uint32_t in_f = 0;
if (sr != 0)
{
print_str ("ERROR: net_deploy: pthread_sigmask failed: %d\n", sr);
abort ();
}
md_init_le (&_sock_r, (int) net_opts.max_sock);
md_init_le (&_net_thrd_r, (int) net_opts.max_worker_threads);
//md_init_le (&_thrd_r_common, 32);
md_init_le (&tasks_in, MAX_TASKS_GLOBAL);
md_init_le (&fs_jobs, 1024);
if (net_opts.flags & F_NETOPT_SSLINIT)
{
print_str ("DEBUG: initializing TLS/SSL subsystem..\n");
ssl_init ();
in_f |= F_ND_SSL_INIT;
}
int r;
po_thrd task_worker_object;
if ((r = thread_create (task_worker, 0, NULL, 0, 0,
F_THRD_NOWPID | F_THRD_NOREG,
F_THC_SKIP_IO, NULL, &task_worker_object, NULL)))
{
return r;
}
if ((r = spawn_threads (net_opts.thread_l, net_worker, 0, &_net_thrd_r,
THREAD_ROLE_NET_WORKER,
SOCKET_OPMODE_LISTENER, 0)))
{
print_str ("ERROR: spawn_threads failed [SOCKET_OPMODE_LISTENER]: %d\n",
r);
return 2;
}
else
{
print_str (
"DEBUG: deployed %hu socket worker threads [SOCKET_OPMODE_LISTENER]\n",
net_opts.thread_l);
}
if ((r = spawn_threads (net_opts.thread_r, net_worker, 0, &_net_thrd_r,
THREAD_ROLE_NET_WORKER,
SOCKET_OPMODE_RECIEVER, 0)))
{
print_str ("ERROR: spawn_threads failed [SOCKET_OPMODE_RECIEVER]: %d\n",
r);
return 2;
}
else
{
print_str (
"DEBUG: deployed %hu socket worker threads [SOCKET_OPMODE_RECIEVER]\n",
net_opts.thread_r);
}
print_str ("DEBUG: waiting for workers to initialize..\n");
if (net_deploy_wait_for_all_threads (&_net_thrd_r))
{
print_str ("D5: all workers online\n");
}
else
{
goto _t_kill;
}
int fail;
if ((fail = process_ca_requests (&_boot_pca, F_OPSOCK_LISTEN)))
{
if ((off_t) fail == _boot_pca.offset)
{
print_str (
"WARNING: process_ca_requests: no socket requests succeeded\n");
goto _t_kill;
}
else
{
print_str (
"WARNING: process_ca_requests: not all socket requests were succesfull\n");
}
}
else
{
print_str ("DEBUG: deployed %llu listener socket(s)\n",
(uint64_t) _boot_pca.offset);
}
if (fs_jobs.offset)
{
__gfs job = (__gfs ) fs_jobs.first->ptr;
if (job->id < 1 || job->id > USHRT_MAX)
{
print_str ("ERROR: invalid job id\n");
goto _ts_kill;
}
if (NULL == job->link || !strlen (job->link))
{
print_str ("ERROR: job [%d] has no path\n", job->id);
goto _ts_kill;
}
int ret;
if (!(ret = fs_link_socks_to_job (job, &_sock_r)))
{
print_str ("ERROR: job [%d] defined but no sockets link to it\n",
job->id);
goto _ts_kill;
}
//job->status |= FS_GFS_JOB_LOPEN;
print_str ("DEBUG: %d sockets linked to job [%d]\n", ret, job->id);
if ((r = spawn_threads (1, fs_worker, 0, &_net_thrd_r,
THREAD_ROLE_FS_WORKER,
0, 0)))
{
print_str (
"ERROR: spawn_threads failed [SOCKET_OPMODE_LISTENER]: %d\n", r);
return 2;
}
if (!net_deploy_wait_for_all_threads (&_net_thrd_r))
{
print_str ("ERROR: could not spawn fs_worker thread\n");
goto _t_kill;
}
}
if (net_opts.flags & F_NETOPT_CHROOT)
{
if (chroot (net_opts.chroot) == -1)
{
char err_buf[1024];
print_str (
"ERROR: netctl_opt_parse: '%s': chroot failed: [%d] [%s]\n",
net_opts.chroot,
errno,
strerror_r (errno, err_buf, sizeof(err_buf)));
goto _ts_kill;
}
print_str ("NOTICE: chrooted %s\n", net_opts.chroot);
}
if (net_opts.flags & F_NETOPT_GID)
{
if (setgid (net_opts.gid) == -1)
{
char e_buffer[1024];
print_str ("ERROR: setgid failed: %s\n",
strerror_r (errno, e_buffer, sizeof(e_buffer)));
goto _ts_kill;
}
else
{
print_str ("DEBUG: setgid: %u\n", (unsigned int) net_opts.gid);
}
}
if (net_opts.flags & F_NETOPT_UID)
{
if (setuid (net_opts.uid) == -1)
{
char e_buffer[1024];
print_str ("ERROR: setuid failed: %s\n",
strerror_r (errno, e_buffer, sizeof(e_buffer)));
goto _ts_kill;
}
else
{
print_str ("DEBUG: setuid: %u\n", (unsigned int) net_opts.uid);
}
}
if (net_opts.flags & (F_NETOPT_HUSER | F_NETOPT_HGROUP))
{
if (net_opts.flags & F_NETOPT_HUSER)
{
snprintf (G_USER, sizeof(G_USER), "%s", net_opts.user);
gfl0 |= F_OPT_SETUID;
}
if (net_opts.flags & F_NETOPT_HGROUP)
{
snprintf (G_GROUP, sizeof(G_GROUP), "%s", net_opts.group);
gfl0 |= F_OPT_SETGID;
}
g_setxid ();
}
//htest();
if ( NULL != ftp_cmd)
{
net_ftp_init (ftp_cmd);
}
net_pop_rc (NULL, &net_post_init_rc);
thread_broadcast_sig (&_net_thrd_r, SIGINT);
if ((fail = process_ca_requests (&_boot_pca, F_OPSOCK_CONNECT)))
{
if ((off_t) fail == _boot_pca.offset)
{
print_str (
"WARNING: process_ca_requests: no socket requests succeeded\n");
goto _t_kill;
}
else
{
print_str (
"WARNING: process_ca_requests: not all socket requests were succesfull\n");
}
}
while (g_get_gkill ())
{
//net_ping_threads();
sleep (-1);
}
_ts_kill: ;
if (register_count (&_sock_r))
{
print_str ("DEBUG: sending F_OPSOCK_TERM to all sockets\n");
net_nw_ssig_term_r (&_sock_r);
}
_t_kill: ;
print_str ("DEBUG: sending F_THRD_TERM to all worker threads\n");
thread_broadcast_kill (&_net_thrd_r);
print_str ("DEBUG: waiting for threads to exit..\n");
if ((r = thread_join_threads (&_net_thrd_r)))
{
print_str ("WARNING: %d threads remaining\n", r);
}
thread_send_kill (task_worker_object);
pthread_join (task_worker_object->pt, NULL);
md_g_free_l (&_net_thrd_r);
md_g_free_l (&_sock_r);
free (pc_a.objects);
md_g_free_l (&_boot_pca);
md_g_free_l (&tasks_in);
md_g_free_l (&fs_jobs);
if (in_f & F_ND_SSL_INIT)
{
print_str ("DEBUG: releasing TLS/SSL resources..\n");
ssl_cleanup ();
}
print_str ("INFO: server shutting down..\n");
return 0;
}
void
splash_update(register_action_e action, const char *message, gpointer client_data)
{
GtkWidget *win;
GtkWidget *main_lb;
GtkWidget *prog_bar;
GtkWidget *percentage_lb;
gfloat percentage;
gulong ul_percentage;
gchar tmp[100];
const char *action_msg;
static gulong ul_sofar = 0;
static gulong ul_count = 0;
static register_action_e last_action = RA_NONE;
static GTimeVal cur_tv;
static GTimeVal next_tv = {0, 0};
win = (GtkWidget *)client_data;
if (win == NULL) return;
g_get_current_time(&cur_tv);
if (last_action == action && cur_tv.tv_sec <= next_tv.tv_sec && cur_tv.tv_usec <= next_tv.tv_usec && ul_sofar < ul_count - 1) {
/* Only update every splash_register_freq milliseconds */
ul_sofar++;
return;
}
memcpy(&next_tv, &cur_tv, sizeof(next_tv));
next_tv.tv_usec += info_update_freq * 1000;
if (next_tv.tv_usec >= 1000000) {
next_tv.tv_sec++;
next_tv.tv_usec -= 1000000;
}
if(last_action != action) {
/* the action has changed */
switch(action) {
case RA_DISSECTORS:
action_msg = "Initializing dissectors ...";
break;
case RA_LISTENERS:
action_msg = "Initializing tap listeners ...";
break;
case RA_REGISTER:
action_msg = "Registering dissector ...";
break;
case RA_PLUGIN_REGISTER:
action_msg = "Registering plugins ...";
break;
case RA_PYTHON_REGISTER:
action_msg = "Registering Python dissectors ...";
break;
case RA_HANDOFF:
action_msg = "Handing off dissector ...";
break;
case RA_PLUGIN_HANDOFF:
action_msg = "Handing off plugins ...";
break;
case RA_PYTHON_HANDOFF:
action_msg = "Handing off Python dissectors ...";
break;
case RA_LUA_PLUGINS:
action_msg = "Loading Lua plugins ...";
break;
case RA_PREFERENCES:
action_msg = "Loading module preferences ...";
break;
case RA_CONFIGURATION:
action_msg = "Loading configuration files ...";
break;
default:
action_msg = "(Unknown action)";;
break;
}
splash_update_label(win, action_msg);
last_action = action;
}
if(ul_count == 0) { /* get the count of dissectors */
ul_count = register_count() + 6; /* additional 6 for:
dissectors, listeners,
registering plugins, handingoff plugins,
preferences and configuration */
#ifdef HAVE_LUA_5_1
ul_count++; /* additional one for lua plugins */
#endif
#ifdef HAVE_PYTHON
ul_count += 2; /* additional 2 for python register and handoff */
#endif
}
main_lb = g_object_get_data(G_OBJECT(win), "protocol_label");
/* make_dissector_reg.py changed -
so we need to strip off the leading elements to get back to the protocol */
if(message) {
if(!strncmp(message, "proto_register_", 15))
message += 15;
else if(!strncmp(message, "proto_reg_handoff_", 18))
message += 18;
}
gtk_label_set_text(GTK_LABEL(main_lb), message ? message : "");
ul_sofar++;
g_assert (ul_sofar <= ul_count);
percentage = (gfloat)ul_sofar/(gfloat)ul_count;
ul_percentage = (gulong)(percentage * 100);
/* update progress bar */
prog_bar = g_object_get_data(G_OBJECT(win), "progress_bar");
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(prog_bar), percentage);
percentage_lb = g_object_get_data(G_OBJECT(win), "percentage_label");
g_snprintf(tmp, sizeof(tmp), "%lu%%", ul_percentage);
gtk_label_set_text((GtkLabel*)percentage_lb, tmp);
/* Process all pending GUI events before continuing, so that
the splash screen window gets updated. */
while (gtk_events_pending()) gtk_main_iteration();
}
