int
save_draw(ui_t *ui)
{
char field_value[80];
// Get panel information
save_info_t *info = save_info(ui);
// Get filter stats
sip_stats_t stats = sip_calls_stats();
mvwprintw(ui->win, 7, 3, "( ) all dialogs ");
mvwprintw(ui->win, 8, 3, "( ) selected dialogs [%d]", call_group_count(info->group));
mvwprintw(ui->win, 9, 3, "( ) filtered dialogs [%d]", stats.displayed);
// Print 'current SIP message' field label if required
if (info->msg != NULL)
mvwprintw(ui->win, 10, 3, "( ) current SIP message");
mvwprintw(ui->win, 7, 35, "( ) .pcap (SIP)");
mvwprintw(ui->win, 8, 35, "( ) .pcap (SIP + RTP)");
mvwprintw(ui->win, 9, 35, "( ) .txt");
// Get filename field value.
memset(field_value, 0, sizeof(field_value));
strcpy(field_value, field_buffer(info->fields[FLD_SAVE_FILE], 0));
strtrim(field_value);
mvwprintw(ui->win, 4, 60, " ");
if (strstr(field_value, ".pcap")) {
info->saveformat = (setting_enabled(SETTING_CAPTURE_RTP))? SAVE_PCAP_RTP : SAVE_PCAP;
} else if (strstr(field_value, ".txt")) {
info->saveformat = SAVE_TXT;
} else {
if (info->saveformat == SAVE_PCAP || info->saveformat == SAVE_PCAP_RTP)
mvwprintw(ui->win, 4, 60, ".pcap");
else
mvwprintw(ui->win, 4, 60, ".txt ");
}
set_field_buffer(info->fields[FLD_SAVE_ALL], 0, (info->savemode == SAVE_ALL) ? "*" : " ");
set_field_buffer(info->fields[FLD_SAVE_SELECTED], 0,
(info->savemode == SAVE_SELECTED) ? "*" : " ");
set_field_buffer(info->fields[FLD_SAVE_DISPLAYED], 0,
(info->savemode == SAVE_DISPLAYED) ? "*" : " ");
set_field_buffer(info->fields[FLD_SAVE_MESSAGE], 0,
(info->savemode == SAVE_MESSAGE) ? "*" : " ");
set_field_buffer(info->fields[FLD_SAVE_PCAP], 0, (info->saveformat == SAVE_PCAP) ? "*" : " ");
set_field_buffer(info->fields[FLD_SAVE_PCAP_RTP], 0, (info->saveformat == SAVE_PCAP_RTP) ? "*" : " ");
set_field_buffer(info->fields[FLD_SAVE_TXT], 0, (info->saveformat == SAVE_TXT) ? "*" : " ");
// Show disabled options with makers
if (!setting_enabled(SETTING_CAPTURE_RTP))
set_field_buffer(info->fields[FLD_SAVE_PCAP_RTP], 0, "-");
set_current_field(info->form, current_field(info->form));
form_driver(info->form, REQ_VALIDATION);
return 0;
}
static int
my_form_driver(FORM * form, int c)
{
static bool insert_mode = TRUE;
FIELD *field;
switch (c) {
case MY_QUIT:
if (form_driver(form, REQ_VALIDATION) == E_OK)
return (TRUE);
break;
case MY_HELP:
help_edit_field();
break;
case MY_EDT_MODE:
if ((field = current_field(form)) != 0) {
set_current_field(form, another_field(form, field));
if ((unsigned) field_opts(field) & O_EDIT) {
field_opts_off(field, O_EDIT);
set_field_status(field, 0);
} else {
field_opts_on(field, O_EDIT);
}
set_current_field(form, field);
}
break;
case MY_INS_MODE:
/* there should be a form_status() function, but there is none */
if (!insert_mode) {
if (form_driver(form, REQ_INS_MODE) == E_OK) {
insert_mode = TRUE;
}
} else {
if (form_driver(form, REQ_OVL_MODE) == E_OK) {
insert_mode = FALSE;
}
}
show_insert_mode(insert_mode);
refresh();
break;
default:
beep();
break;
}
return (FALSE);
}
void brsh_print(char const *in_output)
{
int y, x;
getyx(stdscr, y, x);
waddstr(win_output, in_output);
wrefresh(win_output);
set_current_field(frm_input, fld_input);
move(y, x);
}
void display_msg(size_t row, size_t col,
FORM * my_form,
FIELD * curr_field,
char * message) {
mvprintw( row, col, message );
size_t cur_row, cur_col;
get_cursor_pos( curr_field, &cur_row, &cur_col );
move( cur_row, cur_col );
set_current_field( my_form, curr_field );
return;
}
void brsh_printf(char const *in_output, ...)
{
va_list arg_list;
va_start(arg_list, in_output);
int y, x;
getyx(stdscr, y, x);
vwprintw(win_output, in_output, arg_list);
va_end(arg_list);
wrefresh(win_output);
set_current_field(frm_input, fld_input);
move(y, x);
}
void
call_list_form_activate(PANEL *panel, int active)
{
call_list_info_t *info = call_list_info(panel);
// Store form state
info->form_active = active;
if (active) {
set_current_field(info->form, info->fields[FLD_LIST_FILTER]);
// Show cursor
curs_set(1);
// Change current field background
set_field_back(info->fields[FLD_LIST_FILTER], A_REVERSE);
} else {
set_current_field(info->form, NULL);
// Hide cursor
curs_set(0);
// Change current field background
set_field_back(info->fields[FLD_LIST_FILTER], A_NORMAL);
}
post_form(info->form);
form_driver(info->form, REQ_END_LINE);
}
AddAccMgrForm::AddAccMgrForm(int rows, int cols, Srv* srv, const char* mgrname) : NForm(rows,cols)
{
this->srv = srv;
settitle(mgrname);
this->mgrname = mgrname;
Item* account_manager = NULL;
if (srv !=NULL)
account_manager = srv->findaccountmanager(mgrname);
//поля
int row = 0;
genfields(row,account_manager);
//пересчитываем высоту формы, чтобы влезли все поля и центрируем
int r,c =0;
scale_form(frm, &r, &c);
kLogPrintf("field_count=%d scale_form()->%d,%d\n", field_count(frm), r, c);
resize(r+3,c+2);
set_current_field(frm, fields[0]); //фокус на поле
post_form(frm);
this->refresh();
}
AddProjectForm::AddProjectForm(int rows, int cols, Srv* srv, const char* projname, bool userexist) : NForm(rows,cols)
{
this->srv = srv;
settitle(projname);
this->projname = projname;
this->userexist = userexist;
Item* project = NULL;
if (srv !=NULL)
project = srv->findprojectbynamefromall(projname);
int row = 1;
//поля
genfields(row,project);
//пересчитываем высоту формы, чтобы влезли все поля и центрируем
resize(row + 2,getwidth());
move(getmaxy(stdscr)/2-getheight()/2,getmaxx(stdscr)/2-getwidth()/2);
set_form_fields(frm, fields);
set_current_field(frm, fields[0]); //фокус на поле
post_form(frm);
this->refresh();
}
int kullanici_onayla()
{
FIELD *field[3];
FORM *my_form;
int ch;
touchwin(ana_win);
wrefresh(ana_win);
init_pair(1, COLOR_WHITE, COLOR_BLUE);
init_pair(2, COLOR_WHITE, COLOR_BLUE);
/*calisma yili 4 karakter*/
field[0] = new_field(1, 10, 18, 42, 0, 0);
/*firma 2 karakter*/
field[1] = new_field(1, 10, 20, 42, 0, 0);
field[2] = NULL;
set_field_fore(field[0], COLOR_PAIR(1));
set_field_fore(field[1], COLOR_PAIR(1));
/*geri plan rengi olsun*/
set_field_back(field[0], COLOR_PAIR(2));
set_field_back(field[1], COLOR_PAIR(2));
/*
set_field_type(field[0], TYPE_INTEGER);
set_field_type(field[1], TYPE_INTEGER);
*/
field_opts_off(field[0], O_AUTOSKIP);
field_opts_off(field[1], O_AUTOSKIP);
/*sifre alani olan ikinci field password biçiminde olmali/
field_opts_off(field[1], O_PUBLIC);
/*geri plan rengi olmasin*/
/* set_field_back(field[0], A_UNDERLINE);
set_field_back(field[1], A_UNDERLINE);
*/
my_form = new_form(field);
post_form(my_form);
refresh();
set_current_field(my_form, field[0]);
mvprintw(18, 25, _("User name :") );
mvprintw(20, 25, _("Password :"******"This application under GPL license.") );
attroff(A_BLINK);
attroff(A_BOLD);
attron(A_BOLD);
mvprintw(LINES-3, 5, _("F2-> Begin ESC-> Cancel") );
mvprintw(18, 5, _("F5-> Settings") );
attroff(A_BOLD);
mvprintw(7,3, _(" Acik "));
mvprintw(8,3," _| _| _| ");
mvprintw(9,3," _|_|_| _| _|_| _|_|_|_| _|_|_| _|_| _|_| ");
mvprintw(10,3," _| _|_| _| _|_|_|_| _| _| _| _| _|_|_|_| ");
mvprintw(11,3," _| _|_| _| _| _| _| _| _| _| ");
mvprintw(12,3," _| _|_|_| _| _|_|_| _|_| _| _| _| _|_|_| ");
refresh();
while((ch = getch()) )
{ switch(ch)
{
case 8: /*KEY_BACKSPACE hatali kod vermekte 8 dogru olandir konsolda 8 xterm key_backspace*/
form_driver(my_form, REQ_PREV_CHAR);
form_driver(my_form, REQ_DEL_CHAR);
break;
case KEY_BACKSPACE:
form_driver(my_form, REQ_PREV_CHAR);
form_driver(my_form, REQ_DEL_CHAR);
break;
case 9: /*TAB tusuna basýlmasý durumunda sonraki field konumlan*/
form_driver(my_form, REQ_NEXT_FIELD);
form_driver(my_form, REQ_END_LINE);
break;
case 10: /*ENTER tuþuna basýlmasý durumunda sonraki feild gececek*/
form_driver(my_form, REQ_NEXT_FIELD);
form_driver(my_form, REQ_END_LINE);
break;
case KEY_DC: /*del tusu*/
form_driver(my_form,REQ_DEL_CHAR);
break;
case KEY_HOME:
form_driver(my_form,REQ_BEG_LINE);
break;
case KEY_END:
form_driver(my_form,REQ_END_LINE);
break;
case KEY_DOWN:
form_driver(my_form, REQ_NEXT_FIELD);
form_driver(my_form, REQ_END_LINE);
break;
case KEY_UP:
form_driver(my_form, REQ_PREV_FIELD);
form_driver(my_form, REQ_END_LINE);
break;
case KEY_LEFT:
form_driver(my_form,REQ_LEFT_CHAR);
break;
case KEY_RIGHT:
form_driver(my_form,REQ_RIGHT_CHAR);
break;
case 27: /*esc durumunda*/
unpost_form(my_form);
free_form(my_form);
free_field(field[0]);
free_field(field[1]);
endwin();
exit(0);
break;
case KEY_F(5): /*ayarlara gecis*/
ayarlar();
unpost_form(my_form);
free_form(my_form);
free_field(field[0]);
free_field(field[1]);
endwin();
exit (0);
break;
case KEY_F(2): /*f2 durumunda*/
form_driver(my_form, REQ_PREV_FIELD);
strcpy(query, "select kullanici, sifre, haklar from kullanicilar");
if ( pgsql_sorgula(query) ==1 ) { mesaj(sql_sorgulama_hatasi); return 1;}
for (i=0;i<pgsql_row_miktar;i++)
{
sprintf(kullanici,"%s", pgsql_kayit_field() );
sprintf(sifre,"%s", pgsql_kayit_field() );
sprintf(haklar,"%s", pgsql_kayit_field() );
if ( strcmp(g_strstrip(field_buffer(field[0],0)), kullanici) ==NULL )
{
if ( (sifre_kripto_coz( g_strstrip(field_buffer(field[1],0)) , sifre) == 0) || (strcmp(g_strstrip(field_buffer(field[1],0)), sifre) == NULL ) )
{
//kullanýcý root ise haklar full olmalý
//databaseden degistirme ihtimali olabilir
if ( strstr( kullanici, "root") )
{sprintf(haklar,"%s", "1111111111111111111111111111111111111111111111111111111111111111");}
beep();
unpost_form(my_form);
free_form(my_form);
free_field(field[0]);
free_field(field[1]);
touchwin(ana_win);
wrefresh(ana_win);
return;
}
else
{
set_field_buffer(field[0],0," ");
set_field_buffer(field[1],0," ");
refresh();
//beep sesi
beep();
}
}
}
break;
default:
form_driver(my_form, ch);
break;
}
}
return 0;
/*son*/
}
void actions_dataentry_scr(const char *curr_path, const char *case_num) {
const size_t n_fields = 4;
const size_t starty = 6;
const size_t startx = 25;
FIELD *field[n_fields];
FORM *my_form;
Action_t record;
int width[] = { MAX_ACT_DATE - 1, MAX_ACT_TYPE, MAX_ACT_NOTE - 200 };
int height[] = { 1, 1, 4 };
for ( size_t i = 0; i < n_fields - 1; ++i )
field[i] = new_field(height[i], width[i], starty + i * 2, startx, 0, 0);
field[n_fields - 1] = NULL;
set_field_back( field[0], A_UNDERLINE );
field_opts_off( field[0], O_AUTOSKIP );
set_field_back( field[1], A_UNDERLINE );
field_opts_off( field[1], O_AUTOSKIP );
set_field_back( field[2], A_UNDERLINE );
field_opts_off( field[2], O_AUTOSKIP );
field_opts_off( field[2], O_STATIC );
set_max_field( field[2], MAX_ACT_NOTE );
my_form = new_form(field);
post_form(my_form);
refresh();
int note_count = MAX_ACT_NOTE;
char note_msg[4];
char date_str[MAX_ACT_DATE];
get_curr_date( date_str );
mvprintw( 0, 0, curr_path );
mvprintw( 4, 10, "Case Number: %s", case_num );
mvprintw( 6, 10, "Entry Date: " );
mvprintw( 8, 10, "Type: " );
mvprintw( 10, 10, "Note: " );
mvprintw( 15, 77, "%d", note_count );
mvprintw( 16, 10, "(F2) = Add | (ESC) = Previous Screen" );
set_visible_fields( field, 1, 3 );
size_t actions_count = actions_list( case_num );
move( 6, 25 );
set_field_buffer( field[0], 0, date_str );
set_current_field( my_form, field[0] );
record.id = 0;
int ch;
do {
ch = getch();
switch ( ch ) {
case KEY_UP:
form_driver(my_form, REQ_PREV_FIELD);
form_driver(my_form, REQ_END_LINE);
break;
case KEY_LEFT:
form_driver(my_form, REQ_LEFT_CHAR);
break;
case KEY_RIGHT:
form_driver(my_form, REQ_RIGHT_CHAR);
break;
case KEY_BACKSPACE:
{
FIELD * curr_fld = current_field( my_form );
if ( curr_fld == field[2] ) {
snprintf( note_msg, 4, "%d", ++note_count );
display_msg( 15, 77, my_form, curr_fld, note_msg );
}
}
form_driver(my_form, REQ_PREV_CHAR);
form_driver(my_form, REQ_DEL_CHAR);
break;
case DEL:
{
FIELD * curr_fld = current_field( my_form );
if ( curr_fld == field[2] ) {
snprintf( note_msg, 4, "%d", ++note_count );
display_msg( 15, 77, my_form, curr_fld, note_msg );
}
}
form_driver( my_form, REQ_DEL_CHAR );
break;
case ENTER:
form_driver( my_form, REQ_NEXT_FIELD );
form_driver( my_form, REQ_END_LINE );
break;
case KEY_F(1):
{
FIELD * curr_fld = current_field( my_form );
if ( curr_fld == field[1] ) {
if ( query_select_all_codes_from_action_types() ) {
clear_line(18, 10);
mvprintw( 18, 10, db_get_error_msg() );
} else {
const Code_t const * code_ptr;
size_t count = 0;
mvprintw( 8, 75, "Type Options:" );
while ( ( code_ptr = get_code_from_result() ) != NULL )
mvprintw( 9 + count++, 81, "[%d] %s", code_ptr->code, code_ptr->desc );
free_code_result();
int row, col;
get_cursor_pos( curr_fld, &row, &col );
move( row, col );
set_current_field( my_form, curr_fld );
}
}
}
break;
case KEY_F(2):
{
clear_line( 18, 10 );
strncpy( record.case_num, case_num, MAX_CANUM );
strncpy( record.entry_date, compress_str( field_buffer(field[0], 0) ), MAX_ACT_DATE );
record.type = atoi( compress_str( field_buffer(field[1], 0) ) );
strncpy( record.note, field_buffer(field[2], 0), MAX_ACT_NOTE );
if ( is_empty_str( record.note, MAX_ACT_NOTE ) ) {
mvprintw( 18, 10, "[!] Action must at least have a note." );
move( 10, 25 );
set_current_field( my_form, field[2] );
break;
}
if ( query_add_action( &record ) ) {
mvprintw( 18, 10, db_get_error_msg() );
} else {
clear_fields( field, 0, 2 );
actions_count++;
print_action( &record, actions_count );
note_count = MAX_ACT_NOTE;
mvprintw( 15, 77, "%d", note_count );
}
move( 6, 25 );
set_current_field( my_form, field[0] );
}
break;
default:
{
FIELD * curr_fld = current_field( my_form );
if ( ch == '\'' )
break;
if ( curr_fld == field[1] ) {
if ( !isdigit( ch ) )
break;
} else if ( curr_fld == field[2] ) {
snprintf( note_msg, 4, "%d", --note_count );
display_msg( 15, 77, my_form, curr_fld, note_msg );
}
}
form_driver( my_form, ch );
break;
}
} while ( ch != ESC );
unpost_form( my_form );
free_form( my_form );
for ( size_t i = 0; i < n_fields - 1; ++i )
free_field( field[i] );
return;
}
void actions_menu(const char *curr_path) {
const char *screen_title = "Actions";
FIELD *field[2];
FORM *my_form;
initscr();
curs_set(1);
cbreak();
clear();
noecho();
keypad(stdscr, TRUE);
field[0] = new_field( 1, MAX_CANUM, 4, 25, 0, 0 );
field[1] = NULL;
set_field_back(field[0], A_UNDERLINE);
field_opts_off(field[0], O_AUTOSKIP);
field_opts_on(field[0], O_BLANK);
my_form = new_form(field);
post_form(my_form);
refresh();
mvprintw( 0, 0, menu_path( curr_path, screen_title ) );
mvprintw( 2, 10, "Enter case number then press (Enter) to start. | (F4) = Exit" );
mvprintw( 4, 10, "Case Num: " );
refresh();
move( 4, 25 );
set_current_field( my_form, field[0] );
int done = 0;
int ch;
do {
ch = getch();
switch ( ch ) {
case KEY_LEFT:
form_driver(my_form, REQ_LEFT_CHAR);
break;
case KEY_RIGHT:
form_driver(my_form, REQ_RIGHT_CHAR);
break;
case KEY_BACKSPACE:
form_driver(my_form, REQ_PREV_CHAR);
form_driver(my_form, REQ_DEL_CHAR);
break;
case DEL:
form_driver( my_form, REQ_DEL_CHAR );
break;
case ENTER:
{
size_t count = 0;
char case_num[MAX_CANUM];
form_driver(my_form, REQ_NEXT_FIELD);
strcpy(case_num, compress_str(field_buffer(field[0], 0) ));
if ( query_select_count_from_case_for(case_num, &count) ) {
clear_line(20, 10);
mvprintw( 20, 10, db_get_error_msg() );
move( 4, 25 );
} else {
if ( count ) {
actions_dataentry_scr( menu_path( curr_path, screen_title ), case_num );
done = 1;
break;
}
}
}
break;
default:
if ( ch == '\'' )
break;
form_driver( my_form, ch );
break;
}
} while ( ( ch != KEY_F(4) ) && ( done != 1 ) );
unpost_form( my_form );
free_form( my_form );
free_field( field[0] );
endwin();
return;
}
void summons_dataentry_scr(const char *curr_path, const char *case_num) {
const size_t n_fields = 6;
const size_t starty = 6;
const size_t startx = 25;
FIELD *field[n_fields];
FORM *my_form;
Summon_t record;
int width[] = { MAX_SUMM_NAME, MAX_SUMM_STATUS, MAX_SUMM_REASON,
MAX_SUMM_CITY, MAX_SUMM_DATE
};
for ( size_t i = 0; i < n_fields - 1; ++i )
field[i] = new_field(1, width[i], starty + i * 2, startx, 0, 0);
field[n_fields - 1] = NULL;
set_field_back( field[0], A_UNDERLINE );
field_opts_off( field[0], O_AUTOSKIP );
set_field_back( field[1], A_UNDERLINE );
field_opts_on( field[1], O_BLANK );
field_opts_off( field[1], O_AUTOSKIP );
set_field_back( field[2], A_UNDERLINE );
field_opts_off( field[2], O_AUTOSKIP );
field_opts_on( field[2], O_BLANK );
set_field_back( field[3], A_UNDERLINE );
field_opts_off( field[3], O_AUTOSKIP );
field_opts_on( field[3], O_BLANK );
set_field_back( field[4], A_UNDERLINE );
field_opts_off( field[4], O_AUTOSKIP );
my_form = new_form(field);
post_form(my_form);
refresh();
mvprintw( 0, 0, curr_path );
mvprintw( 4, 10, "Case Number: %s", case_num );
mvprintw( 6, 10, "Person: " );
mvprintw( 8, 10, "Status: " );
mvprintw( 10, 10, "Reason: " );
mvprintw( 12, 10, "City: " );
mvprintw( 14, 10, "Date Summoned: " );
mvprintw( 16, 10, "(F1) = Options | (F2) = Update | (F3) = Delete | (F5) = List | (ESC) = Main Menu" );
set_visible_fields( field, 1, 5 );
move( 6, 25 );
set_current_field( my_form, field[0] );
record.id = 0;
int ch;
do {
ch = getch();
switch ( ch ) {
case KEY_UP:
form_driver(my_form, REQ_PREV_FIELD);
form_driver(my_form, REQ_END_LINE);
break;
case KEY_LEFT:
form_driver(my_form, REQ_LEFT_CHAR);
break;
case KEY_RIGHT:
form_driver(my_form, REQ_RIGHT_CHAR);
break;
case KEY_BACKSPACE:
form_driver(my_form, REQ_PREV_CHAR);
form_driver(my_form, REQ_DEL_CHAR);
break;
case ENTER:
form_driver( my_form, REQ_NEXT_FIELD );
if ( current_field( my_form ) == field[0] )
form_driver( my_form, REQ_END_LINE );
break;
case KEY_F(1):
clear_lines( 20, 40 );
{
FIELD * curr_fld = current_field( my_form );
size_t error = 0;
size_t in_target_fld = 0;
char fld_name[7];
if ( curr_fld == field[1] ) {
error = query_select_all_codes_from_summon_status();
in_target_fld = 1;
strncpy( fld_name, "Status", 7 );
} else if ( curr_fld == field[2] ) {
error = query_select_all_codes_from_summon_reasons();
in_target_fld = 1;
strncpy( fld_name, "Reason", 7 );
} else if ( curr_fld == field[3] ) {
if ( query_select_all_codes_from_city_rates() ) {
clear_line(20, 10);
mvprintw( 20, 10, db_get_error_msg() );
move( 12, 25 );
set_current_field( my_form, curr_fld );
} else {
const SCode_t const * scode_ptr;
size_t count = 0;
size_t column = 10;
mvprintw( 20, 5, "Cities:" );
while ( ( scode_ptr = get_scode_from_result() ) != NULL ) {
mvprintw( 21 + count++, column, "[%s] %s", scode_ptr->code, scode_ptr->name );
if ( count == 30 ) {
column += 20;
count = 0;
}
}
free_scode_result();
}
}
if ( !error && in_target_fld ) {
const Code_t const * code_ptr;
size_t count = 0;
mvprintw( 20, 5, "%s Options:", fld_name );
while ( ( code_ptr = get_code_from_result() ) != NULL )
mvprintw( 21 + count++, 10, "[%d] %s", code_ptr->code, code_ptr->desc );
free_code_result();
}
int row, col;
get_cursor_pos( curr_fld, &row, &col );
move( row, col );
set_current_field( my_form, curr_fld );
}
break;
case KEY_F(2):
clear_lines( 20, 40 );
char person_name[MAX_SUMM_NAME];
strncpy( person_name, field_buffer(field[0], 0), MAX_SUMM_NAME );
if ( is_empty_str( person_name, MAX_SUMM_NAME ) ) {
mvprintw( 20, 10, "[!] Summon must at least have the person's name." );
move( 6, 25 );
set_current_field( my_form, field[0] );
break;
}
strncpy( record.case_num, case_num, MAX_CANUM );
strncpy( record.name, field_buffer(field[0], 0), MAX_SUMM_NAME );
record.status = atoi( compress_str( field_buffer(field[1], 0) ) );
record.reason = atoi( compress_str( field_buffer(field[2], 0) ) );
strncpy( record.city_code, compress_str( field_buffer(field[3], 0) ), MAX_SUMM_CITY );
strncpy( record.summon_date, compress_str( field_buffer(field[4], 0) ), MAX_SUMM_DATE );
if ( query_update_summon( &record ) ) {
mvprintw( 20, 10, db_get_error_msg() );
move( 6, 25 );
set_current_field( my_form, field[0] );
} else {
clear_fields( field, 0, 4 );
mvprintw( 20, 10, "[!] Summon has been updated." );
move( 6, 25 );
set_current_field( my_form, field[0] );
record.id = 0;
}
break;
case KEY_F(3):
clear_lines( 20, 40 );
if ( record.id > 0 ) {
mvprintw( 20, 10, "[?] Delete summon '%u' ? [Y/n]", record.id );
int ch = toupper( getch() );
if ( ch == 'Y' ) {
if ( query_delete_summon( record.id ) ) {
mvprintw( 20, 10, db_get_error_msg() );
} else {
clear_fields( field, 0, 4 );
mvprintw( 20, 10, "[!] Summon '%u' has been deleted.", record.id );
move( 6, 25 );
set_current_field( my_form, field[0] );
record.id = 0;
}
}
}
break;
case KEY_F(5):
clear_lines( 20, 40 );
if ( query_select_all_from_summons_for( case_num ) ) {
mvprintw( 20, 10, db_get_error_msg() );
} else {
Summon_t *summ_ptr;
Summon_t *summons[MAX_SUMM_SET];
size_t count = 0;
while ( ( summ_ptr = get_summon_from_result() ) != NULL ) {
summons[count] = summ_ptr;
count++;
}
if ( count ) {
size_t selection;
char code_buff[4];
summons_list_scr( summons, count, &selection );
if ( selection > 0 ) {
summ_ptr = summons[selection - 1];
record.id = summ_ptr->id;
set_field_buffer( field[0], 0, summ_ptr->name );
snprintf( code_buff, 4, "%d", summ_ptr->status );
set_field_buffer( field[1], 0, code_buff );
snprintf( code_buff, 4, "%d", summ_ptr->reason );
set_field_buffer( field[2], 0, code_buff );
set_field_buffer( field[3], 0, summ_ptr->city_code );
set_field_buffer( field[4], 0, summ_ptr->summon_date );
}
free_summon_result();
} else {
mvprintw( 20, 10, "[!] Case %s has no summons.", case_num );
}
}
set_current_field( my_form, field[0] );
move( 6, 25 );
break;
default:
{
FIELD * curr_fld = current_field( my_form );
if ( ch == '\'' )
break;
if ( curr_fld == field[1] || curr_fld == field[2] ) {
if ( !isdigit( ch ) )
break;
} else if ( curr_fld == field[3] ) {
if ( !isalpha( ch ) )
break;
else
ch = toupper( ch );
}
form_driver( my_form, ch );
break;
}
}
} while ( ch != ESC );
unpost_form( my_form );
free_form( my_form );
for ( size_t i = 0; i < n_fields - 1; ++i )
free_field( field[i] );
return;
}
void cases_menu(const char *curr_path) {
const char *screen_title = "Cases";
const size_t n_fields = 7;
const size_t starty = 4;
const size_t startx = 25;
FIELD *field[n_fields];
FORM *my_form;
int width[] = { MAX_CANUM, MAX_CINUM,
MAX_PHYADD, MAX_POSADD,
MAX_STATUS, MAX_DELDATE
};
initscr();
curs_set(1);
cbreak();
clear();
noecho();
keypad(stdscr, TRUE);
for (size_t i = 0; i < n_fields - 1; ++i) {
field[i] = new_field(1, width[i], starty + i * 2, startx, 0, 0);
}
field[n_fields - 1] = NULL;
set_field_back(field[0], A_UNDERLINE);
field_opts_off(field[0], O_AUTOSKIP);
field_opts_on(field[0], O_BLANK);
set_field_back(field[1], A_UNDERLINE);
field_opts_off(field[1], O_AUTOSKIP);
set_field_back(field[2], A_UNDERLINE);
field_opts_off(field[2], O_AUTOSKIP);
set_field_back(field[3], A_UNDERLINE);
field_opts_off(field[3], O_AUTOSKIP);
set_field_back(field[4], A_UNDERLINE);
field_opts_off(field[4], O_AUTOSKIP);
set_field_back(field[5], A_UNDERLINE);
field_opts_off(field[5], O_AUTOSKIP);
my_form = new_form(field);
post_form(my_form);
refresh();
mvprintw(0, 0, menu_path(curr_path, screen_title));
mvprintw(4, 10, "Case Num: ");
mvprintw(6, 10, "Civil Num: ");
mvprintw(8, 10, "Physical Add: ");
mvprintw(10, 10, "Postal Add: ");
mvprintw(12, 10, "Status: ");
mvprintw(14, 10, "Delivery Date: ");
mvprintw(16, 10, "(F1) = Options | (F2) = Update | (F3) = Delete | (F4) = Exit");
move(4, 25);
refresh();
int ch;
do {
ch = getch();
switch(ch) {
case KEY_UP:
form_driver(my_form, REQ_PREV_FIELD);
form_driver(my_form, REQ_END_LINE);
break;
case KEY_LEFT:
form_driver(my_form, REQ_LEFT_CHAR);
break;
case KEY_RIGHT:
form_driver(my_form, REQ_RIGHT_CHAR);
break;
case ENTER:
form_driver( my_form, REQ_NEXT_FIELD );
form_driver( my_form, REQ_END_LINE );
if (field_status(field[0])) {
size_t count = 0;
char case_num[MAX_CANUM];
clear_line( 20, 10 );
strcpy( case_num, compress_str(field_buffer(field[0], 0) ) );
if ( query_select_count_from_case_for(case_num, &count) ) {
mvprintw( 20, 10, db_get_error_msg() );
move( 4, 25 );
} else {
if ( count ) {
//call routine to fill in fields
Case_t record;
if ( query_select_all_from_case_for(case_num, &record) ) {
mvprintw( 20, 10, db_get_error_msg() );
move( 4, 25 );
} else {
char status_buff[4];
set_field_buffer( field[1], 0, record.civil );
set_field_buffer( field[2], 0, record.physical_add );
set_field_buffer( field[3], 0, record.postal_add );
snprintf( status_buff, 4, "%d", record.status );
set_field_buffer( field[4], 0, status_buff );
set_field_buffer( field[5], 0, record.delivery_date );
}
} else {
clear_fields( field, 1, 5 );
mvprintw( 20, 10, "[!] Case %s does not exist.", case_num );
move( 6, 25 );
set_current_field( my_form, field[0] );
}
}
set_field_status( field[0], 0 );
}
break;
case KEY_BACKSPACE:
form_driver(my_form, REQ_PREV_CHAR);
form_driver(my_form, REQ_DEL_CHAR);
break;
case ESC:
{
FIELD * curr_field = current_field( my_form );
int row, col;
get_cursor_pos( curr_field, &row, &col );
clear_lines( 20, 40 );
move( row, col );
set_current_field( my_form, curr_field );
}
break;
case KEY_F(1):
if ( current_field( my_form ) == field[4] ) {
clear_lines( 20, 30 );
if ( query_select_all_codes_from_case_status() ) {
mvprintw( 20, 10, db_get_error_msg() );
} else {
const Code_t const * code_ptr;
size_t count = 0;
mvprintw( 20, 5, "Status Options:" );
while ( ( code_ptr = get_code_from_result() ) != NULL ) {
mvprintw( 21 + count, 10, "[%d] %s", code_ptr->code, code_ptr->desc );
count++;
}
free_code_result();
move( 12, 25 );
set_current_field( my_form, field[4] );
}
}
break;
case KEY_F(2):
{
size_t count = 0;
char case_num[MAX_CANUM];
clear_lines( 20, 30 );
strncpy( case_num, compress_str(field_buffer(field[0], 0) ), MAX_CANUM );
if ( query_select_count_from_case_for( case_num, &count ) ) {
mvprintw( 20, 10, db_get_error_msg() );
} else {
Case_t record;
strncpy( record.number, compress_str(field_buffer(field[0], 0)), MAX_CANUM );
strncpy( record.civil, compress_str(field_buffer(field[1], 0)), MAX_CINUM );
strncpy( record.physical_add, field_buffer(field[2], 0), MAX_PHYADD );
strncpy( record.postal_add, field_buffer(field[3], 0), MAX_POSADD );
record.status = atoi( compress_str(field_buffer(field[4], 0)) );
strncpy( record.delivery_date, compress_str(field_buffer(field[5], 0)), MAX_DELDATE );
if ( count ) {
// update existing record
if ( query_update_case( &record ) == 0 ) {
mvprintw( 20, 10, "[!] Case has been updated." );
} else {
mvprintw( 20, 10, db_get_error_msg() );
}
} else {
// create new record
if ( query_create_new_case( &record ) == 0 ) {
mvprintw (20, 10, "[!] Case has been created successfully." );
} else {
mvprintw( 20, 10, db_get_error_msg() );
}
}
}
move(4, 25);
set_current_field( my_form, field[0] );
}
break;
case KEY_F(3):
{
size_t count = 0;
char case_num[MAX_CANUM];
clear_lines(20, 30);
strncpy(case_num, compress_str(field_buffer(field[0], 0) ), MAX_CANUM);
if ( strlen(case_num) ) {
if ( query_select_count_from_case_for(case_num, &count) ) {
mvprintw( 20, 10, db_get_error_msg() );
} else {
if (count) {
mvprintw(20, 10, "[?] Delete case '%s' ? [Y/n]", case_num);
int ch = toupper(getch());
if (ch == 'Y') {
if ( query_delete_case(case_num) ) {
mvprintw( 20, 10, db_get_error_msg() );
} else {
clear_fields(field, 0, 5);
mvprintw(20, 10, "[!] Case '%s' has been deleted.");
}
}
} else {
mvprintw(20, 10, "[!] Case '%s' does not exist.", case_num);
}
}
} else {
mvprintw(20, 10, "[!] Must enter a valid Case Number to be deleted.");
}
}
move(4, 25);
set_current_field(my_form, field[0]);
break;
case DEL:
form_driver(my_form, REQ_DEL_CHAR);
break;
default:
{
FIELD * curr_fld = current_field( my_form );
if ( ch == '\'' )
break;
if ( curr_fld == field[4] ) {
if ( !isdigit( ch ) )
break;
}
}
form_driver(my_form, ch);
break;
}
} while( ch != KEY_F(4) );
unpost_form(my_form);
free_form(my_form);
for (size_t i = 0; i < n_fields -1; ++i) {
free_field(field[i]);
}
endwin();
return;
}
void
save_create(ui_t *ui)
{
save_info_t *info;
char savepath[128];
// Pause the capture while saving
capture_set_paused(1);
// Cerate a new indow for the panel and form
ui_panel_create(ui, 15, 68);
// Initialize save panel specific data
info = sng_malloc(sizeof(save_info_t));
// Store it into panel userptr
set_panel_userptr(ui->panel, (void*) info);
// Initialize the fields int total, displayed;
info->fields[FLD_SAVE_PATH] = new_field(1, 52, 3, 13, 0, 0);
info->fields[FLD_SAVE_FILE] = new_field(1, 47, 4, 13, 0, 0);
info->fields[FLD_SAVE_ALL] = new_field(1, 1, 7, 4, 0, 0);
info->fields[FLD_SAVE_SELECTED] = new_field(1, 1, 8, 4, 0, 0);
info->fields[FLD_SAVE_DISPLAYED] = new_field(1, 1, 9, 4, 0, 0);
info->fields[FLD_SAVE_MESSAGE] = new_field(1, 1, 10, 4, 0, 0);
info->fields[FLD_SAVE_PCAP] = new_field(1, 1, 7, 36, 0, 0);
info->fields[FLD_SAVE_PCAP_RTP] = new_field(1, 1, 8, 36, 0, 0);
info->fields[FLD_SAVE_TXT] = new_field(1, 1, 9, 36, 0, 0);
info->fields[FLD_SAVE_SAVE] = new_field(1, 10, ui->height - 2, 20, 0, 0);
info->fields[FLD_SAVE_CANCEL] = new_field(1, 10, ui->height - 2, 40, 0, 0);
info->fields[FLD_SAVE_COUNT] = NULL;
// Set fields options
field_opts_off(info->fields[FLD_SAVE_PATH], O_AUTOSKIP);
field_opts_off(info->fields[FLD_SAVE_FILE], O_AUTOSKIP);
field_opts_off(info->fields[FLD_SAVE_ALL], O_AUTOSKIP);
field_opts_off(info->fields[FLD_SAVE_SELECTED], O_AUTOSKIP);
field_opts_off(info->fields[FLD_SAVE_DISPLAYED], O_AUTOSKIP);
field_opts_off(info->fields[FLD_SAVE_MESSAGE], O_VISIBLE);
// Change background of input fields
set_field_back(info->fields[FLD_SAVE_PATH], A_UNDERLINE);
set_field_back(info->fields[FLD_SAVE_FILE], A_UNDERLINE);
// Disable Save RTP if RTP packets are not being captured
if (!setting_enabled(SETTING_CAPTURE_RTP))
field_opts_off(info->fields[FLD_SAVE_PCAP_RTP], O_ACTIVE);
// Create the form and post it
info->form = new_form(info->fields);
set_form_sub(info->form, ui->win);
post_form(info->form);
form_opts_off(info->form, O_BS_OVERLOAD);
// Set Default field values
sprintf(savepath, "%s", setting_get_value(SETTING_SAVEPATH));
set_field_buffer(info->fields[FLD_SAVE_PATH], 0, savepath);
set_field_buffer(info->fields[FLD_SAVE_SAVE], 0, "[ Save ]");
set_field_buffer(info->fields[FLD_SAVE_CANCEL], 0, "[ Cancel ]");
// Set window boxes
wattron(ui->win, COLOR_PAIR(CP_BLUE_ON_DEF));
// Window border
title_foot_box(ui->panel);
// Header and footer lines
mvwhline(ui->win, ui->height - 3, 1, ACS_HLINE, ui->width - 1);
mvwaddch(ui->win, ui->height - 3, 0, ACS_LTEE);
mvwaddch(ui->win, ui->height - 3, ui->width - 1, ACS_RTEE);
// Save mode box
mvwaddch(ui->win, 6, 2, ACS_ULCORNER);
mvwhline(ui->win, 6, 3, ACS_HLINE, 30);
mvwaddch(ui->win, 6, 32, ACS_URCORNER);
mvwvline(ui->win, 7, 2, ACS_VLINE, 4);
mvwvline(ui->win, 7, 32, ACS_VLINE, 4);
mvwaddch(ui->win, 11, 2, ACS_LLCORNER);
mvwhline(ui->win, 11, 3, ACS_HLINE, 30);
mvwaddch(ui->win, 11, 32, ACS_LRCORNER);
// Save mode box
mvwaddch(ui->win, 6, 34, ACS_ULCORNER);
mvwhline(ui->win, 6, 35, ACS_HLINE, 30);
mvwaddch(ui->win, 6, 64, ACS_URCORNER);
mvwvline(ui->win, 7, 34, ACS_VLINE, 3);
mvwvline(ui->win, 7, 64, ACS_VLINE, 3);
mvwaddch(ui->win, 10, 34, ACS_LLCORNER);
mvwhline(ui->win, 10, 35, ACS_HLINE, 30);
mvwaddch(ui->win, 10, 64, ACS_LRCORNER);
wattroff(ui->win, COLOR_PAIR(CP_BLUE_ON_DEF));
// Set screen labels
mvwprintw(ui->win, 1, 27, "Save capture");
mvwprintw(ui->win, 3, 3, "Path:");
mvwprintw(ui->win, 4, 3, "Filename:");
wattron(ui->win, COLOR_PAIR(CP_BLUE_ON_DEF));
mvwprintw(ui->win, 6, 4, " Dialogs ");
mvwprintw(ui->win, 6, 36, " Format ");
wattroff(ui->win, COLOR_PAIR(CP_BLUE_ON_DEF));
// Set default cursor position
set_current_field(info->form, info->fields[FLD_SAVE_FILE]);
form_driver(info->form, REQ_END_LINE);
curs_set(1);
// Get filter stats
sip_stats_t stats = sip_calls_stats();
// Set default save modes
info->savemode = (stats.displayed == stats.total) ? SAVE_ALL : SAVE_DISPLAYED;
info->saveformat = (setting_enabled(SETTING_CAPTURE_RTP))? SAVE_PCAP_RTP : SAVE_PCAP;
}
void from_to_selector(const char *curr_path, char **from, char **to, int *action) {
const size_t n_fields = 3;
const size_t starty = 6;
const size_t startx = 25;
FIELD *field[n_fields];
FORM *my_form;
int width[] = { MAX_FROM_DATE, MAX_TO_DATE };
int height[] = { 1, 1 };
initscr();
curs_set(1);
cbreak();
clear();
noecho();
keypad(stdscr, TRUE);
for ( size_t i = 0; i < n_fields - 1; ++i )
field[i] = new_field(height[i], width[i], starty + i * 2, startx, 0, 0);
field[n_fields - 1] = NULL;
set_field_back( field[0], A_UNDERLINE );
field_opts_off( field[0], O_AUTOSKIP );
set_field_back( field[1], A_UNDERLINE );
field_opts_off( field[1], O_AUTOSKIP );
my_form = new_form(field);
post_form(my_form);
refresh();
mvprintw( 0, 0, curr_path );
mvprintw( 4, 10, "Enter period for report:" );
mvprintw( 6, 10, "From: " );
mvprintw( 8, 10, "To: " );
mvprintw( 10, 10, "(F2) = Execute | (ESC) = Previous Screen" );
move( 6, 25 );
set_current_field( my_form, field[0] );
int ch;
do {
ch = getch();
switch ( ch ) {
case KEY_UP:
form_driver(my_form, REQ_PREV_FIELD);
form_driver(my_form, REQ_END_LINE);
break;
case KEY_LEFT:
form_driver(my_form, REQ_LEFT_CHAR);
break;
case KEY_RIGHT:
form_driver(my_form, REQ_RIGHT_CHAR);
break;
case KEY_BACKSPACE:
form_driver(my_form, REQ_PREV_CHAR);
form_driver(my_form, REQ_DEL_CHAR);
break;
case ENTER:
form_driver( my_form, REQ_NEXT_FIELD );
form_driver( my_form, REQ_END_LINE );
break;
case KEY_F(2):
{
char my_from[MAX_FROM_DATE];
strncpy( my_from, compress_str(field_buffer( field[0], 0 )), MAX_FROM_DATE );
*from = malloc( strlen( my_from ) + 1 );
strcpy( *from, my_from );
char my_to[MAX_TO_DATE];
strncpy( my_to, compress_str(field_buffer( field[1], 0 )), MAX_TO_DATE );
*to = malloc( strlen( my_to ) + 1 );
strcpy( *to, my_to );
}
break;
case DEL:
form_driver(my_form, REQ_DEL_CHAR);
break;
default:
if ( ch == '\'' )
break;
form_driver( my_form, ch );
break;
}
} while ( (ch != ESC) && (ch != KEY_F(2)) );
*action = ch;
unpost_form( my_form );
free_form( my_form );
for ( size_t i = 0; i < n_fields - 1; ++i )
free_field( field[i] );
return;
}
PANEL *
filter_create()
{
PANEL *panel;
WINDOW *win;
int height, width;
filter_info_t *info;
const char *method;
// Calculate window dimensions
height = 16;
width = 50;
// Cerate a new indow for the panel and form
win = newwin(height, width, (LINES - height) / 2, (COLS - width) / 2);
// Create a new panel
panel = new_panel(win);
// Initialize Filter panel specific data
info = sng_malloc(sizeof(filter_info_t));
// Store it into panel userptr
set_panel_userptr(panel, (void*) info);
// Initialize the fields
info->fields[FLD_FILTER_SIPFROM] = new_field(1, 28, 3, 18, 0, 0);
info->fields[FLD_FILTER_SIPTO] = new_field(1, 28, 4, 18, 0, 0);
info->fields[FLD_FILTER_SRC] = new_field(1, 18, 5, 18, 0, 0);
info->fields[FLD_FILTER_DST] = new_field(1, 18, 6, 18, 0, 0);
info->fields[FLD_FILTER_PAYLOAD] = new_field(1, 28, 7, 18, 0, 0);
info->fields[FLD_FILTER_REGISTER] = new_field(1, 1, 9, 15, 0, 0);
info->fields[FLD_FILTER_INVITE] = new_field(1, 1, 10, 15, 0, 0);
info->fields[FLD_FILTER_SUBSCRIBE] = new_field(1, 1, 11, 15, 0, 0);
info->fields[FLD_FILTER_NOTIFY] = new_field(1, 1, 12, 15, 0, 0);
info->fields[FLD_FILTER_OPTIONS] = new_field(1, 1, 9, 37, 0, 0);
info->fields[FLD_FILTER_PUBLISH] = new_field(1, 1, 10, 37, 0, 0);
info->fields[FLD_FILTER_MESSAGE] = new_field(1, 1, 11, 37, 0, 0);
info->fields[FLD_FILTER_FILTER] = new_field(1, 10, height - 2, 11, 0, 0);
info->fields[FLD_FILTER_CANCEL] = new_field(1, 10, height - 2, 30, 0, 0);
info->fields[FLD_FILTER_COUNT] = NULL;
// Set fields options
field_opts_off(info->fields[FLD_FILTER_SIPFROM], O_AUTOSKIP);
field_opts_off(info->fields[FLD_FILTER_SIPTO], O_AUTOSKIP);
field_opts_off(info->fields[FLD_FILTER_SRC], O_AUTOSKIP);
field_opts_off(info->fields[FLD_FILTER_DST], O_AUTOSKIP);
field_opts_off(info->fields[FLD_FILTER_PAYLOAD], O_AUTOSKIP);
field_opts_off(info->fields[FLD_FILTER_REGISTER], O_AUTOSKIP);
field_opts_off(info->fields[FLD_FILTER_INVITE], O_AUTOSKIP);
field_opts_off(info->fields[FLD_FILTER_SUBSCRIBE], O_AUTOSKIP);
field_opts_off(info->fields[FLD_FILTER_NOTIFY], O_AUTOSKIP);
field_opts_off(info->fields[FLD_FILTER_OPTIONS], O_AUTOSKIP);
field_opts_off(info->fields[FLD_FILTER_PUBLISH], O_AUTOSKIP);
field_opts_off(info->fields[FLD_FILTER_MESSAGE], O_AUTOSKIP);
field_opts_off(info->fields[FLD_FILTER_FILTER], O_EDIT);
field_opts_off(info->fields[FLD_FILTER_CANCEL], O_EDIT);
// Change background of input fields
set_field_back(info->fields[FLD_FILTER_SIPFROM], A_UNDERLINE);
set_field_back(info->fields[FLD_FILTER_SIPTO], A_UNDERLINE);
set_field_back(info->fields[FLD_FILTER_SRC], A_UNDERLINE);
set_field_back(info->fields[FLD_FILTER_DST], A_UNDERLINE);
set_field_back(info->fields[FLD_FILTER_PAYLOAD], A_UNDERLINE);
// Create the form and post it
info->form = new_form(info->fields);
set_form_sub(info->form, win);
post_form(info->form);
// Fields labels
mvwprintw(win, 3, 3, "SIP From:");
mvwprintw(win, 4, 3, "SIP To:");
mvwprintw(win, 5, 3, "Source:");
mvwprintw(win, 6, 3, "Destination:");
mvwprintw(win, 7, 3, "Payload:");
mvwprintw(win, 9, 3, "REGISTER [ ]");
mvwprintw(win, 10, 3, "INVITE [ ]");
mvwprintw(win, 11, 3, "SUBSCRIBE [ ]");
mvwprintw(win, 12, 3, "NOTIFY [ ]");
mvwprintw(win, 9, 25, "OPTIONS [ ]");
mvwprintw(win, 10, 25, "PUBLISH [ ]");
mvwprintw(win, 11, 25, "MESSAGE [ ]");
// Get Method filter
if (!(method = filter_get(FILTER_METHOD)))
method = setting_get_value(SETTING_FILTER_METHODS);
// Set Default field values
set_field_buffer(info->fields[FLD_FILTER_SIPFROM], 0, filter_get(FILTER_SIPFROM));
set_field_buffer(info->fields[FLD_FILTER_SIPTO], 0, filter_get(FILTER_SIPTO));
set_field_buffer(info->fields[FLD_FILTER_SRC], 0, filter_get(FILTER_SOURCE));
set_field_buffer(info->fields[FLD_FILTER_DST], 0, filter_get(FILTER_DESTINATION));
set_field_buffer(info->fields[FLD_FILTER_PAYLOAD], 0, filter_get(FILTER_PAYLOAD));
set_field_buffer(info->fields[FLD_FILTER_REGISTER], 0,
strcasestr(method, sip_method_str(SIP_METHOD_REGISTER)) ? "*" : "");
set_field_buffer(info->fields[FLD_FILTER_INVITE], 0,
strcasestr(method, sip_method_str(SIP_METHOD_INVITE)) ? "*" : "");
set_field_buffer(info->fields[FLD_FILTER_SUBSCRIBE], 0,
strcasestr(method,sip_method_str(SIP_METHOD_SUBSCRIBE)) ? "*" : "");
set_field_buffer(info->fields[FLD_FILTER_NOTIFY], 0,
strcasestr(method, sip_method_str(SIP_METHOD_NOTIFY)) ? "*" : "");
set_field_buffer(info->fields[FLD_FILTER_OPTIONS], 0,
strcasestr(method, sip_method_str(SIP_METHOD_OPTIONS)) ? "*" : "");
set_field_buffer(info->fields[FLD_FILTER_PUBLISH], 0,
strcasestr(method, sip_method_str(SIP_METHOD_PUBLISH)) ? "*" : "");
set_field_buffer(info->fields[FLD_FILTER_MESSAGE], 0,
strcasestr(method, sip_method_str(SIP_METHOD_MESSAGE)) ? "*" : "");
set_field_buffer(info->fields[FLD_FILTER_FILTER], 0, "[ Filter ]");
set_field_buffer(info->fields[FLD_FILTER_CANCEL], 0, "[ Cancel ]");
// Set the window title and boxes
mvwprintw(win, 1, 18, "Filter options");
wattron(win, COLOR_PAIR(CP_BLUE_ON_DEF));
title_foot_box(panel);
mvwhline(win, 8, 1, ACS_HLINE, 49);
mvwaddch(win, 8, 0, ACS_LTEE);
mvwaddch(win, 8, 49, ACS_RTEE);
wattroff(win, COLOR_PAIR(CP_BLUE_ON_DEF));
// Set default cursor position
set_current_field(info->form, info->fields[FLD_FILTER_SIPFROM]);
wmove(win, 3, 18);
curs_set(1);
return panel;
}
PANEL *
save_raw_create()
{
PANEL *panel;
WINDOW *win;
int height, width;
save_raw_info_t *info;
char savefile[128];
// Calculate window dimensions
height = 10;
width = 90;
// Cerate a new indow for the panel and form
win = newwin(height, width, (LINES - height) / 2, (COLS - width) / 2);
// Create a new panel
panel = new_panel(win);
// Initialize save panel specific data
info = malloc(sizeof(save_raw_info_t));
memset(info, 0, sizeof(save_raw_info_t));
// Store it into panel userptr
set_panel_userptr(panel, (void*) info);
// Initialize the fields
info->fields[FLD_SAVE_RAW_FILE] = new_field(1, 68, 3, 15, 0, 0);
info->fields[FLD_SAVE_RAW_SELECTED] = new_field(1, 1, 4, 5, 0, 0);
info->fields[FLD_SAVE_RAW_SAVE] = new_field(1, 10, height - 2, 30, 0, 0);
info->fields[FLD_SAVE_RAW_CANCEL] = new_field(1, 10, height - 2, 50, 0, 0);
info->fields[FLD_SAVE_RAW_COUNT] = NULL;
// Set fields options
field_opts_off(info->fields[FLD_SAVE_RAW_FILE], O_AUTOSKIP);
// Change background of input fields
set_field_back(info->fields[FLD_SAVE_RAW_FILE], A_UNDERLINE);
// Create the form and post it
info->form = new_form(info->fields);
set_form_sub(info->form, win);
post_form(info->form);
// Fields labels
mvwprintw(win, 3, 3, "Save file:");
mvwprintw(win, 4, 4, "[ ] Only save selected calls");
// Set Default field values
sprintf(savefile, "%s/sngrep-raw-%u.txt", get_option_value("sngrep.savepath"),
(unsigned) time(NULL));
set_field_buffer(info->fields[FLD_SAVE_RAW_FILE], 0, savefile);
set_field_buffer(info->fields[FLD_SAVE_RAW_SELECTED], 0,
is_option_enabled("sngrep.saveselected") ? "*" : "");
set_field_buffer(info->fields[FLD_SAVE_RAW_SAVE], 0, "[ Save ]");
set_field_buffer(info->fields[FLD_SAVE_RAW_CANCEL], 0, "[ Cancel ]");
// Set the window title and boxes
mvwprintw(win, 1, 28, "Save raw data to file");
wattron(win, COLOR_PAIR(CP_BLUE_ON_DEF));
title_foot_box(panel_window(panel));
mvwhline(win, height - 3, 1, ACS_HLINE, width - 1);
mvwaddch(win, height - 3, 0, ACS_LTEE);
mvwaddch(win, height - 3, width - 1, ACS_RTEE);
wattroff(win, COLOR_PAIR(CP_BLUE_ON_DEF));
// Set default cursor position
set_current_field(info->form, info->fields[FLD_SAVE_RAW_FILE]);
wmove(win, 3, 15);
curs_set(1);
return panel;
}
/*
* form_page(3x)
*/
static VALUE rbncurs_c_set_current_field(VALUE rb_form, VALUE rb_field) {
FORM* form = get_form(rb_form);
FIELD* field = get_field(rb_field);
return INT2NUM(set_current_field(form, field));
}
int eq_run (kr_client_t *client, char *sysname) {
WINDOW *eq_win,*tmpw;
PANEL *eq_mainpan,*eq_subpan,*ctrl_subp;
FORM *eq_form;
FIELD **field;
FIELD **ctrl_field;
FORM *ctrl_form;
/* Panels Structs */
ctrls_show_t *ctrls;
eq_port_t *eqport;
db_show_t *db;
hz_show_t *hz;
bw_show_t *bw;
eq_saved_val_t *vals;
int i;
int max_co,subx,suby,gap;
int offs = 0;
int field_idx;
int in_ctrl = 0;
int nbands = KRAD_EQ_MAX_BANDS;
int showed_bands = 1;
int idx;
char num[3];
int ch;
int res;
int bandn;
clear ();
char *fieldname[3] = {"Power","Frequency","Bandwidth"};
int nctrls = 3;
eq_win = newwin (0,0,0,0);
field = calloc (nbands+1,sizeof (FIELD*));
ctrl_field = calloc (nctrls+1,sizeof (FIELD*));
max_co = getmaxx (eq_win);
gap = floor ((max_co) / nbands);
vals = NULL;
bandn = 0;
ch = 0;
for (i=0;i<nbands;i++) {
field[i] = new_field (1,2,1, offs, 0, 0);
set_field_just (field[i], JUSTIFY_CENTER);
itoa (i,num,digits (i) + 1 );
set_field_buffer (field[i], 0, num);
field_opts_off (field[i], O_AUTOSKIP | O_EDIT);
offs += gap;
}
field[nbands] = NULL;
offs = 0;
gap = floor ((max_co ) / nctrls);
for (i=0;i<nctrls;i++) {
ctrl_field[i] = new_field (1,strlen (fieldname[i]),1, offs, 0, 0);
set_field_just (ctrl_field[i], JUSTIFY_CENTER);
set_field_buffer (ctrl_field[i], 0, fieldname[i]);
field_opts_off (ctrl_field[i], O_AUTOSKIP | O_EDIT);
offs += gap;
}
/* Controls generation */
ctrls = eq_ctrls_gen (eq_win,showed_bands);
vals = calloc (1,sizeof (eq_saved_val_t));
eqport = calloc (1,sizeof (eq_port_t));
db = ctrls->db;
hz = ctrls->hz;
bw = ctrls->bw;
eqport->name = sysname;
eqport->vals = vals;
eqport->ctrls = ctrls;
/* Eq form init */
eq_form = new_form (field);
wattron (eq_win,COLOR_PAIR (2) | A_BOLD);
mvwprintw (eq_win,getmaxy (eq_win) * 0.05,floor ((max_co/2)-((strlen (sysname)+14)/2)),"Equalizer for %s",sysname);
wattroff (eq_win,COLOR_PAIR (2) | A_BOLD);
set_form_win (eq_form, eq_win);
scale_form (eq_form, &suby, &subx);
set_form_sub (eq_form, derwin (eq_win,suby, subx , getmaxy (eq_win) * 0.10 , (max_co - subx) / 2 ));
eq_mainpan = new_panel (eq_win);
eq_subpan = new_panel (form_sub (eq_form));
top_panel (eq_mainpan);
top_panel (eq_subpan);
post_form (eq_form);
keypad (eq_win, TRUE);
set_current_field (eq_form,field[0]);
set_field_fore (current_field (eq_form),A_BOLD | COLOR_PAIR (3));
/* Eq ctrls form init */
ctrl_form = new_form (ctrl_field);
set_form_win (ctrl_form, eq_win);
scale_form (ctrl_form, &suby, &subx);
set_form_sub (ctrl_form, derwin (eq_win,suby, subx , getmaxy (eq_win) * 0.90 , (max_co - subx) / 2 ));
ctrl_subp = new_panel (form_sub (ctrl_form));
top_panel (ctrl_subp);
post_form (ctrl_form);
field_idx = field_index (current_field (eq_form));
/* Let's show controls! */
kr_mixer_portgroups (client);
show_all_panels (ctrls,showed_bands);
update_panels ();
doupdate ();
while (ch != 'q') {
res = krm_poll (client,-1);
switch (res) {
case 0:
continue;
case 1:
ch = getch ();
break;
case 2:
eqport->band = bandn;
kr_delivery_recv (client);
eq_delivery_handler (client,eqport);
continue;
case -1:
continue;
}
switch (ch) {
case KEY_LEFT:
if (in_ctrl) {
set_field_fore (current_field (ctrl_form),A_NORMAL);
form_driver (ctrl_form, REQ_PREV_FIELD);
set_field_fore (current_field (ctrl_form),A_BOLD | COLOR_PAIR (1));
idx = field_index (current_field (ctrl_form));
}
else {
set_field_fore (current_field (eq_form),A_NORMAL);
form_driver (eq_form, REQ_PREV_FIELD);
set_field_fore (current_field (eq_form),A_BOLD | COLOR_PAIR (3));
bandn = field_index (current_field (eq_form));
kr_mixer_portgroups (client);
}
break;
case KEY_RIGHT:
if (in_ctrl) {
set_field_fore (current_field (ctrl_form),A_NORMAL);
form_driver (ctrl_form, REQ_NEXT_FIELD);
set_field_fore (current_field (ctrl_form),A_BOLD | COLOR_PAIR (1));
idx = field_index (current_field (ctrl_form));
}
else {
set_field_fore (current_field (eq_form),A_NORMAL);
form_driver (eq_form, REQ_NEXT_FIELD);
set_field_fore (current_field (eq_form),A_BOLD | COLOR_PAIR (3));
bandn = field_index (current_field (eq_form));
kr_mixer_portgroups (client);
}
break;
case KEY_UP:
if (in_ctrl) {
switch (idx) {
case 0:
vals->db += 0.50;
kr_mixer_set_effect_control (client, sysname, 0, bandn, "db", vals->db, 0, 0);
break;
case 1:
vals->hz += 5;
kr_mixer_set_effect_control (client, sysname, 0, bandn, "hz", vals->hz, 0, 0);
break;
case 2:
vals->bw += 0.10;
kr_mixer_set_effect_control (client, sysname, 0, bandn, "bw", vals->bw, 0, 0);
break;
}
}
break;
case KEY_DOWN:
if (in_ctrl) {
switch (idx) {
case 0:
vals->db -= 0.5;
kr_mixer_set_effect_control (client, sysname, 0, bandn, "db", vals->db, 0, 0);
break;
case 1:
vals->hz -= 5;
kr_mixer_set_effect_control (client, sysname, 0, bandn, "hz", vals->hz, 0, 0);
break;
case 2:
vals->bw -= 0.10;
kr_mixer_set_effect_control (client, sysname, 0, bandn, "bw", vals->bw, 0, 0);
break;
}
}
break;
case 'w':
if (in_ctrl) {
switch (idx) {
case 0:
vals->db += 0.10;
kr_mixer_set_effect_control (client, sysname, 0, bandn, "db", vals->db, 0, 0);
break;
case 1:
vals->hz += 1;
kr_mixer_set_effect_control (client, sysname, 0, bandn, "hz", vals->hz, 0, 0);
break;
case 2:
break;
}
}
break;
case 's':
if (in_ctrl) {
switch (idx) {
case 0:
vals->db -= 0.10;
kr_mixer_set_effect_control (client, sysname, 0, bandn, "db", vals->db, 0, 0);
break;
case 1:
vals->hz -= 1;
kr_mixer_set_effect_control (client, sysname, 0, bandn, "hz", vals->hz, 0, 0);
break;
case 2:
break;
}
}
break;
case 9:
if (in_ctrl) {
idx = field_index (current_field (ctrl_form));
set_field_fore (ctrl_field[idx],A_NORMAL);
/* ncurses bug I suppose */
form_driver (ctrl_form, REQ_NEXT_FIELD);
form_driver (ctrl_form, REQ_PREV_FIELD);
set_current_field (eq_form,field[field_idx]);
in_ctrl = 0;
}
else {
field_idx = field_index (current_field (eq_form));
set_current_field (ctrl_form,ctrl_field[0]);
set_field_fore (ctrl_field[0],A_BOLD | COLOR_PAIR (1));
/* ncurses bug I suppose */
form_driver (ctrl_form, REQ_NEXT_FIELD);
form_driver (ctrl_form, REQ_PREV_FIELD);
idx = 0;
in_ctrl = 1;
}
break;
default:
break;
}
update_panels ();
doupdate ();
}
/* CLEANUP */
for (i=0;i<showed_bands;i++) {
tmpw = panel_window (db->slider_p[i]);
del_panel (db->slider_p[i]);
delwin (tmpw);
tmpw = panel_window (db->bar_p[i]);
del_panel (db->bar_p[i]);
delwin (tmpw);
tmpw = panel_window (hz->cell_p[i]);
del_panel (hz->cell_p[i]);
delwin (tmpw);
tmpw = panel_window (bw->bar_p[i]);
del_panel (bw->bar_p[i]);
delwin (tmpw);
tmpw = panel_window (bw->slider_p[i]);
del_panel (bw->slider_p[i]);
delwin (tmpw);
tmpw = panel_window (bw->cell_p[i]);
del_panel (bw->cell_p[i]);
delwin (tmpw);
}
free (db->bar_w);
free (db->slider_w);
free (hz->cell_w);
free (bw->bar_w);
free (bw->slider_w);
free (bw->cell_w);
free (db->bar_p);
free (db->slider_p);
free (hz->cell_p);
free (bw->bar_p);
free (bw->slider_p);
free (bw->cell_p);
tmpw = panel_window (db->pan);
del_panel (db->pan);
delwin (tmpw);
tmpw = panel_window (hz->pan);
del_panel (hz->pan);
delwin (tmpw);
tmpw = panel_window (bw->pan);
del_panel (bw->pan);
delwin (tmpw);
free (ctrls);
free (db);
free (hz);
free (bw);
free (vals);
free (eqport);
tmpw = form_sub (ctrl_form);
unpost_form (ctrl_form);
free_form (ctrl_form);
for (i=0;i<nctrls;i++) {
free_field (ctrl_field[i]);
}
free (ctrl_field);
del_panel (ctrl_subp);
delwin (tmpw);
tmpw = form_sub (eq_form);
unpost_form (eq_form);
free_form (eq_form);
for (i=0;i<nbands;i++) {
free_field (field[i]);
}
free (field);
del_panel (eq_subpan);
del_panel (eq_mainpan);
delwin (tmpw);
delwin (eq_win);
return 0;
}
