int get_pass(void)
{
struct termios oldline;
char buf[BUF_SIZE + 1];
int len;
char *p;
char *c;
fputs("Password: "******"");
buf[len - 1] = '\0';
c = "$6$";
if (ld_check())
return (-2);
else if ((p = crypt(buf, c)) == NULL)
return (-1);
else if (crypt_cmp(p))
return (1);
else if (be_root(SHELL))
return (-1);
return (0);
}
void init_lines(t_area *ar, struct termios *oldline)
{
struct winsize w;
int li;
int co;
if (ioctl(0, TIOCGWINSZ, &w) < 0)
{
restore_mode(oldline, ar);
my_put_error(ERR_IOCTL);
free_struct(ar);
exit(EXIT_FAILURE);
}
li = w.ws_row;
co = w.ws_col;
if (li < 4 || co < ar->size)
{
restore_mode(oldline, ar);
my_put_error(ERR_SIZE);
free_struct(ar);
exit(EXIT_FAILURE);
}
if (li != ar->li || co != ar->co)
aff_list_resize(ar, li, co);
}
int main(int argc, char **argv)
{
struct termios oldline;
t_area ar;
if (argc > 1)
{
non_canonical_mode(&oldline);
init_term(&ar, argv, argc);
display_arguments(&ar);
while ((ar.len = read(0, ar.buff, sizeof(ar.buff))))
{
x_read(ar.len);
init_lines(&ar, &oldline);
check_ctrl(&ar);
check_keys(&ar, ar.len);
check_select(&ar);
if (my_exit(&oldline, &ar) == 1 || void_exit(&ar, &oldline) == 1)
return (EXIT_SUCCESS);
}
restore_mode(&oldline, &ar);
free_struct(&ar);
}
else
my_put_error(ERR_ARGV);
return (EXIT_SUCCESS);
}
static void
restore_metadata(struct file_stream *out, const tchar *newpath,
const struct stat *stbuf)
{
restore_mode(out, stbuf);
restore_owner_and_group(out, stbuf);
restore_timestamps(out, newpath, stbuf);
}
void rec_restore_mode(int (*restore_mode)(FILE *file))
{
rec_name_complete();
if (!rec_file) return;
if (restore_mode)
if (restore_mode(rec_file)) rec_format_error("fscanf");
/*
* Unlocking the file explicitly is normally not necessary since we're about to
* close it anyway (which would normally release the lock). However, when
* we're the main process running with --fork, our newborn children may hold a
* copy of the fd for a moment (until they close the fd themselves). Thus, if
* we don't explicitly remove the lock, there may be a race condition between
* our children closing the fd and us proceeding to re-open and re-lock it.
*/
rec_unlock();
if (fclose(rec_file)) pexit("fclose");
rec_file = NULL;
rec_restoring_now = 0;
}
void rec_restore_args(int lock)
{
char line[LINE_BUFFER_SIZE];
int index, argc;
char **argv;
char *save_rec_name;
rec_name_complete();
if (!(rec_file = fopen(path_expand(rec_name), "r+"))) {
#ifndef HAVE_MPI
if (options.fork && !john_main_process && errno == ENOENT) {
#else
if (options.node_min > 1 && errno == ENOENT) {
#endif
fprintf(stderr, "%u Session completed\n",
options.node_min);
if (options.flags & FLG_STATUS_CHK)
return;
log_event("No crash recovery file, terminating");
log_done();
#ifdef HAVE_MPI
mpi_teardown();
#endif
exit(0);
}
#ifdef HAVE_MPI
if (mpi_p > 1) {
fprintf(stderr, "%u@%s: fopen: %s: %s\n",
mpi_id + 1, mpi_name,
path_expand(rec_name), strerror(errno));
error();
}
#endif
pexit("fopen: %s", path_expand(rec_name));
}
rec_fd = fileno(rec_file);
if (lock) rec_lock(lock);
if (!fgetl(line, sizeof(line), rec_file)) rec_format_error("fgets");
rec_version = 0;
if (!strcmp(line, RECOVERY_V4)) rec_version = 4; else
if (!strcmp(line, RECOVERY_V3)) rec_version = 3; else
if (!strcmp(line, RECOVERY_V2)) rec_version = 2; else
if (!strcmp(line, RECOVERY_V1)) rec_version = 1; else
if (strcmp(line, RECOVERY_V0)) rec_format_error(NULL);
if (fscanf(rec_file, "%d\n", &argc) != 1)
rec_format_error("fscanf");
if (argc < 2)
rec_format_error(NULL);
argv = mem_alloc_tiny(sizeof(char *) * (argc + 1), MEM_ALIGN_WORD);
argv[0] = "john";
for (index = 1; index < argc; index++)
if (fgetl(line, sizeof(line), rec_file))
argv[index] = str_alloc_copy(line);
else
rec_format_error("fgets");
argv[argc] = NULL;
save_rec_name = rec_name;
opt_init(argv[0], argc, argv, 0);
rec_name = save_rec_name;
rec_name_completed = 1;
if (fscanf(rec_file, "%u\n%u\n%x\n%x\n",
&status_restored_time,
&status.guess_count,
&status.combs.lo,
&status.combs.hi) != 4)
rec_format_error("fscanf");
if (!status_restored_time)
status_restored_time = 1;
if (rec_version >= 4) {
if (fscanf(rec_file, "%x\n%x\n%x\n%x\n%x\n%d\n",
&status.combs_ehi,
&status.crypts.lo,
&status.crypts.hi,
&status.cands.lo,
&status.cands.hi,
&status.compat) != 6)
rec_format_error("fscanf");
} else {
/* Historically, we were reusing what became the combs field for candidates
* count when in --stdout mode */
status.cands = status.combs;
status.compat = 1;
}
if (rec_version == 0) {
status.pass = 0;
status.progress = -1;
} else
if (fscanf(rec_file, "%d\n%d\n", &status.pass, &status.progress) != 2)
rec_format_error("fscanf");
if (status.pass < 0 || status.pass > 3)
rec_format_error(NULL);
if (rec_version < 3)
rec_check = 0;
else
if (fscanf(rec_file, "%x\n", &rec_check) != 1)
rec_format_error("fscanf");
rec_restoring_now = 1;
}
void rec_restore_mode(int (*restore_mode)(FILE *file))
{
rec_name_complete();
if (!rec_file) return;
if (restore_mode)
if (restore_mode(rec_file)) rec_format_error("fscanf");
if (options.flags & FLG_MASK_STACKED)
if (mask_restore_state(rec_file)) rec_format_error("fscanf");
/*
* Unlocking the file explicitly is normally not necessary since we're about to
* close it anyway (which would normally release the lock). However, when
* we're the main process running with --fork, our newborn children may hold a
* copy of the fd for a moment (until they close the fd themselves). Thus, if
* we don't explicitly remove the lock, there may be a race condition between
* our children closing the fd and us proceeding to re-open and re-lock it.
*/
rec_unlock();
if (fclose(rec_file)) pexit("fclose");
rec_file = NULL;
rec_restoring_now = 0;
}
int main(int argc, char* argv[]) {
struct arguments arguments;
struct board board;
char buffer[256];
int format;
char input;
char* message;
int status; // Game status.
struct termios term_settings;
int valid;
// Parse arguments.
message = arguments_parse(&arguments, argc, argv);
if (message) {
usage_print(message);
}
// Apply arguments.
valid = 1; // Hack; overload to determine whether to play or quit.
if (arguments.flags & ARGUMENTS_VERSION) {
printf("%s\n", VERSION);
valid = 0;
}
if (arguments.flags & ARGUMENTS_LEGAL) {
printf("%s\n", legal);
valid = 0;
}
if (arguments.flags & ARGUMENTS_HELP) {
usage_print(NULL);
}
if (!valid) {
exit(EXIT_SUCCESS);
}
if (arguments.flags & ARGUMENTS_MODE) {
if (arguments.mode == mode_format) {
setup_signal_handlers();
enter_alternate_buffer();
enter_format_mode(&term_settings);
format = 1;
} else if (arguments.mode == mode_plain) {
format = 0;
}
} else if (isatty(STDOUT_FILENO) && isatty(STDIN_FILENO)) {
setup_signal_handlers();
enter_alternate_buffer();
enter_format_mode(&term_settings);
format = 1;
}
if (arguments.flags & ARGUMENTS_SEED) {
srand(arguments.seed);
} else {
srand(time(NULL));
}
// Set up the board.
board_init(&board);
if (!format) {
fputs(legal, stdout);
}
// Play the game.
play:
valid = 1;
while (!(status = board_done(&board))) {
// Set up screen for next move.
// Sorry about this ugly call.
screen_print(&board, valid ? (format ? "\n\n" : "") :
"\nInvalid move.\n", format);
// Get the player's move.
input = yoink(format);
// Process player's move.
if (input == 'w' || input == 'k') {
valid = board_move_up(&board);
} else if (input == 's' || input == 'j') {
valid = board_move_down(&board);
} else if (input == 'a' || input == 'h') {
valid = board_move_left(&board);
} else if (input == 'd' || input == 'l') {
valid = board_move_right(&board);
} else if (input == 'n') {
// Start a new game (or not) based on user input.
printf("Start a new game? [y/N] ");
input = yoink(format);
if (input == 'y' || input == 'Y') {
board_reset(&board);
}
continue;
} else if (input == '?') {
help_print();
if (format) {
printf("\nPress any key to continue.");
input = yoink(format);
}
continue;
} else {
valid = 0;
}
// End player's move.
if (valid) {
board_plop(&board);
}
}
// Print the final board.
snprintf(buffer, sizeof(buffer),
"\nGame over, you %s!\n\nPlay again? [y/n]\n",
(status < 0) ? "LOSE" : "WIN");
screen_print(&board, buffer, format);
// Check for new game.
while ((input = yoink(format)) != 'y' && input != 'Y' &&
input != 'n' && input != 'N') {
screen_print(&board, buffer, format);
}
if (input == 'y' || input == 'Y') {
board_reset(&board);
goto play;
}
// Restore the terminal.
if (format) {
restore_mode();
leave_alternate_buffer();
}
// Free the board.
board_free(&board);
// Return success.
return EXIT_SUCCESS;
}
