static void get_domain(const struct phishcheck* pchk,struct string* dest,struct string* host)
{
char* domain;
char* tld = strrchr(host->data,'.');
if(!tld) {
cli_dbgmsg("Phishcheck: Encountered a host without a tld? (%s)\n",host->data);
string_assign(dest,host);
return;
}
if(isCountryCode(pchk,tld+1)) {
const char* countrycode = tld+1;
tld = rfind(host->data,'.',tld-host->data-1);
if(!tld) {
cli_dbgmsg("Phishcheck: Weird, a name with only 2 levels (%s)\n",
host->data);
string_assign(dest,host);
return;
}
if(!isTLD(pchk,tld+1,countrycode-tld-1)) {
string_assign_ref(dest,host,tld+1);
return;/*it was a name like: subdomain.domain.uk, return domain.uk*/
}
}
/*we need to strip one more level, this is the actual domain*/
domain = rfind(host->data,'.',tld-host->data-1);
if(!domain) {
string_assign(dest,host);
return;/* it was like sourceforge.net?*/
}
string_assign_ref(dest,host,domain+1);
}
void update(void* instance)
{
InstancePtr inst = (InstancePtr) instance;
MyInstancePtr my = inst->my;
int len = inst->in_audio->len;
double* samples = inst->in_audio->samples;
double thr = trim_double(inst->in_thr->number, 0, 1);
int is_beat;
if (strcmp(my->algo.text, inst->in_algo->text) != 0
|| my->drv == 0)
{
string_assign(&my->algo, inst->in_algo);
if (my->drv) {
if (my->drv->inst) {
my->drv->destroy(my->drv->inst);
}
free(my->drv);
}
if (strcmp(inst->in_algo->text, "exp") == 0) {
my->drv = exp_get_driver();
}
else if (strcmp(inst->in_algo->text, "avg") == 0) {
my->drv = av_get_driver();
}
else {
char buffer[128];
snprintf(buffer, sizeof(buffer),
"Unsupported algo: '%s', using 'exp' instead",
my->algo.text);
s_log(0, buffer);
my->drv = exp_get_driver();
}
my->drv->inst = my->drv->create(HIST_SIZE, LOCAL_SIZE);
}
assert(my->drv);
assert(my->drv->inst);
is_beat = my->drv->is_beat(my->drv->inst, samples, len, thr);
if (is_beat)
inst->out_b->number = 1.0;
else
inst->out_b->number = 0;
}
void string_erase(String *sp)
{
string_assign(sp, 0);
}
void _type_copy_string(const void* cpv_first, const void* cpv_second, void* pv_output)
{
assert(cpv_first != NULL && cpv_second != NULL && pv_output != NULL);
string_assign((string_t*)cpv_first, (string_t*)cpv_second);
*(bool_t*)pv_output = true;
}
void show_process_info() {
vtab_t table;
int header_rows = 2;
int header_cols = 1;
int data_rows;
int show_sub_categories = (verbose || (num_pids == 1));
if (show_sub_categories) {
data_rows = PROCESS_MEMINFO_ROWS;
} else {
data_rows = num_pids;
}
// Add two extra rows for a horizontal rule followed by a total row
// Add one extra data column for a total column
init_table(&table, header_rows, header_cols, data_rows + 2, num_nodes + 1);
int total_col_ix = header_cols + num_nodes;
int total_row_ix = header_rows + data_rows + 1;
string_assign(&table, total_row_ix, 0, "Total");
if (show_sub_categories) {
// Assign left header column label for each row in table
for (int row = 0; (row < PROCESS_MEMINFO_ROWS); row++) {
string_assign(&table, (header_rows + row), 0, process_meminfo[row].label);
}
} else {
string_assign(&table, 0, 0, "PID");
repchar_assign(&table, 1, 0, '-');
printf("\nPer-node process memory usage (in MBs)\n");
}
// Set left header column width and left justify it
set_col_width(&table, 0, 16);
set_col_justification(&table, 0, COL_JUSTIFY_LEFT);
// Set up "Node <N>" column headers over data columns, plus "Total" column
for (int node_ix = 0; (node_ix <= num_nodes); node_ix++) {
int col = header_cols + node_ix;
// Assign header row label and horizontal line for this column...
string_assign(&table, 0, col, node_header[node_ix]);
repchar_assign(&table, 1, col, '-');
// Set column width, decimal places, and right justify data
set_col_width(&table, col, 16);
int decimal_places = 2;
if (compress_display) {
decimal_places = 0;
}
set_col_decimal_places(&table, col, decimal_places);
set_col_justification(&table, col, COL_JUSTIFY_RIGHT);
}
// Initialize data in table to all zeros
zero_table_data(&table, CELL_TYPE_DOUBLE);
// If (show_sub_categories), show individual process tables for each PID,
// Otherwise show one big table of process total lines from all the PIDs.
for (int pid_ix = 0; (pid_ix < num_pids); pid_ix++) {
int pid = pid_array[pid_ix];
if (show_sub_categories) {
printf("\nPer-node process memory usage (in MBs) for PID %d (%s)\n", pid, command_name_for_pid(pid));
if (pid_ix > 0) {
// Re-initialize show_sub_categories table, because we re-use it for each PID.
zero_table_data(&table, CELL_TYPE_DOUBLE);
}
} else {
// Put this row's "PID (cmd)" label in left header column for this PID total row
char tmp_buf[64];
snprintf(tmp_buf, sizeof(tmp_buf), "%d (%s)", pid, command_name_for_pid(pid));
char *p = strdup(tmp_buf);
if (p == NULL) {
perror("malloc failed line: " STRINGIFY(__LINE__));
exit(EXIT_FAILURE);
}
string_assign(&table, header_rows + pid_ix, 0, p);
set_cell_flag(&table, header_rows + pid_ix, 0, CELL_FLAG_FREEABLE);
}
// Open numa_map for this PID to get per-node data
char fname[64];
snprintf(fname, sizeof(fname), "/proc/%d/numa_maps", pid);
char buf[BUF_SIZE];
FILE *fs = fopen(fname, "r");
if (!fs) {
sprintf(buf, "Can't read /proc/%d/numa_maps", pid);
perror(buf);
continue;
}
// Add up sub-category memory used from each node. Must go line by line
// through the numa_map figuring out which category memory, node, and the
// amount.
while (fgets(buf, BUF_SIZE, fs)) {
int category = PROCESS_PRIVATE_INDEX; // init category to the catch-all...
const char *delimiters = " \t\r\n";
char *p = strtok(buf, delimiters);
while (p) {
// If the memory category for this line is still the catch-all
// (i.e. private), then see if the current token is a special
// keyword for a specific memory sub-category.
if (category == PROCESS_PRIVATE_INDEX) {
for (int ix = 0; (ix < PROCESS_PRIVATE_INDEX); ix++) {
if (!strncmp(p, process_meminfo[ix].token, strlen(process_meminfo[ix].token))) {
category = ix;
break;
}
}
}
// If the current token is a per-node pages quantity, parse the
// node number and accumulate the number of pages in the specific
// category (and also add to the total).
if (p[0] == 'N') {
int node_num = (int)strtol(&p[1], &p, 10);
if (p[0] != '=') {
perror("node value parse error");
exit(EXIT_FAILURE);
}
double value = (double)strtol(&p[1], &p, 10);
double multiplier = page_size_in_bytes;
if (category == PROCESS_HUGE_INDEX) {
multiplier = huge_page_size_in_bytes;
}
value *= multiplier;
value /= (double)MEGABYTE;
// Add value to data cell, total_col, and total_row
int tmp_row;
if (show_sub_categories) {
tmp_row = header_rows + category;
} else {
tmp_row = header_rows + pid_ix;
}
int tmp_col = header_cols + node_num;
double_addto(&table, tmp_row, tmp_col, value);
double_addto(&table, tmp_row, total_col_ix, value);
double_addto(&table, total_row_ix, tmp_col, value);
double_addto(&table, total_row_ix, total_col_ix, value);
}
// Get next token on the line
p = strtok(NULL, delimiters);
}
}
// Currently, a non-root user can open some numa_map files successfully
// without error, but can't actually read the contents -- despite the
// 444 file permissions. So, use ferror() to check here to see if we
// actually got a read error, and if so, alert the user so they know
// not to trust the zero in the table.
if (ferror(fs)) {
sprintf(buf, "Can't read /proc/%d/numa_maps", pid);
perror(buf);
}
fclose(fs);
// If showing individual tables, or we just added the last total line,
// prepare the table for display and display it...
if ((show_sub_categories) || (pid_ix + 1 == num_pids)) {
// Crompress display column widths, if requested
if (compress_display) {
for (int col = 0; (col < header_cols + num_nodes + 1); col++) {
auto_set_col_width(&table, col, 4, 16);
}
} else {
// Since not compressing the display, allow the left header
// column to be wider. Otherwise, sometimes process command
// name instance numbers can be truncated in an annoying way.
auto_set_col_width(&table, 0, 16, 24);
}
// Put dashes above Total line...
set_row_flag(&table, total_row_ix - 1, COL_FLAG_ALWAYS_SHOW);
for (int col = 0; (col < header_cols + num_nodes + 1); col++) {
repchar_assign(&table, total_row_ix - 1, col, '-');
}
// Optionally sort the table data
if (sort_table) {
int sort_col;
if ((sort_table_node < 0) || (sort_table_node >= num_nodes)) {
sort_col = total_col_ix;
} else {
sort_col = header_cols + node_ix_map[sort_table_node];
}
sort_rows_descending_by_col(&table, header_rows, header_rows + data_rows - 1, sort_col);
}
// Actually show the table
display_table(&table, screen_width, 0, 0, show_zero_data, show_zero_data);
}
} // END OF FOR_EACH-PID loop
free_table(&table);
} // show_process_info()
void show_info_from_system_file(char *file, meminfo_p meminfo, int meminfo_rows, int tok_offset) {
// Setup and init table
vtab_t table;
int header_rows = 2 - compatibility_mode;
int header_cols = 1;
// Add an extra data column for a total column
init_table(&table, header_rows, header_cols, meminfo_rows, num_nodes + 1);
int total_col_ix = header_cols + num_nodes;
// Insert token mapping in hash table and assign left header column label for each row in table
init_hash_table();
for (int row = 0; (row < meminfo_rows); row++) {
hash_insert(meminfo[row].token, meminfo[row].index);
if (compatibility_mode) {
string_assign(&table, (header_rows + row), 0, meminfo[row].token);
} else {
string_assign(&table, (header_rows + row), 0, meminfo[row].label);
}
}
// printf("There are %d table hash collisions.\n", hash_collisions);
// Set left header column width and left justify it
set_col_width(&table, 0, 16);
set_col_justification(&table, 0, COL_JUSTIFY_LEFT);
// Open /sys/devices/system/node/node?/<file> for each node and store data
// in table. If not compatibility_mode, do approximately first third of
// this loop also for (node_ix == num_nodes) to get "Total" column header.
for (int node_ix = 0; (node_ix < (num_nodes + (1 - compatibility_mode))); node_ix++) {
int col = header_cols + node_ix;
// Assign header row label and horizontal line for this column...
string_assign(&table, 0, col, node_header[node_ix]);
if (!compatibility_mode) {
repchar_assign(&table, 1, col, '-');
int decimal_places = 2;
if (compress_display) {
decimal_places = 0;
}
set_col_decimal_places(&table, col, decimal_places);
}
// Set column width and right justify data
set_col_width(&table, col, 16);
set_col_justification(&table, col, COL_JUSTIFY_RIGHT);
if (node_ix == num_nodes) {
break;
}
// Open /sys/.../node<N>/numstast file for this node...
char buf[SMALL_BUF_SIZE];
char fname[64];
snprintf(fname, sizeof(fname), "/sys/devices/system/node/node%d/%s", node_ix_map[node_ix], file);
FILE *fs = fopen(fname, "r");
if (!fs) {
sprintf(buf, "cannot open %s", fname);
perror(buf);
exit(EXIT_FAILURE);
}
// Get table values for this node...
while (fgets(buf, SMALL_BUF_SIZE, fs)) {
char *tok[64];
int tokens = 0;
const char *delimiters = " \t\r\n:";
char *p = strtok(buf, delimiters);
if (p == NULL) {
continue; // Skip blank lines;
}
while (p) {
tok[tokens++] = p;
p = strtok(NULL, delimiters);
}
// example line from numastat file: "numa_miss 16463"
// example line from meminfo file: "Node 3 Inactive: 210680 kB"
int index = hash_lookup(tok[0 + tok_offset]);
if (index < 0) {
printf("Token %s not in hash table.\n", tok[0]);
} else {
double value = (double)atol(tok[1 + tok_offset]);
if (!compatibility_mode) {
double multiplier = 1.0;
if (tokens < 4) {
multiplier = page_size_in_bytes;
} else if (!strncmp("HugePages", tok[2], 9)) {
multiplier = huge_page_size_in_bytes;
} else if (!strncmp("kB", tok[4], 2)) {
multiplier = KILOBYTE;
}
value *= multiplier;
value /= (double)MEGABYTE;
}
double_assign(&table, header_rows + index, col, value);
double_addto(&table, header_rows + index, total_col_ix, value);
}
}
fclose(fs);
}
// Crompress display column widths, if requested
if (compress_display) {
for (int col = 0; (col < header_cols + num_nodes + 1); col++) {
auto_set_col_width(&table, col, 4, 16);
}
}
// Optionally sort the table data
if (sort_table) {
int sort_col;
if ((sort_table_node < 0) || (sort_table_node >= num_nodes)) {
sort_col = total_col_ix;
} else {
sort_col = header_cols + node_ix_map[sort_table_node];
}
sort_rows_descending_by_col(&table, header_rows, header_rows + meminfo_rows - 1, sort_col);
}
// Actually display the table now, doing line-folding as necessary
display_table(&table, screen_width, 0, 0, show_zero_data, show_zero_data);
free_table(&table);
}
void assign(TypeInstanceID dst,TypeInstanceID src)
{
string_assign((StringType*) dst, (const StringType*) src);
}
void update(void* instance)
{
InstancePtr inst = (InstancePtr) instance;
MyInstancePtr my = inst->my;
int options = trim_int(inst->in_options->number, 0, INT_MAX);
int on_top = options & 1;
int frame = options & 2;
int mirrorx = options & 4;
int mirrory = options & 8;
int invert = options & 16;
int monitor = trim_int(inst->in_monitor->number, 0, 3);
int win_xsize = trim_int(inst->in_xsize->number, 0, 2048);
int win_ysize = trim_int(inst->in_ysize->number, 0, 2048);
double brightness = trim_double(inst->in_brightness->number, 0, 1);
double contrast = trim_double(inst->in_contrast->number, 0, 4);
double gamma = trim_double(inst->in_gamma->number, 0.01, 4);
int fb_xsize = inst->in_in->xsize;
int fb_ysize = inst->in_in->ysize;
int result;
char buffer[TEMP_BUF_SIZE] = "";
const char* driver_name = inst->in_driver->text;
const char* server_name = inst->in_server->text;
if (strcmp(driver_name, my->driver_name->text) != 0 ||
strcmp(server_name, my->server_name->text) != 0 ||
my->drv == 0)
{
if (my->drv != 0)
{
get_drv_window_pos(my->drv, &my->win_xpos,&my->win_ypos);
output_close(my->driver_name->text, my->server_name->text);
my->drv = 0;
}
string_assign(my->driver_name, inst->in_driver);
string_assign(my->server_name, inst->in_server);
my->drv = output_open(driver_name, server_name);
if (my->drv == 0)
return;
}
assert(my->drv != 0);
if (my->drv->inst == 0)
{
/** initialize the driver **/
my->drv->inst = my->drv->new_instance(server_name,
my->win_xpos, my->win_ypos,
my->width, my->height,
s_mmx_supported,
buffer, sizeof(buffer));
if (my->drv->inst == 0)
{
s_log(0, buffer);
output_close(driver_name, server_name);
my->drv = 0;
return;
}
// reset parameters to make sure they are initialized below
my->frame = -1;
my->monitor = -1;
my->on_top = -1;
}
assert(my->drv != 0);
assert(my->drv->inst != 0);
if (on_top != my->on_top && my->drv->always_on_top)
{
int res = my->drv->always_on_top(my->drv->inst,
on_top,
buffer, sizeof(buffer));
if (!res)
s_log(0, buffer);
my->on_top = on_top;
}
if (monitor != my->monitor && my->drv->to_monitor)
{
int res = my->drv->to_monitor(my->drv->inst,
monitor,
buffer, sizeof(buffer));
if (!res)
s_log(0, buffer);
my->monitor = monitor;
}
if (win_xsize == 0 || win_ysize == 0)
{
win_xsize = fb_xsize;
win_ysize = fb_ysize;
}
// if (win_xsize != my->width || win_ysize != my->height)
{
int res = my->drv->resize(my->drv->inst, win_xsize, win_ysize,
buffer, sizeof(buffer));
if (!res)
{
char msg[128];
snprintf(msg, sizeof(msg), "Could not resize: %s", buffer);
s_log(0, msg);
}
my->width = win_xsize;
my->height = win_ysize;
}
if (frame != my->frame && my->drv->frame)
{
int res = my->drv->frame(my->drv->inst,
frame,
buffer, sizeof(buffer));
if (!res)
s_log(0, buffer);
my->frame = frame;
}
{
struct blit_params params;
params.mirrorx = mirrorx;
params.mirrory = mirrory;
params.brightness = brightness;
params.contrast = contrast;
params.gamma = gamma;
params.invert = invert;
result = my->drv->blit(my->drv->inst,
(const uint8_t*) inst->in_in->framebuffer,
inst->in_in->xsize,
inst->in_in->ysize,
¶ms,
buffer, sizeof(buffer));
}
if (!result)
{
s_log(0, buffer);
}
}