void parser (void)
{
char command_line [80];
int quit=0;
noecho();
cbreak();
wtimeout(command_win, 100);
keypad(command_win, 1);
while (!quit) {
/* Terminal screen size has changed */
if (redraw_request) {
redraw_all();
redraw_request=0;
}
wmove (command_win,0,0);wclrtoeol (command_win);
wmove(command_win, 0, 0);
wprintw(command_win, "ext2ed > ");
read_line(command_line);
/* If only enter was pressed, recall the last command */
if (*command_line==0)
strcpy (command_line,last_command_line);
mvcur (-1,-1,LINES-COMMAND_WIN_LINES + 1,0);
strcpy (last_command_line,command_line); /* Save this command in our tiny cache */
/* And call dispatch to do the actual job */
quit=dispatch (command_line);
}
}
void set_flg_play_replay( bool_t flg )
{
g_flg_play_replay = flg;
if( flg ){
g_replay_cur[REPLAY_SLOT_PLAY]
= g_replay_head[REPLAY_SLOT_PLAY];
g_replay_cur_draw
= g_replay_head[REPLAY_SLOT_PLAY];
if( g_replay_head[REPLAY_SLOT_PLAY] != NULL )
g_replay_head[REPLAY_SLOT_PLAY]->n = 0;
g_play_replay_turn = -1;
g_play_replay_count = 0;
g_play_replay_idx = 0;
g_play_replay_idx_draw = 0;
if( g_flg_gui )
call_gui_replay_bgn();
} else {
g_play_replay_turn = -1;
g_play_replay_count = 0;
redraw_all();
if( g_flg_gui )
call_gui_replay_end();
}
}
static void key(void)
{
uint8_t c;
moveto(0,0);
switch (c = getkey()) {
case 'Q':
if (notifier("quit"))
exit(0);
break;
case 'R' & 31:
redraw_all();
break;
case 'R':
if (notifier("restart"))
start_level();
break;
case 'U':
undo();
break;
case 'H':
case 'J':
case 'K':
case 'L':
move(c - 'H');
break;
}
/* TODO arrow key handling */
}
static void start_level(void)
{
moves = 0;
undop = 0;
memcpy(&map, &base_map.map, sizeof(map));
redraw_all();
}
/*
* Designed to handles signals (e.g., SIGWINCH).
*/
void
handle_signal(int signum) {
// handle a change in the window (i.e., a resizing)
if (signum == SIGWINCH)
redraw_all();
// re-register myself so this signal gets handled in future too
signal(signum, (void (*)(int)) handle_signal);
}
static void
idle_handler(void)
{
ENTER("idle_handler(void)");
pgSetIdle(IDLE_TIME, NULL);
redraw_all();
pgSetIdle(IDLE_TIME, &idle_handler);
LEAVE;
}
/*
* Read a character from the command window
*/
int command_read_key()
{
int key = 0;
while (!key) {
if (redraw_request) {
redraw_all();
redraw_request=0;
}
key = wgetch(command_win);
switch (key) {
case 0x1A:
key = 0;
kill(getpid(), SIGTSTP);
break;
case KEY_NPAGE:
pgdn("");
refresh_command_win ();
break;
case KEY_PPAGE:
pgup("");
refresh_command_win ();
break;
case ERR:
key = 0;
break;
case KEY_BACKSPACE:
key = '\b';
}
if ((key < 32 && key != '\b' && key != '\n') ||
(key > 127))
key = 0;
}
return key;
}
void redraw (char *command_line)
{
redraw_all ();
dispatch ("show");
}
int
main(int argc, char *argv[])
{
// define usage
const char *usage = "Usage: sudoku n00b|l33t [#]\n";
// ensure that number of arguments is as expected
if (argc != 2 && argc != 3)
{
fprintf(stderr, usage);
return 1;
}
// ensure that level is valid
if (strcmp(argv[1], "debug") == 0)
g.level = "debug";
else if (strcmp(argv[1], "n00b") == 0)
g.level = "n00b";
else if (strcmp(argv[1], "l33t") == 0)
g.level = "l33t";
else
{
fprintf(stderr, usage);
return 2;
}
// n00b and l33t levels have 1024 boards; debug level has 9
int max = (strcmp(g.level, "debug") == 0) ? 9 : 1024;
// ensure that #, if provided, is in [1, max]
if (argc == 3)
{
// ensure n is integral
char c;
if (sscanf(argv[2], " %d %c", &g.number, &c) != 1)
{
fprintf(stderr, usage);
return 3;
}
// ensure n is in [1, max]
if (g.number < 1 || g.number > max)
{
fprintf(stderr, "That board # does not exist!\n");
return 4;
}
// seed PRNG with # so that we get same sequence of boards
srand(g.number);
}
else
{
// seed PRNG with current time so that we get any sequence of boards
srand(time(NULL));
// choose a random n in [1, max]
g.number = rand() % max + 1;
}
// start up ncurses
if (!startup())
{
fprintf(stderr, "Error starting up ncurses!\n");
return 5;
}
// register handler for SIGWINCH (SIGnal WINdow CHanged)
signal(SIGWINCH, (void (*)(int)) handle_signal);
// start the first game
if (!restart_game())
{
shutdown();
fprintf(stderr, "Could not load board from disk!\n");
return 6;
}
redraw_all();
// initialize legal variable
g.legal = true;
// initialize won variable
g.won = false;
// let the user play!
int ch;
do
{
// refresh the screen
refresh();
// get user's input
ch = getch();
// capitalize input to simplify cases
ch = toupper(ch);
// process user's input
switch (ch)
{
// start a new game
case 'N':
g.number = rand() % max + 1;
if (!restart_game())
{
shutdown();
fprintf(stderr, "Could not load board from disk!\n");
return 6;
}
break;
// restart current game
case 'R':
if (!restart_game())
{
shutdown();
fprintf(stderr, "Could not load board from disk!\n");
return 6;
}
break;
// let user manually redraw screen with ctrl-L
case CTRL('l'):
redraw_all();
break;
// move cursor on the board
case KEY_DOWN:
case KEY_UP:
case KEY_LEFT:
case KEY_RIGHT:
move_cursor(ch);
break;
case KEY_BACKSPACE:
case KEY_DC:
case 46: // .
case 48: // 0
case 49: // 1
case 50: // 2
case 51: // 3
case 52: // 4
case 53: // 5
case 54: // 6
case 55: // 7
case 56: // 8
case 57: // 9
change_number(ch);
if(!legal(ch))
{
show_banner("Illegal Move...");
show_cursor();
g.legal = false;
}
else
{
hide_banner();
show_cursor();
g.legal = true;
}
if(won(ch))
{
show_banner("You Won The Game!!!");
g.won = true;
}
break;
}
// log input (and board's state) if any was received this iteration
if (ch != ERR)
log_move(ch);
}
while (ch != 'Q');
// shut down ncurses
shutdown();
// tidy up the screen (using ANSI escape sequences)
printf("\033[2J");
printf("\033[%d;%dH", 0, 0);
// that's all folks
printf("\nkthxbai!\n\n");
return 0;
}
/*######################### check_dir_status() ##########################*/
void
check_dir_status(Widget w)
{
signed char flush;
int i,
x,
y,
pos,
prev_no_of_dirs = no_of_dirs,
location_where_changed,
new_bar_length,
old_bar_length,
redo_warn_time_bar,
redraw_everything = NO;
u_off_t bytes_received;
unsigned int files_received,
prev_dir_flag;
time_t delta_time,
end_time;
/* Initialise variables. */
location_where_changed = no_of_dirs + 10;
flush = NO;
now = time(NULL);
/*
* See if a directory has been added or removed from the FRA.
* If it changed resize the window.
*/
if (check_fra(NO) == YES)
{
unsigned int new_bar_length;
size_t new_size = no_of_dirs * sizeof(struct dir_line);
struct dir_line *new_connect_data,
*tmp_connect_data;
if ((new_connect_data = calloc(no_of_dirs,
sizeof(struct dir_line))) == NULL)
{
(void)xrec(FATAL_DIALOG, "calloc() error : %s (%s %d)",
strerror(errno), __FILE__, __LINE__);
return;
}
/*
* First try to copy the connect data from the old structure
* so long as the directories are the same.
*/
for (i = 0, location_where_changed = 0;
i < prev_no_of_dirs; i++, location_where_changed++)
{
if (strcmp(connect_data[i].dir_alias, fra[i].dir_alias) == 0)
{
(void)memcpy(&new_connect_data[i], &connect_data[i],
sizeof(struct dir_line));
}
else
{
break;
}
}
for (i = location_where_changed; i < no_of_dirs; i++)
{
if ((pos = check_disp_data(fra[i].dir_alias,
prev_no_of_dirs)) != INCORRECT)
{
(void)memcpy(&new_connect_data[i], &connect_data[pos],
sizeof(struct dir_line));
}
else /* A directory host has been added. */
{
/* Initialise values for new host. */
(void)strcpy(new_connect_data[i].dir_alias, fra[i].dir_alias);
(void)sprintf(new_connect_data[i].dir_display_str, "%-*s",
MAX_DIR_ALIAS_LENGTH, new_connect_data[i].dir_alias);
new_connect_data[i].dir_status = fra[i].dir_status;
new_connect_data[i].bytes_received = fra[i].bytes_received;
new_connect_data[i].files_received = fra[i].files_received;
new_connect_data[i].dir_flag = fra[i].dir_flag;
new_connect_data[i].files_in_dir = fra[i].files_in_dir;
new_connect_data[i].files_queued = fra[i].files_queued;
new_connect_data[i].bytes_in_dir = fra[i].bytes_in_dir;
new_connect_data[i].bytes_in_queue = fra[i].bytes_in_queue;
new_connect_data[i].max_process = fra[i].max_process;
new_connect_data[i].no_of_process = fra[i].no_of_process;
new_connect_data[i].max_errors = fra[i].max_errors;
new_connect_data[i].error_counter = fra[i].error_counter;
CREATE_FC_STRING(new_connect_data[i].str_files_in_dir,
new_connect_data[i].files_in_dir);
CREATE_FS_STRING(new_connect_data[i].str_bytes_in_dir,
new_connect_data[i].bytes_in_dir);
CREATE_FC_STRING(new_connect_data[i].str_files_queued,
new_connect_data[i].files_queued);
CREATE_FS_STRING(new_connect_data[i].str_bytes_queued,
new_connect_data[i].bytes_in_queue);
CREATE_EC_STRING(new_connect_data[i].str_np,
new_connect_data[i].no_of_process);
CREATE_EC_STRING(new_connect_data[i].str_ec,
new_connect_data[i].error_counter);
new_connect_data[i].last_retrieval = fra[i].last_retrieval;
new_connect_data[i].start_event_handle = fra[i].start_event_handle;
new_connect_data[i].end_event_handle = fra[i].end_event_handle;
if (*(unsigned char *)((char *)fra - AFD_FEATURE_FLAG_OFFSET_END) & DISABLE_DIR_WARN_TIME)
{
new_connect_data[i].warn_time = 0;
}
else
{
new_connect_data[i].warn_time = fra[i].warn_time;
}
new_connect_data[i].bytes_per_sec = 0;
new_connect_data[i].prev_bytes_per_sec = 0;
new_connect_data[i].str_tr[0] = new_connect_data[i].str_tr[1] = ' ';
new_connect_data[i].str_tr[2] = '0';
new_connect_data[i].str_tr[3] = 'B';
new_connect_data[i].str_tr[4] = '\0';
new_connect_data[i].average_tr = 0.0;
new_connect_data[i].max_average_tr = 0.0;
new_connect_data[i].files_per_sec = 0;
new_connect_data[i].prev_files_per_sec = 0;
new_connect_data[i].str_fr[0] = ' ';
new_connect_data[i].str_fr[1] = '0';
new_connect_data[i].str_fr[2] = '.';
new_connect_data[i].str_fr[3] = '0';
new_connect_data[i].str_fr[4] = '\0';
new_connect_data[i].average_fr = 0.0;
new_connect_data[i].max_average_fr = 0.0;
new_connect_data[i].bar_length[BYTE_RATE_BAR_NO] = 0;
if (new_connect_data[i].warn_time < 1)
{
new_connect_data[i].scale = 0.0;
new_connect_data[i].bar_length[TIME_UP_BAR_NO] = 0;
}
else
{
new_connect_data[i].scale = max_bar_length / new_connect_data[i].warn_time;
new_bar_length = (now - new_connect_data[i].last_retrieval) * new_connect_data[i].scale;
if (new_bar_length > 0)
{
if (new_bar_length >= max_bar_length)
{
new_connect_data[i].bar_length[TIME_UP_BAR_NO] = max_bar_length;
}
else
{
new_connect_data[i].bar_length[TIME_UP_BAR_NO] = new_bar_length;
}
}
else
{
new_connect_data[i].bar_length[TIME_UP_BAR_NO] = 0;
}
}
new_connect_data[i].bar_length[FILE_RATE_BAR_NO] = 0;
new_connect_data[i].start_time = times(&tmsdummy);
new_connect_data[i].inverse = OFF;
new_connect_data[i].expose_flag = NO;
/*
* If this line has been selected in the old
* connect_data structure, we have to make sure
* that this host has not been deleted. If it
* is deleted reduce the select counter!
*/
if ((i < prev_no_of_dirs) && (connect_data[i].inverse == ON))
{
if ((pos = check_fra_data(connect_data[i].dir_alias)) == INCORRECT)
{
/* Host has been deleted. */
no_selected--;
}
}
}
} /* for (i = location_where_changed; i < no_of_dirs; i++) */
/*
* Ensure that we really have checked all directories in old
* structure.
*/
if (prev_no_of_dirs > no_of_dirs)
{
while (i < prev_no_of_dirs)
{
if (connect_data[i].inverse == ON)
{
if ((pos = check_fra_data(connect_data[i].dir_alias)) == INCORRECT)
{
/* Host has been deleted. */
no_selected--;
}
}
i++;
}
}
if ((tmp_connect_data = realloc(connect_data, new_size)) == NULL)
{
int tmp_errno = errno;
free(connect_data);
(void)xrec(FATAL_DIALOG, "realloc() error : %s (%s %d)",
strerror(tmp_errno), __FILE__, __LINE__);
return;
}
connect_data = tmp_connect_data;
/* Activate the new connect_data structure. */
(void)memcpy(&connect_data[0], &new_connect_data[0],
no_of_dirs * sizeof(struct dir_line));
free(new_connect_data);
/* Resize window if necessary. */
if ((redraw_everything = resize_dir_window()) == YES)
{
if (no_of_columns != 0)
{
location_where_changed = 0;
}
}
/* When no. of directories have been reduced, then delete */
/* removed directories from end of list. */
for (i = prev_no_of_dirs; i > no_of_dirs; i--)
{
draw_dir_blank_line(i - 1);
}
/* Make sure changes are drawn!!! */
flush = YES;
} /* if (check_fra(NO) == YES) */
/* Change information for each directory if necessary. */
for (i = 0; i < no_of_dirs; i++)
{
x = y = -1;
redo_warn_time_bar = NO;
if (connect_data[i].dir_status != fra[i].dir_status)
{
connect_data[i].dir_status = fra[i].dir_status;
locate_xy(i, &x, &y);
draw_dir_identifier(i, x, y);
flush = YES;
}
if (connect_data[i].max_process != fra[i].max_process)
{
connect_data[i].max_process = fra[i].max_process;
}
if (connect_data[i].dir_flag != fra[i].dir_flag)
{
prev_dir_flag = connect_data[i].dir_flag;
connect_data[i].dir_flag = fra[i].dir_flag;
if (x == -1)
{
locate_xy(i, &x, &y);
}
if (((prev_dir_flag & MAX_COPIED) == 0) &&
(connect_data[i].dir_flag & MAX_COPIED))
{
draw_dir_full_marker(i, x, y, YES);
}
else if ((prev_dir_flag & MAX_COPIED) &&
((connect_data[i].dir_flag & MAX_COPIED) == 0))
{
draw_dir_full_marker(i, x, y, NO);
}
flush = YES;
}
if (connect_data[i].max_errors != fra[i].max_errors)
{
connect_data[i].max_errors = fra[i].max_errors;
}
if (*(unsigned char *)((char *)fra - AFD_FEATURE_FLAG_OFFSET_END) & DISABLE_DIR_WARN_TIME)
{
if (connect_data[i].warn_time != 0)
{
connect_data[i].scale = 0.0;
connect_data[i].warn_time = 0;
redo_warn_time_bar = YES;
}
}
else
{
if (connect_data[i].warn_time != fra[i].warn_time)
{
connect_data[i].warn_time = fra[i].warn_time;
if (connect_data[i].warn_time < 1)
{
connect_data[i].scale = 0.0;
}
else
{
connect_data[i].scale = max_bar_length / connect_data[i].warn_time;
}
redo_warn_time_bar = YES;
}
}
end_time = times(&tmsdummy);
if ((delta_time = (end_time - connect_data[i].start_time)) == 0)
{
delta_time = 1;
}
connect_data[i].start_time = end_time;
/*
* Byte Rate Bar
*/
bytes_received = 0;
if (connect_data[i].bytes_received != fra[i].bytes_received)
{
if (fra[i].bytes_received < connect_data[i].bytes_received)
{
bytes_received = fra[i].bytes_received;
}
else
{
bytes_received = fra[i].bytes_received -
connect_data[i].bytes_received;
}
connect_data[i].bytes_received = fra[i].bytes_received;
}
if (bytes_received > 0)
{
connect_data[i].bytes_per_sec = (float)(bytes_received) /
delta_time * clktck;
if (line_style != CHARACTERS_ONLY)
{
/* Arithmetischer Mittelwert. */
connect_data[i].average_tr = (connect_data[i].average_tr +
connect_data[i].bytes_per_sec) / 2.0;
if (connect_data[i].average_tr > connect_data[i].max_average_tr)
{
connect_data[i].max_average_tr = connect_data[i].average_tr;
}
}
}
else
{
connect_data[i].bytes_per_sec = 0;
if ((line_style != CHARACTERS_ONLY) &&
(connect_data[i].average_tr > 0.0))
{
/* Arithmetischer Mittelwert. */
connect_data[i].average_tr = (connect_data[i].average_tr +
connect_data[i].bytes_per_sec) / 2.0;
if (connect_data[i].average_tr > connect_data[i].max_average_tr)
{
connect_data[i].max_average_tr = connect_data[i].average_tr;
}
}
}
files_received = 0;
if (connect_data[i].files_received != fra[i].files_received)
{
if (fra[i].files_received < connect_data[i].files_received)
{
files_received = fra[i].files_received;
}
else
{
files_received = fra[i].files_received -
connect_data[i].files_received;
}
connect_data[i].files_received = fra[i].files_received;
}
if (files_received > 0)
{
connect_data[i].files_per_sec = (float)(files_received) /
delta_time * clktck;
if (line_style != CHARACTERS_ONLY)
{
/* Arithmetischer Mittelwert. */
connect_data[i].average_fr = (connect_data[i].average_fr +
connect_data[i].files_per_sec) / 2.0;
if (connect_data[i].average_fr > connect_data[i].max_average_fr)
{
connect_data[i].max_average_fr = connect_data[i].average_fr;
}
}
}
else
{
connect_data[i].files_per_sec = 0;
if ((line_style != CHARACTERS_ONLY) &&
(connect_data[i].average_fr > 0.0))
{
/* Arithmetischer Mittelwert. */
connect_data[i].average_fr = (connect_data[i].average_fr +
connect_data[i].files_per_sec) / 2.0;
if (connect_data[i].average_fr > connect_data[i].max_average_fr)
{
connect_data[i].max_average_fr = connect_data[i].average_fr;
}
}
}
/*
* CHARACTER INFORMATION
* =====================
*
* If in character mode see if any change took place,
* if so, redraw only those characters.
*/
if (line_style != BARS_ONLY)
{
/*
* Number of files in directory.
*/
if (connect_data[i].files_in_dir != fra[i].files_in_dir)
{
connect_data[i].files_in_dir = fra[i].files_in_dir;
if (x == -1)
{
locate_xy(i, &x, &y);
}
CREATE_FC_STRING(connect_data[i].str_files_in_dir,
connect_data[i].files_in_dir);
if (i < location_where_changed)
{
draw_dir_chars(i, FILES_IN_DIR, x, y);
flush = YES;
}
}
/*
* Number of bytes in directory.
*/
if (connect_data[i].bytes_in_dir != fra[i].bytes_in_dir)
{
connect_data[i].bytes_in_dir = fra[i].bytes_in_dir;
if (x == -1)
{
locate_xy(i, &x, &y);
}
CREATE_FS_STRING(connect_data[i].str_bytes_in_dir,
connect_data[i].bytes_in_dir);
if (i < location_where_changed)
{
draw_dir_chars(i, BYTES_IN_DIR, x, y);
flush = YES;
}
}
/*
* Number of files queued.
*/
if (connect_data[i].files_queued != fra[i].files_queued)
{
connect_data[i].files_queued = fra[i].files_queued;
if (x == -1)
{
locate_xy(i, &x, &y);
}
CREATE_FC_STRING(connect_data[i].str_files_queued,
connect_data[i].files_queued);
if (i < location_where_changed)
{
draw_dir_chars(i, FILES_QUEUED, x, y);
flush = YES;
}
}
/*
* Number of bytes queued.
*/
if (connect_data[i].bytes_in_queue != fra[i].bytes_in_queue)
{
connect_data[i].bytes_in_queue = fra[i].bytes_in_queue;
if (x == -1)
{
locate_xy(i, &x, &y);
}
CREATE_FS_STRING(connect_data[i].str_bytes_queued,
connect_data[i].bytes_in_queue);
if (i < location_where_changed)
{
draw_dir_chars(i, BYTES_QUEUED, x, y);
flush = YES;
}
}
/*
* Number of process for this directory.
*/
if (connect_data[i].no_of_process != fra[i].no_of_process)
{
connect_data[i].no_of_process = fra[i].no_of_process;
if (x == -1)
{
locate_xy(i, &x, &y);
}
CREATE_EC_STRING(connect_data[i].str_np,
connect_data[i].no_of_process);
if (i < location_where_changed)
{
draw_dir_chars(i, NO_OF_DIR_PROCESS, x, y);
flush = YES;
}
}
/*
* Byte rate.
*/
if (connect_data[i].bytes_per_sec != connect_data[i].prev_bytes_per_sec)
{
connect_data[i].prev_bytes_per_sec = connect_data[i].bytes_per_sec;
if (x == -1)
{
locate_xy(i, &x, &y);
}
CREATE_FS_STRING(connect_data[i].str_tr,
connect_data[i].bytes_per_sec);
if (i < location_where_changed)
{
draw_dir_chars(i, BYTE_RATE, x, y);
flush = YES;
}
}
/*
* File rate.
*/
if (connect_data[i].files_per_sec != connect_data[i].prev_files_per_sec)
{
connect_data[i].prev_files_per_sec = connect_data[i].files_per_sec;
if (x == -1)
{
locate_xy(i, &x, &y);
}
CREATE_FR_STRING(connect_data[i].str_fr,
connect_data[i].files_per_sec);
if (i < location_where_changed)
{
draw_dir_chars(i, FILE_RATE, x, y);
flush = YES;
}
}
/*
* Error Counter.
*/
if (connect_data[i].error_counter != fra[i].error_counter)
{
connect_data[i].error_counter = fra[i].error_counter;
if (x == -1)
{
locate_xy(i, &x, &y);
}
CREATE_EC_STRING(connect_data[i].str_ec,
connect_data[i].error_counter);
if (i < location_where_changed)
{
draw_dir_chars(i, DIR_ERRORS, x, y);
flush = YES;
}
}
} /* if (line_style != BARS_ONLY) */
/*
* BAR INFORMATION
* ===============
*/
if (line_style != CHARACTERS_ONLY)
{
if (connect_data[i].last_retrieval != fra[i].last_retrieval)
{
connect_data[i].last_retrieval = fra[i].last_retrieval;
}
if (connect_data[i].average_tr > 1.0)
{
if (connect_data[i].max_average_tr < 2.0)
{
new_bar_length = (log10(connect_data[i].average_tr) *
max_bar_length /
log10((double) 2.0));
}
else
{
new_bar_length = (log10(connect_data[i].average_tr) *
max_bar_length /
log10(connect_data[i].max_average_tr));
}
}
else
{
new_bar_length = 0;
}
if ((connect_data[i].bar_length[BYTE_RATE_BAR_NO] != new_bar_length) &&
(new_bar_length < max_bar_length))
{
old_bar_length = connect_data[i].bar_length[BYTE_RATE_BAR_NO];
connect_data[i].bar_length[BYTE_RATE_BAR_NO] = new_bar_length;
if (i < location_where_changed)
{
if (x == -1)
{
locate_xy(i, &x, &y);
}
if (old_bar_length < new_bar_length)
{
draw_dir_bar(i, 1, BYTE_RATE_BAR_NO, x, y);
}
else
{
draw_dir_bar(i, -1, BYTE_RATE_BAR_NO, x, y);
}
if (flush != YES)
{
flush = YUP;
}
}
}
else if ((new_bar_length >= max_bar_length) &&
(connect_data[i].bar_length[BYTE_RATE_BAR_NO] < max_bar_length))
{
connect_data[i].bar_length[BYTE_RATE_BAR_NO] = max_bar_length;
if (i < location_where_changed)
{
if (x == -1)
{
locate_xy(i, &x, &y);
}
draw_dir_bar(i, 1, BYTE_RATE_BAR_NO, x, y);
if (flush != YES)
{
flush = YUP;
}
}
}
if (((connect_data[i].warn_time > 0) &&
(connect_data[i].scale > 0.0)) ||
(redo_warn_time_bar == YES))
{
new_bar_length = (now - connect_data[i].last_retrieval) * connect_data[i].scale;
if (new_bar_length > 0)
{
if (new_bar_length >= max_bar_length)
{
new_bar_length = max_bar_length;
}
}
else
{
new_bar_length = 0;
}
if (new_bar_length != connect_data[i].bar_length[TIME_UP_BAR_NO])
{
old_bar_length = connect_data[i].bar_length[TIME_UP_BAR_NO];
connect_data[i].bar_length[TIME_UP_BAR_NO] = new_bar_length;
if (i < location_where_changed)
{
if (x == -1)
{
locate_xy(i, &x, &y);
}
if (old_bar_length < new_bar_length)
{
draw_dir_bar(i, 1, TIME_UP_BAR_NO, x, y + bar_thickness_3);
}
else
{
draw_dir_bar(i, -1, TIME_UP_BAR_NO, x, y + bar_thickness_3);
}
if (flush != YES)
{
flush = YUP;
}
}
}
}
/*
* File Rate Bar
*/
if (connect_data[i].average_fr > 1.0)
{
if (connect_data[i].max_average_fr < 2.0)
{
new_bar_length = (log10(connect_data[i].average_fr) *
max_bar_length /
log10((double) 2.0));
}
else
{
new_bar_length = (log10(connect_data[i].average_fr) *
max_bar_length /
log10(connect_data[i].max_average_fr));
}
}
else
{
new_bar_length = 0;
}
if ((connect_data[i].bar_length[FILE_RATE_BAR_NO] != new_bar_length) &&
(new_bar_length < max_bar_length))
{
old_bar_length = connect_data[i].bar_length[FILE_RATE_BAR_NO];
connect_data[i].bar_length[FILE_RATE_BAR_NO] = new_bar_length;
if (i < location_where_changed)
{
if (x == -1)
{
locate_xy(i, &x, &y);
}
if (old_bar_length < new_bar_length)
{
draw_dir_bar(i, 1, FILE_RATE_BAR_NO, x, y + bar_thickness_3 + bar_thickness_3);
}
else
{
draw_dir_bar(i, -1, FILE_RATE_BAR_NO, x, y + bar_thickness_3 + bar_thickness_3);
}
if (flush != YES)
{
flush = YUP;
}
}
}
else if ((new_bar_length >= max_bar_length) &&
(connect_data[i].bar_length[FILE_RATE_BAR_NO] < max_bar_length))
{
connect_data[i].bar_length[FILE_RATE_BAR_NO] = max_bar_length;
if (i < location_where_changed)
{
if (x == -1)
{
locate_xy(i, &x, &y);
}
draw_dir_bar(i, 1, FILE_RATE_BAR_NO, x, y + bar_thickness_3 + bar_thickness_3);
if (flush != YES)
{
flush = YUP;
}
}
}
}
/* Redraw the line. */
if (i >= location_where_changed)
{
#ifdef _DEBUG
(void)fprintf(stderr, "count_channels: i = %d\n", i);
#endif
flush = YES;
draw_dir_line_status(i, 1);
}
}
if (redraw_everything == YES)
{
redraw_all();
flush = YES;
}
/* Make sure all changes are shown. */
if ((flush == YES) || (flush == YUP))
{
XFlush(display);
if (flush != YUP)
{
redraw_time_line = MIN_DIR_REDRAW_TIME;
}
}
else
{
if (redraw_time_line < MAX_DIR_REDRAW_TIME)
{
redraw_time_line += DIR_REDRAW_STEP_TIME;
}
#ifdef _DEBUG
(void)fprintf(stderr, "count_channels: Redraw time = %d\n", redraw_time_line);
#endif
}
/* Redraw every redraw_time_line ms. */
(void)XtAppAddTimeOut(app, redraw_time_line,
(XtTimerCallbackProc)check_dir_status, w);
return;
}
/*
* This function asks the user for a command and calls the dispatcher
* function, dispatch, to analyze it. We use the readline library
* function readline to read the command, hence all the usual readline
* keys are available. The new command is saved both in the
* readline's history and in our tiny one-command cache, so that only
* the enter key is needed to retype it.
*/
void parser (void)
{
char *ptr,command_line [80];
int quit=0;
#if 0
noecho();
cbreak();
keypad(command_win, 1);
wtimeout(command_win, 100);
rl_getc_function = rl_getc_replacement;
#endif
while (!quit) {
/* Terminal screen size has changed */
if (redraw_request) {
redraw_all();
redraw_request=0;
}
wmove (command_win,0,0);
wclrtoeol (command_win);
wprintw (command_win,"ext2ed > ");
refresh_command_win ();
/*
* The ncurses library optimizes cursor movement by
* keeping track of the cursor position. However, by
* using the readline library I'm breaking its
* assumptions. The double -1 arguments tell ncurses
* to disable cursor movement optimization this
* time.
*/
mvcur (-1,-1,LINES-COMMAND_WIN_LINES,0);
/* echo (); */
ptr=readline ("ext2ed > ");
/* noecho (); */
/*
* Readline allocated the buffer - Copy the string
* and free the allocated buffer
* XXX WHY???
*/
strcpy (command_line,ptr);
free (ptr);
if (*command_line != 0)
add_history (command_line);
/* If only enter was pressed, recall the last command */
if (*command_line==0)
strcpy (command_line,last_command_line);
/* Emulate readline's actions for ncurses */
mvcur (-1,-1,LINES-COMMAND_WIN_LINES,0);
werase (command_win);
wprintw (command_win,"ext2ed > ");
wprintw (command_win,command_line);
wprintw (command_win,"\n");
refresh_command_win ();
/* Save this command in our tiny cache */
strcpy (last_command_line,command_line);
/* And call dispatch to do the actual job */
quit=dispatch (command_line);
}
}
/*
* Main driver for the game.
*/
int
main(int argc, char **argv) {
// define usage
const char *usage = "Usage: sudoku n00b|l33t [#]\n";
// ensure that number of arguments is as expected
if (argc != 2 && argc != 3) {
fprintf(stderr, usage);
return 1;
}
// ensure that level is valid
if (!strcmp(argv[1], "debug"))
g.level = "debug";
else if (!strcmp(argv[1], "n00b"))
g.level = "n00b";
else if (!strcmp(argv[1], "l33t"))
g.level = "l33t";
else {
fprintf(stderr, usage);
return 2;
}
// n00b and l33t levels have 1024 boards; debug level has 9
int max = (!strcmp(g.level, "debug")) ? 9 : 1024;
// ensure that #, if provided, is in [1, max]
if (argc == 3) {
// ensure n is integral
char c;
if (!sscanf(argv[2], " %d %c", &g.number, &c) == 1) {
fprintf(stderr, usage);
return 3;
}
// ensure n is in [1, max]
if (g.number < 1 || g.number > max) {
fprintf(stderr, "That board # does not exist!\n");
return 4;
}
// seed PRNG with # so that we get same sequence of boards
srand(g.number);
}
else {
// seed PRNG with current time so that we get any sequence of boards
srand(time(NULL));
// choose a random n in [1, max]
g.number = rand() % max + 1;
}
// start up ncurses
if (!startup()) {
fprintf(stderr, "Error starting up ncurses!\n");
return 6;
}
// register handler for SIGWINCH (SIGnal WINdow CHanged)
signal(SIGWINCH, (void (*)(int)) handle_signal);
// start the first game
if (!restart_game()) {
shutdown();
fprintf(stderr, "Could not load board from disk!\n");
return 7;
}
redraw_all();
// let the user play!
int ch;
do {
// refresh the screen
refresh();
// get user's input
ch = getch();
// capitalize input to simplify cases
ch = toupper(ch);
// process user's input
switch (ch) {
// left arrow key
case KEY_LEFT:
case 'H':
if (--g.x < 0)
g.x += DIM;
hide_banner();
show_cursor();
break;
// right arrow key
case KEY_RIGHT:
case 'L':
if (++g.x >= DIM)
g.x -= DIM;
hide_banner();
show_cursor();
break;
// up arrow key
case KEY_UP:
case 'K':
if (--g.y < 0)
g.y += DIM;
hide_banner();
show_cursor();
break;
// down arrow key
case KEY_DOWN:
case 'J':
if (++g.y >= DIM)
g.y -= DIM;
hide_banner();
show_cursor();
break;
// enable user to enter numbers
case '1': case '2':
case '3': case '4':
case '5': case '6':
case '7': case '8':
case '9':
if (g.given[g.y][g.x] == false && validate(ch) == true) {
enter_number(ch);
draw_numbers();
show_cursor();
won();
}
break;
// delete a number
case KEY_BACKSPACE:
case KEY_DC:
case '.':
case '0':
if (g.given[g.y][g.x] == false) {
g.board[g.y][g.x] = 0;
draw_numbers();
hide_banner();
show_cursor();
}
break;
// start a new game
case 'N':
g.number = rand() % max + 1;
if (!restart_game()) {
shutdown();
fprintf(stderr, "Could not load board from disk!\n");
return 7;
}
break;
// restart current game
case 'R':
if (!restart_game()) {
shutdown();
fprintf(stderr, "Could not load board from disk!\n");
return 7;
}
break;
// let user manually redraw screen with ctrl-L
case CTRL('l'):
redraw_all();
break;
} // end switch statement
// log input (and board's state) if any was received this iteration
if (ch != ERR)
log_move(ch);
} while (ch != 'Q');
// shut down ncurses
shutdown();
// tidy up the screen (using ANSI escape sequences)
printf("\033[2J");
printf("\033[%d;%dH", 0, 0);
// kthxbai
printf("\nkthxbai!\n\n");
return 0;
}
/*######################### check_afd_status() ##########################*/
void
check_afd_status(Widget w)
{
signed char flush;
int draw_identifier,
i,
x,
y,
pos,
prev_no_of_afds = no_of_afds,
location_where_changed,
new_bar_length,
old_bar_length,
redraw_everything = NO;
/* Initialise variables. */
location_where_changed = no_of_afds + 10;
flush = NO;
/*
* See if a host has been added or removed from the MSA.
* If it changed resize the window.
*/
if (check_msa() == YES)
{
size_t new_size = no_of_afds * sizeof(struct mon_line);
struct mon_line *new_connect_data,
*tmp_connect_data;
if ((new_connect_data = calloc(no_of_afds,
sizeof(struct mon_line))) == NULL)
{
(void)xrec(FATAL_DIALOG, "calloc() error : %s (%s %d)",
strerror(errno), __FILE__, __LINE__);
return;
}
/*
* First try to copy the connect data from the old structure
* so long as the hostnames are the same.
*/
for (i = 0, location_where_changed = 0;
i < prev_no_of_afds; i++, location_where_changed++)
{
if (strcmp(connect_data[i].afd_alias, msa[i].afd_alias) == 0)
{
(void)memcpy(&new_connect_data[i], &connect_data[i],
sizeof(struct mon_line));
}
else
{
break;
}
}
for (i = location_where_changed; i < no_of_afds; i++)
{
if ((pos = check_disp_data(msa[i].afd_alias,
prev_no_of_afds)) != INCORRECT)
{
(void)memcpy(&new_connect_data[i], &connect_data[pos],
sizeof(struct mon_line));
}
else /* A new host has been added. */
{
/* Initialise values for new host. */
(void)strcpy(new_connect_data[i].afd_alias, msa[i].afd_alias);
new_connect_data[i].afd_toggle = msa[i].afd_toggle;
new_connect_data[i].afd_alias_length = strlen(new_connect_data[i].afd_alias);
if ((msa[i].afd_switching != NO_SWITCHING) &&
(new_connect_data[i].afd_alias_length < MAX_AFDNAME_LENGTH))
{
int pos;
(void)memset(new_connect_data[i].afd_display_str, ' ',
MAX_AFDNAME_LENGTH);
pos = sprintf(new_connect_data[i].afd_display_str, "%s%d",
new_connect_data[i].afd_alias,
new_connect_data[i].afd_toggle + 1);
new_connect_data[i].afd_display_str[pos] = ' ';
new_connect_data[i].afd_display_str[MAX_AFDNAME_LENGTH] = '\0';
}
else
{
(void)sprintf(new_connect_data[i].afd_display_str, "%-*s",
MAX_AFDNAME_LENGTH, new_connect_data[i].afd_alias);
}
(void)memcpy(new_connect_data[i].sys_log_fifo,
msa[i].sys_log_fifo, LOG_FIFO_SIZE + 1);
if (his_log_set > 0)
{
(void)memcpy(new_connect_data[i].log_history, msa[i].log_history,
(NO_OF_LOG_HISTORY * MAX_LOG_HISTORY));
}
new_connect_data[i].sys_log_ec = msa[i].sys_log_ec;
new_connect_data[i].amg = msa[i].amg;
new_connect_data[i].fd = msa[i].fd;
new_connect_data[i].archive_watch = msa[i].archive_watch;
if ((new_connect_data[i].amg == OFF) ||
(new_connect_data[i].fd == OFF) ||
(new_connect_data[i].archive_watch == OFF))
{
new_connect_data[i].blink_flag = ON;
}
else
{
new_connect_data[i].blink_flag = OFF;
}
new_connect_data[i].blink = TR_BAR;
new_connect_data[i].jobs_in_queue = msa[i].jobs_in_queue;
new_connect_data[i].danger_no_of_jobs = msa[i].danger_no_of_jobs;
new_connect_data[i].link_max = msa[i].danger_no_of_jobs * 2;
new_connect_data[i].no_of_transfers = msa[i].no_of_transfers;
new_connect_data[i].host_error_counter = msa[i].host_error_counter;
new_connect_data[i].fc = msa[i].fc;
new_connect_data[i].fs = msa[i].fs;
new_connect_data[i].tr = msa[i].tr;
new_connect_data[i].fr = msa[i].fr;
new_connect_data[i].ec = msa[i].ec;
new_connect_data[i].last_data_time = msa[i].last_data_time;
new_connect_data[i].connect_status = msa[i].connect_status;
CREATE_FC_STRING(new_connect_data[i].str_fc,
new_connect_data[i].fc);
CREATE_FS_STRING(new_connect_data[i].str_fs,
new_connect_data[i].fs);
CREATE_FS_STRING(new_connect_data[i].str_tr,
new_connect_data[i].tr);
CREATE_JQ_STRING(new_connect_data[i].str_fr,
new_connect_data[i].fr);
CREATE_EC_STRING(new_connect_data[i].str_ec,
new_connect_data[i].ec);
CREATE_JQ_STRING(new_connect_data[i].str_jq,
new_connect_data[i].jobs_in_queue);
CREATE_JQ_STRING(new_connect_data[i].str_at,
new_connect_data[i].no_of_transfers);
CREATE_EC_STRING(new_connect_data[i].str_hec,
new_connect_data[i].host_error_counter);
new_connect_data[i].average_tr = 0.0;
new_connect_data[i].max_average_tr = 0.0;
new_connect_data[i].no_of_hosts = msa[i].no_of_hosts;
new_connect_data[i].max_connections = msa[i].max_connections;
if (new_connect_data[i].max_connections < 1)
{
new_connect_data[i].scale[ACTIVE_TRANSFERS_BAR_NO - 1] = (double)max_bar_length;
}
else
{
new_connect_data[i].scale[ACTIVE_TRANSFERS_BAR_NO - 1] = max_bar_length / new_connect_data[i].max_connections;
}
if (new_connect_data[i].no_of_hosts < 1)
{
new_connect_data[i].scale[HOST_ERROR_BAR_NO - 1] = (double)max_bar_length;
}
else
{
new_connect_data[i].scale[HOST_ERROR_BAR_NO - 1] = max_bar_length / new_connect_data[i].no_of_hosts;
}
if (new_connect_data[i].no_of_transfers == 0)
{
new_bar_length = 0;
}
else if (new_connect_data[i].no_of_transfers >= new_connect_data[i].max_connections)
{
new_bar_length = max_bar_length;
}
else
{
new_bar_length = new_connect_data[i].no_of_transfers * new_connect_data[i].scale[ACTIVE_TRANSFERS_BAR_NO - 1];
}
if (new_bar_length >= max_bar_length)
{
new_connect_data[i].bar_length[ACTIVE_TRANSFERS_BAR_NO] = max_bar_length;
new_connect_data[i].blue_color_offset = MAX_INTENSITY;
new_connect_data[i].green_color_offset = 0;
}
else
{
new_connect_data[i].bar_length[ACTIVE_TRANSFERS_BAR_NO] = new_bar_length;
new_connect_data[i].blue_color_offset = new_bar_length *
step_size;
new_connect_data[i].green_color_offset = MAX_INTENSITY -
new_connect_data[i].blue_color_offset;
}
new_connect_data[i].bar_length[MON_TR_BAR_NO] = 0;
if (new_connect_data[i].host_error_counter == 0)
{
new_connect_data[i].bar_length[HOST_ERROR_BAR_NO] = 0;
}
else if (new_connect_data[i].host_error_counter >= new_connect_data[i].no_of_hosts)
{
new_connect_data[i].bar_length[HOST_ERROR_BAR_NO] = max_bar_length;
}
else
{
new_connect_data[i].bar_length[HOST_ERROR_BAR_NO] = new_connect_data[i].host_error_counter *
new_connect_data[i].scale[HOST_ERROR_BAR_NO - 1];
}
new_connect_data[i].inverse = OFF;
/*
* If this line has been selected in the old
* connect_data structure, we have to make sure
* that this host has not been deleted. If it
* is deleted reduce the select counter!
*/
if ((i < prev_no_of_afds) && (connect_data[i].inverse == ON))
{
if ((pos = check_msa_data(connect_data[i].afd_alias)) == INCORRECT)
{
/* Host has been deleted. */
no_selected--;
}
}
}
} /* for (i = location_where_changed; i < no_of_afds; i++) */
/*
* Ensure that we really have checked all AFD's in old
* structure.
*/
if (prev_no_of_afds > no_of_afds)
{
while (i < prev_no_of_afds)
{
if (connect_data[i].inverse == ON)
{
if ((pos = check_msa_data(connect_data[i].afd_alias)) == INCORRECT)
{
/* Host has been deleted. */
no_selected--;
}
}
i++;
}
}
if ((tmp_connect_data = realloc(connect_data, new_size)) == NULL)
{
int tmp_errno = errno;
free(connect_data);
(void)xrec(FATAL_DIALOG, "realloc() error : %s (%s %d)",
strerror(tmp_errno), __FILE__, __LINE__);
return;
}
connect_data = tmp_connect_data;
/* Activate the new connect_data structure. */
(void)memcpy(&connect_data[0], &new_connect_data[0],
no_of_afds * sizeof(struct mon_line));
free(new_connect_data);
/* Resize window if necessary. */
if ((redraw_everything = resize_mon_window()) == YES)
{
if (no_of_columns != 0)
{
location_where_changed = 0;
}
}
/* When no. of AFD's have been reduced, then delete */
/* removed AFD's from end of list. */
for (i = prev_no_of_afds; i > no_of_afds; i--)
{
draw_mon_blank_line(i - 1);
}
/* Make sure changes are drawn !!! */
flush = YES;
} /* if (check_msa() == YES) */
/* Change information for each remote AFD if necessary. */
for (i = 0; i < no_of_afds; i++)
{
x = y = -1;
draw_identifier = NO;
if (connect_data[i].connect_status != msa[i].connect_status)
{
connect_data[i].connect_status = msa[i].connect_status;
draw_identifier = YES;
}
if ((msa[i].afd_switching != NO_SWITCHING) &&
(connect_data[i].afd_toggle != msa[i].afd_toggle))
{
#ifndef ONLY_KILL_AUTO_SWITCHING
int j;
#endif
connect_data[i].afd_toggle = msa[i].afd_toggle;
if (connect_data[i].afd_alias_length < MAX_AFDNAME_LENGTH)
{
int pos;
(void)memset(connect_data[i].afd_display_str, ' ',
MAX_AFDNAME_LENGTH);
pos = sprintf(connect_data[i].afd_display_str, "%s%d",
connect_data[i].afd_alias,
connect_data[i].afd_toggle + 1);
connect_data[i].afd_display_str[pos] = ' ';
connect_data[i].afd_display_str[MAX_AFDNAME_LENGTH] = '\0';
draw_identifier = YES;
}
/*
* With autoswitching it is best to kill the connection,
* otherwise if the host/connection dies the user will not
* be able to restart a window because the rsh/ssh process
* do not die.
*/
#ifdef ONLY_KILL_AUTO_SWITCHING
if (msa[i].afd_switching == AUTO_SWITCHING)
{
int j;
#endif
for (j = 0; j < no_of_active_process; j++)
{
if (apps_list[j].position == i)
{
if (kill(apps_list[j].pid, SIGKILL) < 0)
{
system_log(DEBUG_SIGN, __FILE__, __LINE__,
"Failed to kill() %d : %s",
apps_list[j].pid, strerror(errno));
}
}
}
/*
* Note: make_xprocess() will take care of any zombies.
*/
#ifdef ONLY_KILL_AUTO_SWITCHING
}
#endif
}
if (draw_identifier == YES)
{
locate_xy(i, &x, &y);
draw_afd_identifier(i, x, y);
flush = YES;
}
if (connect_data[i].no_of_hosts != msa[i].no_of_hosts)
{
connect_data[i].no_of_hosts = msa[i].no_of_hosts;
connect_data[i].scale[HOST_ERROR_BAR_NO - 1] = max_bar_length / connect_data[i].no_of_hosts;
}
if (connect_data[i].max_connections != msa[i].max_connections)
{
connect_data[i].max_connections = msa[i].max_connections;
connect_data[i].scale[ACTIVE_TRANSFERS_BAR_NO - 1] = max_bar_length / connect_data[i].max_connections;
}
/*
* PROCESS INFORMATION
* ===================
*/
if (connect_data[i].amg != msa[i].amg)
{
if (x == -1)
{
locate_xy(i, &x, &y);
}
if (msa[i].amg == OFF)
{
connect_data[i].blink_flag = ON;
}
else if ((msa[i].amg == ON) &&
(connect_data[i].amg != ON) &&
(connect_data[i].fd != OFF) &&
(connect_data[i].archive_watch != OFF))
{
connect_data[i].blink_flag = OFF;
}
connect_data[i].amg = msa[i].amg;
draw_mon_proc_led(AMG_LED, connect_data[i].amg, x, y);
flush = YES;
}
if (connect_data[i].fd != msa[i].fd)
{
if (x == -1)
{
locate_xy(i, &x, &y);
}
if (msa[i].fd == OFF)
{
connect_data[i].blink_flag = ON;
}
else if ((msa[i].fd == ON) &&
(connect_data[i].fd != ON) &&
(connect_data[i].amg != OFF) &&
(connect_data[i].archive_watch != OFF))
{
connect_data[i].blink_flag = OFF;
}
connect_data[i].fd = msa[i].fd;
draw_mon_proc_led(FD_LED, connect_data[i].fd, x, y);
flush = YES;
}
if (connect_data[i].archive_watch != msa[i].archive_watch)
{
if (x == -1)
{
locate_xy(i, &x, &y);
}
connect_data[i].archive_watch = msa[i].archive_watch;
draw_mon_proc_led(AW_LED, connect_data[i].archive_watch, x, y);
flush = YES;
}
if (connect_data[i].blink_flag == ON)
{
if (connect_data[i].amg == OFF)
{
if (x == -1)
{
locate_xy(i, &x, &y);
}
draw_mon_proc_led(AMG_LED, connect_data[i].blink, x, y);
flush = YES;
}
if (connect_data[i].fd == OFF)
{
if (x == -1)
{
locate_xy(i, &x, &y);
}
draw_mon_proc_led(FD_LED, connect_data[i].blink, x, y);
flush = YES;
}
if (connect_data[i].blink == TR_BAR)
{
connect_data[i].blink = OFF;
}
else
{
connect_data[i].blink = TR_BAR;
}
}
/*
* SYSTEM LOG INFORMATION
* ======================
*/
if (connect_data[i].sys_log_ec != msa[i].sys_log_ec)
{
if (x == -1)
{
locate_xy(i, &x, &y);
}
connect_data[i].sys_log_ec = msa[i].sys_log_ec;
(void)memcpy(connect_data[i].sys_log_fifo,
msa[i].sys_log_fifo,
LOG_FIFO_SIZE + 1);
draw_remote_log_status(i,
connect_data[i].sys_log_ec % LOG_FIFO_SIZE,
x, y);
flush = YES;
}
/*
* HISTORY LOG INFORMATION
* =======================
*/
if (his_log_set > 0)
{
if (memcmp(connect_data[i].log_history[RECEIVE_HISTORY],
msa[i].log_history[RECEIVE_HISTORY], MAX_LOG_HISTORY) != 0)
{
if (x == -1)
{
locate_xy(i, &x, &y);
}
(void)memcpy(connect_data[i].log_history[RECEIVE_HISTORY],
msa[i].log_history[RECEIVE_HISTORY], MAX_LOG_HISTORY);
draw_remote_history(i, RECEIVE_HISTORY, x, y);
flush = YES;
}
if (memcmp(connect_data[i].log_history[SYSTEM_HISTORY],
msa[i].log_history[SYSTEM_HISTORY], MAX_LOG_HISTORY) != 0)
{
if (x == -1)
{
locate_xy(i, &x, &y);
}
(void)memcpy(connect_data[i].log_history[SYSTEM_HISTORY],
msa[i].log_history[SYSTEM_HISTORY], MAX_LOG_HISTORY);
draw_remote_history(i, SYSTEM_HISTORY, x, y + bar_thickness_3);
flush = YES;
}
if (memcmp(connect_data[i].log_history[TRANSFER_HISTORY],
msa[i].log_history[TRANSFER_HISTORY], MAX_LOG_HISTORY) != 0)
{
if (x == -1)
{
locate_xy(i, &x, &y);
}
(void)memcpy(connect_data[i].log_history[TRANSFER_HISTORY],
msa[i].log_history[TRANSFER_HISTORY], MAX_LOG_HISTORY);
draw_remote_history(i, TRANSFER_HISTORY, x,
y + bar_thickness_3 + bar_thickness_3);
flush = YES;
}
}
/*
* CHARACTER INFORMATION
* =====================
*
* If in character mode see if any change took place,
* if so, redraw only those characters.
*/
if (line_style != BARS_ONLY)
{
/*
* Number of files to be send.
*/
if (connect_data[i].fc != msa[i].fc)
{
if (x == -1)
{
locate_xy(i, &x, &y);
}
connect_data[i].fc = msa[i].fc;
CREATE_FC_STRING(connect_data[i].str_fc, connect_data[i].fc);
if (i < location_where_changed)
{
draw_mon_chars(i, FILES_TO_BE_SEND, x, y);
flush = YES;
}
}
/*
* File size to be send.
*/
if (connect_data[i].fs != msa[i].fs)
{
char tmp_string[5];
if (x == -1)
{
locate_xy(i, &x, &y);
}
connect_data[i].fs = msa[i].fs;
CREATE_FS_STRING(tmp_string, connect_data[i].fs);
if ((tmp_string[2] != connect_data[i].str_fs[2]) ||
(tmp_string[1] != connect_data[i].str_fs[1]) ||
(tmp_string[0] != connect_data[i].str_fs[0]) ||
(tmp_string[3] != connect_data[i].str_fs[3]))
{
connect_data[i].str_fs[0] = tmp_string[0];
connect_data[i].str_fs[1] = tmp_string[1];
connect_data[i].str_fs[2] = tmp_string[2];
connect_data[i].str_fs[3] = tmp_string[3];
if (i < location_where_changed)
{
draw_mon_chars(i, FILE_SIZE_TO_BE_SEND, x + (5 * glyph_width), y);
flush = YES;
}
}
}
/*
* Transfer rate.
*/
if (connect_data[i].tr != msa[i].tr)
{
char tmp_string[5];
if (x == -1)
{
locate_xy(i, &x, &y);
}
connect_data[i].tr = msa[i].tr;
CREATE_FS_STRING(tmp_string, connect_data[i].tr);
if ((tmp_string[2] != connect_data[i].str_tr[2]) ||
(tmp_string[1] != connect_data[i].str_tr[1]) ||
(tmp_string[0] != connect_data[i].str_tr[0]) ||
(tmp_string[3] != connect_data[i].str_tr[3]))
{
connect_data[i].str_tr[0] = tmp_string[0];
connect_data[i].str_tr[1] = tmp_string[1];
connect_data[i].str_tr[2] = tmp_string[2];
connect_data[i].str_tr[3] = tmp_string[3];
if (i < location_where_changed)
{
draw_mon_chars(i, AVERAGE_TRANSFER_RATE, x + (10 * glyph_width), y);
flush = YES;
}
}
}
/*
* Connection rate.
*/
if (connect_data[i].fr != msa[i].fr)
{
if (x == -1)
{
locate_xy(i, &x, &y);
}
connect_data[i].fr = msa[i].fr;
CREATE_JQ_STRING(connect_data[i].str_fr, connect_data[i].fr);
if (i < location_where_changed)
{
draw_mon_chars(i, AVERAGE_CONNECTION_RATE,
x + (15 * glyph_width), y);
flush = YES;
}
}
/*
* Jobs in queue.
*/
if (connect_data[i].jobs_in_queue != msa[i].jobs_in_queue)
{
if (x == -1)
{
locate_xy(i, &x, &y);
}
connect_data[i].jobs_in_queue = msa[i].jobs_in_queue;
CREATE_JQ_STRING(connect_data[i].str_jq,
connect_data[i].jobs_in_queue);
if (i < location_where_changed)
{
draw_mon_chars(i, JOBS_IN_QUEUE,
x + (19 * glyph_width), y);
flush = YES;
}
}
/*
* Danger number of Jobs.
*/
if (connect_data[i].danger_no_of_jobs != msa[i].danger_no_of_jobs)
{
if (x == -1)
{
locate_xy(i, &x, &y);
}
connect_data[i].danger_no_of_jobs = msa[i].danger_no_of_jobs;
connect_data[i].link_max = connect_data[i].danger_no_of_jobs * 2;
if (i < location_where_changed)
{
draw_mon_chars(i, JOBS_IN_QUEUE,
x + (19 * glyph_width), y);
flush = YES;
}
}
/*
* Active transfers.
*/
if (connect_data[i].no_of_transfers != msa[i].no_of_transfers)
{
if (x == -1)
{
locate_xy(i, &x, &y);
}
connect_data[i].no_of_transfers = msa[i].no_of_transfers;
CREATE_JQ_STRING(connect_data[i].str_at, msa[i].no_of_transfers);
if (i < location_where_changed)
{
draw_mon_chars(i, ACTIVE_TRANSFERS,
x + (23 * glyph_width), y);
flush = YES;
}
}
/*
* Error counter.
*/
if (connect_data[i].ec != msa[i].ec)
{
if (x == -1)
{
locate_xy(i, &x, &y);
}
connect_data[i].ec = msa[i].ec;
CREATE_EC_STRING(connect_data[i].str_ec, connect_data[i].ec);
if (i < location_where_changed)
{
draw_mon_chars(i, TOTAL_ERROR_COUNTER,
x + (27 * glyph_width), y);
flush = YES;
}
}
/*
* Error hosts.
*/
if (connect_data[i].host_error_counter != msa[i].host_error_counter)
{
if (x == -1)
{
locate_xy(i, &x, &y);
}
connect_data[i].host_error_counter = msa[i].host_error_counter;
CREATE_EC_STRING(connect_data[i].str_hec, msa[i].host_error_counter);
if (i < location_where_changed)
{
draw_mon_chars(i, ERROR_HOSTS,
x + (30 * glyph_width), y);
flush = YES;
}
}
}
else
{
/*
* Transfer rate.
*/
if (connect_data[i].tr != msa[i].tr)
{
connect_data[i].tr = msa[i].tr;
}
}
/*
* BAR INFORMATION
* ===============
*/
if (line_style != CHARACTERS_ONLY)
{
/*
* Transfer Rate Bar
*/
/* Calculate transfer rate (arithmetischer Mittelwert). */
connect_data[i].average_tr = (connect_data[i].average_tr +
connect_data[i].tr) / 2.0;
if (connect_data[i].average_tr > connect_data[i].max_average_tr)
{
connect_data[i].max_average_tr = connect_data[i].average_tr;
}
if (connect_data[i].average_tr > 1.0)
{
if (connect_data[i].max_average_tr < 2.0)
{
new_bar_length = (log10(connect_data[i].average_tr) *
max_bar_length /
log10((double) 2.0));
}
else
{
new_bar_length = (log10(connect_data[i].average_tr) *
max_bar_length /
log10(connect_data[i].max_average_tr));
}
}
else
{
new_bar_length = 0;
}
if ((connect_data[i].bar_length[MON_TR_BAR_NO] != new_bar_length) &&
(new_bar_length < max_bar_length))
{
old_bar_length = connect_data[i].bar_length[MON_TR_BAR_NO];
connect_data[i].bar_length[MON_TR_BAR_NO] = new_bar_length;
if (i < location_where_changed)
{
if (x == -1)
{
locate_xy(i, &x, &y);
}
if (old_bar_length < new_bar_length)
{
draw_mon_bar(i, 1, MON_TR_BAR_NO, x, y);
}
else
{
draw_mon_bar(i, -1, MON_TR_BAR_NO, x, y);
}
if (flush != YES)
{
flush = YUP;
}
}
}
else if ((new_bar_length >= max_bar_length) &&
(connect_data[i].bar_length[MON_TR_BAR_NO] < max_bar_length))
{
connect_data[i].bar_length[MON_TR_BAR_NO] = max_bar_length;
if (i < location_where_changed)
{
if (x == -1)
{
locate_xy(i, &x, &y);
}
draw_mon_bar(i, 1, MON_TR_BAR_NO, x, y);
if (flush != YES)
{
flush = YUP;
}
}
}
/*
* Active Transfers Bar
*/
if (connect_data[i].no_of_transfers != msa[i].no_of_transfers)
{
connect_data[i].no_of_transfers = msa[i].no_of_transfers;
if (connect_data[i].no_of_transfers == 0)
{
new_bar_length = 0;
}
else if (connect_data[i].no_of_transfers >= msa[i].max_connections)
{
new_bar_length = max_bar_length;
}
else
{
new_bar_length = connect_data[i].no_of_transfers * connect_data[i].scale[ACTIVE_TRANSFERS_BAR_NO - 1];
}
if (connect_data[i].bar_length[ACTIVE_TRANSFERS_BAR_NO] != new_bar_length)
{
connect_data[i].blue_color_offset = new_bar_length * step_size;
connect_data[i].green_color_offset = MAX_INTENSITY - connect_data[i].blue_color_offset;
if (i < location_where_changed)
{
if (x == -1)
{
locate_xy(i, &x, &y);
}
if (connect_data[i].bar_length[ACTIVE_TRANSFERS_BAR_NO] < new_bar_length)
{
connect_data[i].bar_length[ACTIVE_TRANSFERS_BAR_NO] = new_bar_length;
draw_mon_bar(i, 1, ACTIVE_TRANSFERS_BAR_NO, x, y);
}
else
{
connect_data[i].bar_length[ACTIVE_TRANSFERS_BAR_NO] = new_bar_length;
draw_mon_bar(i, -1, ACTIVE_TRANSFERS_BAR_NO, x, y);
}
flush = YES;
}
}
}
/*
* Host Error Bar
*/
if (connect_data[i].host_error_counter != msa[i].host_error_counter)
{
connect_data[i].host_error_counter = msa[i].host_error_counter;
if (connect_data[i].host_error_counter >= connect_data[i].no_of_hosts)
{
new_bar_length = max_bar_length;
}
else
{
new_bar_length = connect_data[i].host_error_counter *
connect_data[i].scale[HOST_ERROR_BAR_NO - 1];
}
if (connect_data[i].bar_length[HOST_ERROR_BAR_NO] != new_bar_length)
{
if (i < location_where_changed)
{
if (x == -1)
{
locate_xy(i, &x, &y);
}
if (connect_data[i].bar_length[HOST_ERROR_BAR_NO] < new_bar_length)
{
connect_data[i].bar_length[HOST_ERROR_BAR_NO] = new_bar_length;
draw_mon_bar(i, 1, HOST_ERROR_BAR_NO, x, y);
}
else
{
connect_data[i].bar_length[HOST_ERROR_BAR_NO] = new_bar_length;
draw_mon_bar(i, -1, HOST_ERROR_BAR_NO, x, y);
}
flush = YES;
}
}
}
}
/* Redraw the line. */
if (i >= location_where_changed)
{
#ifdef _DEBUG
(void)fprintf(stderr, "count_channels: i = %d\n", i);
#endif
flush = YES;
draw_line_status(i, 1);
}
}
if (redraw_everything == YES)
{
calc_mon_but_coord(window_width);
redraw_all();
flush = YES;
}
/* Make sure all changes are shown. */
if ((flush == YES) || (flush == YUP))
{
XFlush(display);
if (flush != YUP)
{
redraw_time_line = MIN_REDRAW_TIME;
}
}
else
{
if (redraw_time_line < MAX_REDRAW_TIME)
{
redraw_time_line += REDRAW_STEP_TIME;
}
#ifdef _DEBUG
(void)fprintf(stderr, "count_channels: Redraw time = %d\n", redraw_time_line);
#endif
}
/* Redraw every redraw_time_line ms. */
(void)XtAppAddTimeOut(app, redraw_time_line,
(XtTimerCallbackProc)check_afd_status, w);
return;
}
int
main(int argc, char *argv[])
{
// define usage
const char *usage = "Usage: sudoku n00b|l33t [#]\n";
// ensure that number of arguments is as expected
if (argc != 2 && argc != 3)
{
fprintf(stderr, usage);
return 1;
}
// ensure that level is valid
if (strcmp(argv[1], "debug") == 0)
g.level = "debug";
else if (strcmp(argv[1], "n00b") == 0)
g.level = "n00b";
else if (strcmp(argv[1], "l33t") == 0)
g.level = "l33t";
else
{
fprintf(stderr, usage);
return 2;
}
// n00b and l33t levels have 1024 boards; debug level has 9
int max = (strcmp(g.level, "debug") == 0) ? 9 : 1024;
// ensure that #, if provided, is in [1, max]
if (argc == 3)
{
// ensure n is integral
char c;
if (sscanf(argv[2], " %d %c", &g.number, &c) != 1)
{
fprintf(stderr, usage);
return 3;
}
// ensure n is in [1, max]
if (g.number < 1 || g.number > max)
{
fprintf(stderr, "That board # does not exist!\n");
return 4;
}
// seed PRNG with # so that we get same sequence of boards
srand(g.number);
}
else
{
// seed PRNG with current time so that we get any sequence of boards
srand(time(NULL));
// choose a random n in [1, max]
g.number = rand() % max + 1;
}
//////////////
for (int m=0; m<9; m++)
{
for (int n=0; n<9; n++)
{
g.badMoves[m][n]=0;
}
}
// start up ncurses
if (!startup())
{
fprintf(stderr, "Error starting up ncurses!\n");
return 5;
}
// register handler for SIGWINCH (SIGnal WINdow CHanged)
signal(SIGWINCH, (void (*)(int)) handle_signal);
// start the first game
if (!restart_game())
{
shutdown();
fprintf(stderr, "Could not load board from disk!\n");
return 6;
}
redraw_all();
// let the user play!
int ch;
do
{
// refresh the screen
refresh();
// get user's input
ch = getch();
//check won
// capitalize input to simplify cases
ch = toupper(ch);
// process user's input
switch (ch)
{
// start a new game
case 'N':
g.number = rand() % max + 1;
if (!restart_game())
{
shutdown();
fprintf(stderr, "Could not load board from disk!\n");
return 6;
}
break;
// restart current game
case 'R':
if (!restart_game())
{
shutdown();
fprintf(stderr, "Could not load board from disk!\n");
return 6;
}
break;
// let user manually redraw screen with ctrl-L
case CTRL('l'):
redraw_all();
break;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//getting input as a char and logging as the ascii value
case '9':
movenumber=9;
if (tempBoard[g.y][g.x]!=0)///
break;///
if (check_valid(movenumber))
{
g.board[g.y][g.x]=9;
draw_numbers();
show_cursor();////
//printf ("%c" g.board[3][3]);
//printf ("%c" tempBoard[3][3]);
}
break;
case '8':
movenumber=8;
if (tempBoard[g.y][g.x]!=0)///
break;///
if (check_valid(movenumber))
{
g.board[g.y][g.x]=8;
draw_numbers();
show_cursor();////
}
break;
case '7':
movenumber=7;
if (tempBoard[g.y][g.x]!=0)///
break;///
if (check_valid(movenumber))
{
g.board[g.y][g.x]=7;
draw_numbers();
show_cursor();////
}
break;
case '6':
movenumber=6;
if (tempBoard[g.y][g.x]!=0)///
break;///
check_valid(movenumber);
g.board[g.y][g.x]=6;
draw_numbers();
show_cursor();////
break;
case '5':
movenumber=5;
if (tempBoard[g.y][g.x]!=0)///
break;///
check_valid(movenumber);
g.board[g.y][g.x]=5;
draw_numbers();
show_cursor();////
break;
case '4':
movenumber=4;
if (tempBoard[g.y][g.x]!=0)///
break;///
check_valid(movenumber);
g.board[g.y][g.x]=4;
draw_numbers();
show_cursor();////
break;
case '3':
movenumber=3;
if (tempBoard[g.y][g.x]!=0)///
break;///
check_valid(movenumber);
g.board[g.y][g.x]=3;
draw_numbers();
show_cursor();////
break;
case '2':
movenumber=2;
if (tempBoard[g.y][g.x]!=0)///
break;///
check_valid(movenumber);
g.board[g.y][g.x]=2;
draw_numbers();
show_cursor();////
break;
case '1':
movenumber=1;
if (tempBoard[g.y][g.x]!=0)///
break;///
check_valid(movenumber);
g.board[g.y][g.x]=1;
draw_numbers();
show_cursor();////
break;
case '0':
break;
case KEY_UP:
// move cursor to new place
if (g.y<1)
{
g.y = 8;
}
else
g.y = g.y-1;
show_cursor();
break;
case KEY_DOWN:
// move cursor to new place
if (g.y>7)
{
g.y = 0;
}
else
g.y = g.y+1;
show_cursor();
break;
case KEY_RIGHT:
// move cursor to new place
if (g.x>7)
{
g.x = 0;
}
else
g.x = g.x+1;
show_cursor();
break;
case KEY_LEFT:
// move cursor to new place
if (g.x<1)
{
g.x = 8;
}
else
g.x = g.x-1;
show_cursor();
break;
}
// log input (and board's state) if any was received this iteration
if (ch != ERR)
log_move(ch);
if (!badBanner())
{
hide_banner();
show_cursor();
}
////call badBanner
} ///////////////////////////////goes with do way above////////
while (ch != 'Q');
// shut down ncurses
shutdown();
// tidy up the screen (using ANSI escape sequences)
printf("\033[2J");
printf("\033[%d;%dH", 0, 0);
// that's all folks
printf("\nkthxbai!\n\n");
return 0;
}
int
main(int argc, char *argv[])
{
// define usage
const char *usage = "Usage: sudoku n00b|l33t [#]\n";
// ensure that number of arguments is as expected
if (argc != 2 && argc != 3)
{
fprintf(stderr, usage);
return 1;
}
// ensure that level is valid
if (strcmp(argv[1], "debug") == 0)
g.level = "debug";
else if (strcmp(argv[1], "n00b") == 0)
g.level = "n00b";
else if (strcmp(argv[1], "l33t") == 0)
g.level = "l33t";
else
{
fprintf(stderr, usage);
return 2;
}
// n00b and l33t levels have 1024 boards; debug level has 9
int max = (strcmp(g.level, "debug") == 0) ? 9 : 1024;
// ensure that #, if provided, is in [1, max]
if (argc == 3)
{
// ensure n is integral
char c;
if (sscanf(argv[2], " %d %c", &g.number, &c) != 1)
{
fprintf(stderr, usage);
return 3;
}
// ensure n is in [1, max]
if (g.number < 1 || g.number > max)
{
fprintf(stderr, "That board # does not exist!\n");
return 4;
}
// seed PRNG with # so that we get same sequence of boards
srand(g.number);
}
else
{
// seed PRNG with current time so that we get any sequence of boards
srand(time(NULL));
// choose a random n in [1, max]
g.number = rand() % max + 1;
}
// start up ncurses
if (!startup())
{
fprintf(stderr, "Error starting up ncurses!\n");
return 5;
}
// register handler for SIGWINCH (SIGnal WINdow CHanged)
signal(SIGWINCH, (void (*)(int)) handle_signal);
// start the first game
if (!restart_game())
{
shutdown();
fprintf(stderr, "Could not load board from disk!\n");
return 6;
}
redraw_all();
// let the user play!
int ch;
int last[3] = {10};
do
{
// refresh the screen
refresh();
// get user's input
ch = getch();
// capitalize input to simplify cases
ch = toupper(ch);
// process user's input
switch (ch)
{
// start a new game
case 'N':
g.number = rand() % max + 1;
if (!restart_game())
{
shutdown();
fprintf(stderr, "Could not load board from disk!\n");
return 6;
}
break;
// restart current game
case 'R':
if (!restart_game())
{
shutdown();
fprintf(stderr, "Could not load board from disk!\n");
return 6;
}
break;
// let user manually redraw screen with ctrl-L
case CTRL('l'):
redraw_all();
break;
case 'U': case CTRL('Z'):
if (last[0] != 10 && !game_won())
{
g.board[last[0]][last[1]] = last[2];
draw_numbers();
if (check_cols(1) || check_rows(1) || check_squares(1))
hide_banner();
show_cursor();
warn();
}
break;
// move cursor
case KEY_UP:
if (g.y > 0)
{
g.y -= 1;
show_cursor();
}
else
{
g.y = 8;
show_cursor();
}
break;
case KEY_DOWN:
if (g.y < 8)
{
g.y += 1;
show_cursor();
}
else
{
g.y = 0;
show_cursor();
}
break;
case KEY_LEFT:
if (g.x > 0)
{
g.x -= 1;
show_cursor();
}
else
{
g.x = 8;
show_cursor();
}
break;
case KEY_RIGHT:
if (g.x < 8)
{
g.x += 1;
show_cursor();
}
else
{
g.x = 0;
show_cursor();
}
break;
//input number and check if game is won
case '1' ... '9':
if (g.init_board[g.y][g.x] == 0)
{
last[0] = g.y;
last[1] = g.x;
last[2] = g.board[g.y][g.x];
g.board[g.y][g.x] = ch - 48;
draw_numbers();
if (check_cols(1) || check_rows(1) || check_squares(1))
hide_banner();
show_cursor();
}
game_won();
warn();
break;
//return to blank space
case '0': case '.': case KEY_BACKSPACE: case KEY_DC:
if (g.init_board[g.y][g.x] == 0)
{
last[0] = g.y;
last[1] = g.x;
last[2] = g.board[g.y][g.x];
g.board[g.y][g.x] = 0;
draw_numbers();
if (check_cols(1) || check_rows(1) || check_squares(1))
hide_banner();
show_cursor();
}
warn();
break;
}
// log input (and board's state) if any was received this iteration
if (ch != ERR)
log_move(ch);
}
while (ch != 'Q');
// shut down ncurses
shutdown();
// tidy up the screen (using ANSI escape sequences)
printf("\033[2J");
printf("\033[%d;%dH", 0, 0);
// that's all folks
printf("\nkthxbai!\n\n");
return 0;
}
