static void
clone_print_xml(resource_t * rsc, const char *pre_text, long options, void *print_data)
{
int is_master_slave = rsc->variant == pe_master ? 1 : 0;
char *child_text = crm_concat(pre_text, " ", ' ');
const char *target_role = configured_role_str(rsc);
GListPtr gIter = rsc->children;
status_print("%s<clone ", pre_text);
status_print("id=\"%s\" ", rsc->id);
status_print("multi_state=\"%s\" ", is_master_slave ? "true" : "false");
status_print("unique=\"%s\" ", is_set(rsc->flags, pe_rsc_unique) ? "true" : "false");
status_print("managed=\"%s\" ", is_set(rsc->flags, pe_rsc_managed) ? "true" : "false");
status_print("failed=\"%s\" ", is_set(rsc->flags, pe_rsc_failed) ? "true" : "false");
status_print("failure_ignored=\"%s\" ",
is_set(rsc->flags, pe_rsc_failure_ignored) ? "true" : "false");
if (target_role) {
status_print("target_role=\"%s\" ", target_role);
}
status_print(">\n");
for (; gIter != NULL; gIter = gIter->next) {
resource_t *child_rsc = (resource_t *) gIter->data;
child_rsc->fns->print(child_rsc, child_text, options, print_data);
}
status_print("%s</clone>\n", pre_text);
free(child_text);
}
int multitrack_add_track( void *data )
{
multitracker_t *mt = (multitracker_t*) data;
int res = 0;
char *hostname = vj_calloc( 100 );
int port_num = 0;
if( mt_new_connection_dialog( mt, hostname, 100, &port_num ) == GTK_RESPONSE_ACCEPT )
{
int track = 0;
if( gvr_track_connect( mt->preview, hostname, port_num, &track ) )
{
status_print( mt, "Connection established with veejay runnning on %s port %d",
hostname, port_num );
if( gveejay_user_preview() )
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(mt->view[track]->toggle), TRUE );
gtk_widget_set_sensitive_(GTK_WIDGET(mt->view[track]->panel), TRUE );
gtk_widget_set_sensitive_(GTK_WIDGET(mt->view[track]->toggle), TRUE );
res = 1;
}
else
{
status_print( mt, "Unable to open connection with %s : %d", hostname, port_num );
}
}
free( hostname );
return res;
}
static void examine_file(void)
{
char *new_fname;
print_statusline("Examine: ");
new_fname = less_gets(sizeof("Examine: ") - 1);
if (!new_fname[0]) {
status_print();
err:
free(new_fname);
return;
}
if (access(new_fname, R_OK) != 0) {
print_statusline("Cannot read this file");
goto err;
}
free(filename);
filename = new_fname;
/* files start by = argv. why we assume that argv is infinitely long??
files[num_files] = filename;
current_file = num_files + 1;
num_files++; */
files[0] = filename;
num_files = current_file = 1;
reinitialize();
}
static void
group_print_xml(resource_t * rsc, const char *pre_text, long options, void *print_data)
{
GListPtr gIter = rsc->children;
char *child_text = crm_concat(pre_text, " ", ' ');
status_print("%s<group id=\"%s\" ", pre_text, rsc->id);
status_print("number_resources=\"%d\" ", g_list_length(rsc->children));
status_print(">\n");
for (; gIter != NULL; gIter = gIter->next) {
resource_t *child_rsc = (resource_t *) gIter->data;
child_rsc->fns->print(child_rsc, child_text, options, print_data);
}
status_print("%s</group>\n", pre_text);
free(child_text);
}
static void status_service(void)
{
static int last_event;
if(elapsed(&last_event, identifier_frequency_read())) {
if(status_enabled) {
status_print();
printf("\r\n");
}
}
}
/* Print the buffer */
static void buffer_print(void)
{
unsigned i;
move_cursor(0, 0);
for (i = 0; i <= max_displayed_line; i++)
if (pattern_valid)
print_found(buffer[i]);
else
print_ascii(buffer[i]);
status_print();
}
static gint begin_scan_matching(gpointer data __attribute__ ((unused))) {
g_mutex_lock(laserscans_mutex);
scan_matching = 1;
g_mutex_unlock(laserscans_mutex);
status_print("Scan matching...", "scanmatch");
g_idle_add(scan_match, (gpointer) 1);
return FALSE;
}
static gint end_scan_matching(gpointer data) {
long cancelled = (long) data;
g_mutex_lock(laserscans_mutex);
scan_matching = 0;
g_mutex_unlock(laserscans_mutex);
gtk_progress_set_percentage(GTK_PROGRESS(progress_bar), 0.0);
if (!cancelled) {
laser_scans_update();
status_print("Scan matching...complete", "scanmatch");
}
else {
laser_scans_restore();
status_print("Scan matching...cancelled", "scanmatch");
}
return FALSE;
}
static void john_run(void)
{
if (options.flags & FLG_TEST_CHK)
exit_status = benchmark_all() ? 1 : 0;
else
if (options.flags & FLG_MAKECHR_CHK)
do_makechars(&database, options.charset);
else
if (options.flags & FLG_CRACKING_CHK) {
if (!(options.flags & FLG_STDOUT)) {
status_init(NULL, 1);
log_init(LOG_NAME, options.loader.activepot, options.session);
john_log_format();
if (cfg_get_bool(SECTION_OPTIONS, NULL, "Idle", 1))
log_event("- Configured to use otherwise idle "
"processor cycles only");
}
tty_init(options.flags & FLG_STDIN_CHK);
if (options.flags & FLG_SINGLE_CHK)
do_single_crack(&database);
else
if ((options.flags & FLG_GIJOHN_CHK) && FLG_EXTERNAL_CHK)
{
do
{
do_external_crack(&database);
if (!aborted_gijohn) ext_init("gijohn");
}
while (crk_db->password_count && !aborted_gijohn);
}
else
if (options.flags & FLG_WORDLIST_CHK)
do_wordlist_crack(&database, options.wordlist,
(options.flags & FLG_RULES) != 0);
else
if (options.flags & FLG_INC_CHK)
do_incremental_crack(&database, options.charset);
else
if (options.flags & FLG_MKV_CHK)
do_markov_crack(&database, options.mkv_level, options.mkv_start, options.mkv_end, options.mkv_maxlen);
else
if ((options.flags & FLG_EXTERNAL_CHK) && FLG_GIJOHN_CHK)
do_external_crack(&database);
else
if (options.flags & FLG_BATCH_CHK)
do_batch_crack(&database);
status_print();
tty_done();
}
}
int status_display(t_kit *k, int *map, int *map2)
{
static int inst;
int j;
ft_printf("\e[1;1H\e[2J");
status_print(*(k->a), *(k->b), map, map2);
j = lstlen(*(k->a)) > lstlen(*(k->b)) ? lstlen(*(k->a)) : lstlen(*(k->b));
while (j++ < 64)
ft_printf("\n");
ft_printf("+%d, %d\n", lstlen(*(k->in)) - inst, lstlen(*(k->in)));
inst = lstlen(*(k->in));
getchar();
return (1);
}
static void
short_print(char *list, const char *prefix, const char *type, const char *suffix, long options, void *print_data)
{
if(suffix == NULL) {
suffix = "";
}
if (list) {
if (options & pe_print_html) {
status_print("<li>");
}
status_print("%s%s: [%s ]%s", prefix, type, list, suffix);
if (options & pe_print_html) {
status_print("</li>\n");
} else if (options & pe_print_suppres_nl) {
/* nothing */
} else if ((options & pe_print_printf) || (options & pe_print_ncurses)) {
status_print("\n");
}
}
}
/* Print the buffer */
static void buffer_print(void)
{
int i;
printf("%s", CLEAR);
if (num_flines >= height - 2) {
for (i = 0; i < height - 1; i++)
printf("%s", buffer[i]);
}
else {
for (i = 1; i < (height - 1 - num_flines); i++)
putchar('\n');
for (i = 0; i < height - 1; i++)
printf("%s", buffer[i]);
}
status_print();
}
void
group_print(resource_t * rsc, const char *pre_text, long options, void *print_data)
{
char *child_text = NULL;
GListPtr gIter = rsc->children;
if (pre_text == NULL) {
pre_text = " ";
}
if (options & pe_print_xml) {
group_print_xml(rsc, pre_text, options, print_data);
return;
}
child_text = crm_concat(pre_text, " ", ' ');
status_print("%sResource Group: %s", pre_text ? pre_text : "", rsc->id);
if (options & pe_print_html) {
status_print("\n<ul>\n");
} else if ((options & pe_print_log) == 0) {
status_print("\n");
}
if (options & pe_print_brief) {
print_rscs_brief(rsc->children, child_text, options, print_data, TRUE);
} else {
for (; gIter != NULL; gIter = gIter->next) {
resource_t *child_rsc = (resource_t *) gIter->data;
if (options & pe_print_html) {
status_print("<li>\n");
}
child_rsc->fns->print(child_rsc, child_text, options, print_data);
if (options & pe_print_html) {
status_print("</li>\n");
}
}
}
if (options & pe_print_html) {
status_print("</ul>\n");
}
free(child_text);
}
void do_scan_matching() {
int stop;
if (!scan_list) {
status_print("Ctrl-O opens a logfile", "tools");
return;
}
if (!laserscans_mutex)
g_mutex_init(laserscans_mutex);
//laserscans_mutex = g_mutex_new();
g_mutex_lock(laserscans_mutex);
stop = scan_matching;
g_mutex_unlock(laserscans_mutex);
if (!stop)
g_idle_add(begin_scan_matching, NULL);
else
g_idle_add(end_scan_matching, (gpointer) 1);
}
void pause_draw(void)
{
game_draw();
status_print();
}
void opt_init(char *name, int argc, char **argv)
{
if (argc < 2)
print_usage(name);
memset(&options, 0, sizeof(options));
list_init(&options.passwd);
options.loader.flags = DB_LOGIN;
list_init(&options.loader.users);
list_init(&options.loader.groups);
list_init(&options.loader.shells);
options.length = -1;
opt_process(opt_list, &options.flags, argv);
ext_flags = 0;
if (options.flags & FLG_EXTERNAL_CHK) {
if (options.flags & (FLG_CRACKING_CHK | FLG_MAKECHR_CHK)) {
ext_flags = EXT_REQ_FILTER | EXT_USES_FILTER;
} else {
options.flags |= FLG_CRACKING_SET;
ext_flags = EXT_REQ_GENERATE |
EXT_USES_GENERATE | EXT_USES_FILTER;
}
}
if (!(options.flags & FLG_ACTION))
options.flags |= FLG_BATCH_SET;
opt_check(opt_list, options.flags, argv);
if (options.session) {
#if OS_FORK
char *p = strrchr(options.session, '.');
int bad = 0;
if (p) {
while (*++p) {
if (*p < '0' || *p > '9') {
bad = 0;
break;
}
bad = 1;
}
}
if (bad) {
fprintf(stderr,
"Invalid session name: all-digits suffix\n");
error();
}
#endif
rec_name = options.session;
rec_name_completed = 0;
}
if (options.flags & FLG_RESTORE_CHK) {
#if OS_FORK
char *rec_name_orig = rec_name;
#endif
rec_restore_args(1);
#if OS_FORK
if (options.fork) {
rec_name = rec_name_orig;
rec_name_completed = 0;
}
#endif
return;
}
if (options.flags & FLG_STATUS_CHK) {
#if OS_FORK
char *rec_name_orig = rec_name;
#endif
rec_restore_args(0);
options.flags |= FLG_STATUS_SET;
status_init(NULL, 1);
status_print();
#if OS_FORK
if (options.fork) {
unsigned int i;
for (i = 2; i <= options.fork; i++) {
rec_name = rec_name_orig;
rec_name_completed = 0;
rec_restoring_now = 0;
options.node_min = options.node_max = i;
john_main_process = 0;
rec_restore_args(0);
john_main_process = 1;
options.node_min = options.node_max = i;
options.flags |= FLG_STATUS_SET;
if (rec_restoring_now)
status_print();
}
}
#endif
exit(0);
}
if (options.flags & FLG_SALTS)
if (options.loader.min_pps < 0) {
options.loader.max_pps = -1 - options.loader.min_pps;
options.loader.min_pps = 0;
}
if (options.length < 0)
options.length = PLAINTEXT_BUFFER_SIZE - 3;
else
if (options.length < 1 || options.length > PLAINTEXT_BUFFER_SIZE - 3) {
fprintf(stderr, "Invalid plaintext length requested\n");
error();
}
if (options.flags & FLG_STDOUT) options.flags &= ~FLG_PWD_REQ;
#if OS_FORK
if ((options.flags & FLG_FORK) &&
(options.fork < 2 || options.fork > 1024)) {
fprintf(stderr, "--fork number must be between 2 and 1024\n");
error();
}
#endif
if (options.node_str) {
const char *msg = NULL;
int n;
if ((n = sscanf(options.node_str, "%u-%u/%u",
&options.node_min, &options.node_max,
&options.node_count)) != 3) {
n = sscanf(options.node_str, "%u/%u",
&options.node_min, &options.node_count);
options.node_max = options.node_min;
#if OS_FORK
if (options.fork)
options.node_max += options.fork - 1;
#endif
}
if (n < 2)
msg = "valid syntax is MIN-MAX/TOTAL or N/TOTAL";
else if (!options.node_min)
msg = "valid node numbers start from 1";
else if (options.node_min > options.node_max)
msg = "range start can't exceed range end";
else if (options.node_count < 2)
msg = "node count must be at least 2";
else if (options.node_max > options.node_count)
msg = "node numbers can't exceed node count";
#if OS_FORK
else if (options.fork &&
options.node_max - options.node_min + 1 != options.fork)
msg = "range must be consistent with --fork number";
#endif
else if (!options.fork &&
options.node_max - options.node_min + 1 ==
options.node_count)
msg = "node numbers can't span the whole range";
if (msg) {
fprintf(stderr, "Invalid node specification: %s: %s\n",
options.node_str, msg);
error();
}
#if OS_FORK
} else if (options.fork) {
options.node_min = 1;
options.node_max = options.node_min + options.fork - 1;
options.node_count = options.node_max;
#endif
}
if ((options.flags & (FLG_PASSWD | FLG_PWD_REQ)) == FLG_PWD_REQ) {
fprintf(stderr, "Password files required, "
"but none specified\n");
error();
}
if ((options.flags & (FLG_PASSWD | FLG_PWD_SUP)) == FLG_PASSWD) {
fprintf(stderr, "Password files specified, "
"but no option would use them\n");
error();
}
rec_argc = argc; rec_argv = argv;
rec_check = 0;
}
void opt_init(char *name, int argc, char **argv)
{
if (argc < 2)
print_usage(name);
memset(&options, 0, sizeof(options));
list_init(&options.passwd);
options.loader.flags = DB_LOGIN;
list_init(&options.loader.users);
list_init(&options.loader.groups);
list_init(&options.loader.shells);
options.length = -1;
opt_process(opt_list, &options.flags, argv);
ext_flags = 0;
if (options.flags & FLG_EXTERNAL_CHK) {
if (options.flags & (FLG_CRACKING_CHK | FLG_MAKECHR_CHK)) {
ext_flags = EXT_REQ_FILTER | EXT_USES_FILTER;
} else {
options.flags |= FLG_CRACKING_SET;
ext_flags = EXT_REQ_GENERATE |
EXT_USES_GENERATE | EXT_USES_FILTER;
}
}
if (!(options.flags & FLG_ACTION))
options.flags |= FLG_BATCH_SET;
opt_check(opt_list, options.flags, argv);
if (options.session) {
rec_name = options.session;
rec_name_completed = 0;
}
if (options.flags & FLG_RESTORE_CHK) {
rec_restore_args(1);
return;
}
if (options.flags & FLG_STATUS_CHK) {
rec_restore_args(0);
options.flags |= FLG_STATUS_SET;
status_init(NULL, 1);
status_print();
exit(0);
}
if (options.flags & FLG_SALTS)
if (options.loader.min_pps < 0) {
options.loader.max_pps = -1 - options.loader.min_pps;
options.loader.min_pps = 0;
}
if (options.length < 0)
options.length = PLAINTEXT_BUFFER_SIZE - 3;
else
if (options.length < 1 || options.length > PLAINTEXT_BUFFER_SIZE - 3) {
fprintf(stderr, "Invalid plaintext length requested\n");
error();
}
if (options.flags & FLG_STDOUT) options.flags &= ~FLG_PWD_REQ;
if ((options.flags & (FLG_PASSWD | FLG_PWD_REQ)) == FLG_PWD_REQ) {
fprintf(stderr, "Password files required, "
"but none specified\n");
error();
}
if ((options.flags & (FLG_PASSWD | FLG_PWD_SUP)) == FLG_PASSWD) {
fprintf(stderr, "Password files specified, "
"but no option would use them\n");
error();
}
rec_argc = argc; rec_argv = argv;
rec_check = 0;
}
static int status_merge(void *status, package_t *pkgs)
{
FILE *fin, *fout;
char *line;
package_t *pkg = 0, *statpkg = 0;
package_t locpkg;
int r = 0;
if ((fin = fopen(statusfile, "r")) == NULL) {
perror(statusfile);
return 0;
}
if ((fout = fopen(new_statusfile, "w")) == NULL) {
perror(new_statusfile);
return 0;
}
if (getenv(udpkg_quiet) == NULL) {
printf("(Updating database...)\n");
}
while (((line = get_line_from_file(fin)) != NULL) && !feof(fin)) {
line[strlen(line)] = 0; /* trim newline */
/* If we see a package header, find out if it's a package
* that we have processed. if so, we skip that block for
* now (write it at the end).
*
* we also look at packages in the status cache and update
* their status fields
*/
if (strstr(line, "Package: ") == line) {
for (pkg = pkgs; pkg != 0 && strncmp(line + 9,
pkg->package, strlen(line) - 9) != 0;
pkg = pkg->next) ;
locpkg.package = line + 9;
statpkg = tfind(&locpkg, &status, package_compare);
/* note: statpkg should be non-zero, unless the status
* file was changed while we are processing (no locking
* is currently done...
*/
if (statpkg != 0) {
statpkg = *(package_t **)statpkg;
}
}
if (pkg != 0) {
continue;
}
if (strstr(line, "Status: ") == line && statpkg != 0) {
snprintf(line, sizeof(line), "Status: %s",
status_print(statpkg->status));
}
fputs(line, fout);
fputc('\n', fout);
}
free(line);
// Print out packages we processed.
for (pkg = pkgs; pkg != 0; pkg = pkg->next) {
fprintf(fout, "Package: %s\nStatus: %s\n",
pkg->package, status_print(pkg->status));
if (pkg->depends)
fprintf(fout, "Depends: %s\n", pkg->depends);
if (pkg->provides)
fprintf(fout, "Provides: %s\n", pkg->provides);
if (pkg->installer_menu_item)
fprintf(fout, "installer-menu-item: %i\n", pkg->installer_menu_item);
if (pkg->description)
fprintf(fout, "Description: %s\n", pkg->description);
fputc('\n', fout);
}
fclose(fin);
fclose(fout);
r = rename(statusfile, bak_statusfile);
if (r == 0) {
r = rename(new_statusfile, statusfile);
}
return 0;
}
void
clone_print(resource_t * rsc, const char *pre_text, long options, void *print_data)
{
char *list_text = NULL;
char *child_text = NULL;
char *stopped_list = NULL;
const char *type = "Clone";
GListPtr master_list = NULL;
GListPtr started_list = NULL;
GListPtr gIter = rsc->children;
clone_variant_data_t *clone_data = NULL;
int active_instances = 0;
if (pre_text == NULL) {
pre_text = " ";
}
if (options & pe_print_xml) {
clone_print_xml(rsc, pre_text, options, print_data);
return;
}
get_clone_variant_data(clone_data, rsc);
child_text = crm_concat(pre_text, " ", ' ');
if (rsc->variant == pe_master) {
type = "Master/Slave";
}
status_print("%s%s Set: %s [%s]%s%s",
pre_text ? pre_text : "", type, rsc->id, ID(clone_data->xml_obj_child),
is_set(rsc->flags, pe_rsc_unique) ? " (unique)" : "",
is_set(rsc->flags, pe_rsc_managed) ? "" : " (unmanaged)");
if (options & pe_print_html) {
status_print("\n<ul>\n");
} else if ((options & pe_print_log) == 0) {
status_print("\n");
}
for (; gIter != NULL; gIter = gIter->next) {
gboolean print_full = FALSE;
resource_t *child_rsc = (resource_t *) gIter->data;
if (options & pe_print_clone_details) {
print_full = TRUE;
}
if (child_rsc->fns->active(child_rsc, FALSE) == FALSE) {
/* Inactive clone */
if (is_set(child_rsc->flags, pe_rsc_orphan)) {
continue;
} else if (is_set(rsc->flags, pe_rsc_unique)) {
print_full = TRUE;
} else if (is_not_set(options, pe_print_clone_active)) {
stopped_list = add_list_element(stopped_list, child_rsc->id);
}
} else if (is_set_recursive(child_rsc, pe_rsc_unique, TRUE)
|| is_set_recursive(child_rsc, pe_rsc_orphan, TRUE)
|| is_set_recursive(child_rsc, pe_rsc_managed, FALSE) == FALSE
|| is_set_recursive(child_rsc, pe_rsc_failed, TRUE)) {
/* Unique, unmanaged or failed clone */
print_full = TRUE;
} else if (is_set(options, pe_print_pending) && child_rsc->pending_task != NULL) {
/* In a pending state */
print_full = TRUE;
} else if (child_rsc->fns->active(child_rsc, TRUE)) {
/* Fully active anonymous clone */
node_t *location = child_rsc->fns->location(child_rsc, NULL, TRUE);
if (location) {
enum rsc_role_e a_role = child_rsc->fns->state(child_rsc, TRUE);
if (location->details->online == FALSE && location->details->unclean) {
print_full = TRUE;
} else if (a_role > RSC_ROLE_SLAVE) {
/* And active on a single node as master */
master_list = g_list_append(master_list, location);
} else {
/* And active on a single node as started/slave */
started_list = g_list_append(started_list, location);
}
} else {
/* uncolocated group - bleh */
print_full = TRUE;
}
} else {
/* Partially active anonymous clone */
print_full = TRUE;
}
if (print_full) {
if (options & pe_print_html) {
status_print("<li>\n");
}
child_rsc->fns->print(child_rsc, child_text, options, print_data);
if (options & pe_print_html) {
status_print("</li>\n");
}
}
}
/* Masters */
master_list = g_list_sort(master_list, sort_node_uname);
for (gIter = master_list; gIter; gIter = gIter->next) {
node_t *host = gIter->data;
list_text = add_list_element(list_text, host->details->uname);
active_instances++;
}
short_print(list_text, child_text, "Masters", NULL, options, print_data);
g_list_free(master_list);
free(list_text);
list_text = NULL;
/* Started/Slaves */
started_list = g_list_sort(started_list, sort_node_uname);
for (gIter = started_list; gIter; gIter = gIter->next) {
node_t *host = gIter->data;
list_text = add_list_element(list_text, host->details->uname);
active_instances++;
}
if(rsc->variant == pe_master) {
enum rsc_role_e role = configured_role(rsc);
if(role > RSC_ROLE_STOPPED && role < RSC_ROLE_MASTER) {
short_print(list_text, child_text, "Slaves (target-role)", NULL, options, print_data);
} else {
short_print(list_text, child_text, "Slaves", NULL, options, print_data);
}
} else {
short_print(list_text, child_text, "Started", NULL, options, print_data);
}
g_list_free(started_list);
free(list_text);
list_text = NULL;
if (is_not_set(options, pe_print_clone_active)) {
const char *state = "Stopped";
enum rsc_role_e role = configured_role(rsc);
if (role == RSC_ROLE_STOPPED) {
state = "Stopped (disabled)";
}
if (is_not_set(rsc->flags, pe_rsc_unique)
&& (clone_data->clone_max > active_instances)) {
GListPtr nIter;
GListPtr list = g_hash_table_get_values(rsc->allowed_nodes);
/* Custom stopped list for non-unique clones */
free(stopped_list); stopped_list = NULL;
if (g_list_length(list) == 0) {
/* Clusters with symmetrical=false haven't calculated allowed_nodes yet
* If we've not probed for them yet, the Stopped list will be empty
*/
list = g_hash_table_get_values(rsc->known_on);
}
list = g_list_sort(list, sort_node_uname);
for (nIter = list; nIter != NULL; nIter = nIter->next) {
node_t *node = (node_t *)nIter->data;
if (pe_find_node(rsc->running_on, node->details->uname) == NULL) {
stopped_list = add_list_element(stopped_list, node->details->uname);
}
}
g_list_free(list);
}
short_print(stopped_list, child_text, state, NULL, options, print_data);
free(stopped_list);
}
if (options & pe_print_html) {
status_print("</ul>\n");
}
free(child_text);
}
static void john_run(void)
{
if (options.flags & FLG_TEST_CHK)
exit_status = benchmark_all() ? 1 : 0;
else
if (options.flags & FLG_MAKECHR_CHK)
do_makechars(&database, options.charset);
else
if (options.flags & FLG_CRACKING_CHK) {
int remaining = database.password_count;
if (!(options.flags & FLG_STDOUT)) {
status_init(NULL, 1);
log_init(LOG_NAME, options.loader.activepot, options.session);
john_log_format();
if (idle_requested(database.format))
log_event("- Configured to use otherwise idle "
"processor cycles only");
}
tty_init(options.flags & FLG_STDIN_CHK);
#if defined(HAVE_MPI) && defined(_OPENMP)
if (database.format->params.flags & FMT_OMP &&
omp_get_max_threads() > 1 && mpi_p > 1) {
if(cfg_get_bool(SECTION_OPTIONS, NULL, "MPIOMPmutex", 1)) {
if(cfg_get_bool(SECTION_OPTIONS, NULL, "MPIOMPverbose", 1) &&
mpi_id == 0)
fprintf(stderr, "MPI in use, disabling OMP (see doc/README.mpi)\n");
omp_set_num_threads(1);
} else
if(cfg_get_bool(SECTION_OPTIONS, NULL, "MPIOMPverbose", 1) &&
mpi_id == 0)
fprintf(stderr, "Note: Running both MPI and OMP (see doc/README.mpi)\n");
}
#endif
if (options.flags & FLG_SINGLE_CHK)
do_single_crack(&database);
else
if (options.flags & FLG_WORDLIST_CHK)
do_wordlist_crack(&database, options.wordlist,
(options.flags & FLG_RULES) != 0);
else
if (options.flags & FLG_INC_CHK)
do_incremental_crack(&database, options.charset);
else
if (options.flags & FLG_MKV_CHK)
do_markov_crack(&database, options.mkv_level, options.mkv_start, options.mkv_end, options.mkv_maxlen, options.mkv_minlevel, options.mkv_minlen);
else
if (options.flags & FLG_EXTERNAL_CHK)
do_external_crack(&database);
else
if (options.flags & FLG_BATCH_CHK)
do_batch_crack(&database);
status_print();
tty_done();
if (database.password_count < remaining) {
char *might = "Warning: passwords printed above might";
char *partial = " be partial";
char *not_all = " not be all those cracked";
switch (database.options->flags &
(DB_SPLIT | DB_NODUP)) {
case DB_SPLIT:
#ifdef HAVE_MPI
if (mpi_id == 0)
#endif
fprintf(stderr, "%s%s\n", might, partial);
break;
case DB_NODUP:
#ifdef HAVE_MPI
if (mpi_id == 0)
#endif
fprintf(stderr, "%s%s\n", might, not_all);
break;
case (DB_SPLIT | DB_NODUP):
#ifdef HAVE_MPI
if (mpi_id == 0)
#endif
fprintf(stderr, "%s%s and%s\n",
might, partial, not_all);
}
#ifdef HAVE_MPI
if (mpi_id == 0)
#endif
fputs("Use the \"--show\" option to display all of "
"the cracked passwords reliably\n", stderr);
}
}
}
int status_merge(void *status, struct package_t *pkgs)
{
FILE *fin, *fout;
char buf[BUFSIZE];
struct package_t *pkg = 0, *statpkg = 0;
struct package_t locpkg;
int r = 0;
if ((fin = fopen(STATUSFILE, "r")) == NULL)
{
perror(STATUSFILE);
return 0;
}
if ((fout = fopen(STATUSFILE ".new", "w")) == NULL)
{
perror(STATUSFILE ".new");
return 0;
}
if (getenv(UDPKG_QUIET) == NULL)
printf("(Updating database...)\n");
while (fgets(buf, BUFSIZE, fin) && !feof(fin))
{
buf[strlen(buf)-1] = 0; /* trim newline */
/* If we see a package header, find out if it's a package
* that we have processed. if so, we skip that block for
* now (write it at the end).
*
* we also look at packages in the status cache and update
* their status fields
*/
if (strstr(buf, "Package: ") == buf)
{
for (pkg = pkgs; pkg != 0 && strcmp(buf+9,
pkg->package)!=0; pkg = pkg->next) ;
locpkg.package = buf+9;
statpkg = tfind(&locpkg, &status, package_compare);
/* note: statpkg should be non-zero, unless the status
* file was changed while we are processing (no locking
* is currently done...
*/
if (statpkg != 0) statpkg = *(struct package_t **)statpkg;
}
if (pkg != 0) continue;
if (strstr(buf, "Status: ") == buf && statpkg != 0)
{
snprintf(buf, sizeof(buf), "Status: %s",
status_print(statpkg->status));
}
fputs(buf, fout);
fputc('\n', fout);
}
// Print out packages we processed.
for (pkg = pkgs; pkg != 0; pkg = pkg->next) {
fprintf(fout, "Package: %s\nStatus: %s\n",
pkg->package, status_print(pkg->status));
if (pkg->priority)
fprintf(fout, "Priority: %s\n", pkg->priority);
if (pkg->section)
fprintf(fout, "Section: %s\n", pkg->section);
if (pkg->priority)
fprintf(fout, "Installed-Size: %s\n", pkg->installed_size);
if (pkg->maintainer)
fprintf(fout, "Maintainer: %s\n", pkg->maintainer);
if (pkg->source)
fprintf(fout, "Source: %s\n", pkg->source);
if (pkg->version)
fprintf(fout, "Version: %s\n", pkg->version);
if (pkg->pre_depends)
fprintf(fout, "Pre-Depends: %s\n", pkg->pre_depends);
if (pkg->depends)
fprintf(fout, "Depends: %s\n", pkg->depends);
if (pkg->replaces)
fprintf(fout, "Replaces: %s\n", pkg->replaces);
if (pkg->recommends)
fprintf(fout, "Recommends: %s\n", pkg->recommends);
if (pkg->suggests)
fprintf(fout, "Suggests: %s\n", pkg->suggests);
if (pkg->provides)
fprintf(fout, "Provides: %s\n", pkg->provides);
if (pkg->conflicts)
fprintf(fout, "Conflicts: %s\n", pkg->conflicts);
if (pkg->conffiles)
fprintf(fout, "Conffiles:\n %s\n", pkg->conffiles);
if (pkg->description)
fprintf(fout, "Description: %s\n%s", pkg->description, pkg->long_description);
#ifdef SUPPORTL10N
if (pkg->localized_descriptions) {
struct language_description_t *ld;
ld = pkg->localized_descriptions;
while (ld) {
if (ld->language && ld->description &&
ld->long_description) {
fprintf(fout, "description-%s: %s\n%s",
ld->language,
ld->description,
ld->long_description);
}
ld = ld->next;
}
}
#endif
if (pkg->installer_menu_item)
fprintf(fout, "Installer-Menu-Item: %i\n", pkg->installer_menu_item);
fputc('\n', fout);
}
fclose(fin);
fclose(fout);
r = rename(STATUSFILE, STATUSFILE ".bak");
if (r == 0) r = rename(STATUSFILE ".new", STATUSFILE);
return 0;
}
int main(int argc, char *argv[])
{
struct vrmr_ctx vctx;
int retval = 0, optch = 0;
static char optstring[] = "c:d:hVW";
struct option long_options[] = {
{"configfile", required_argument, NULL, 'c'},
{"debug", required_argument, NULL, 'd'},
{"help", no_argument, NULL, 'h'},
{"version", no_argument, NULL, 'V'},
{"wizard", no_argument, NULL, 'W'},
{0, 0, 0, 0},
};
int longopt_index = 0;
int debug_level = NONE;
PANEL *main_panels[5];
char *s = NULL;
/* some defaults */
vuurmuur_semid = -1;
vuurmuur_shmid = -1;
vuurmuurlog_semid = -1;
vuurmuurlog_shmid = -1;
/* create the version string */
snprintf(version_string, sizeof(version_string),
"%s (using libvuurmuur %s)", VUURMUURCONF_VERSION,
libvuurmuur_get_version());
/* some initilization */
if (vrmr_init(&vctx, "vuurmuur_conf") < 0)
exit(EXIT_FAILURE);
/* settings file */
memset(vccnf.configfile_location, 0, sizeof(vccnf.configfile_location));
if (vctx.conf.etcdir[0] == '\0')
(void)strlcpy(vccnf.configfile_location, VUURMUURCONF_CONFIGFILE,
sizeof(vccnf.configfile_location));
else
(void)snprintf(vccnf.configfile_location,
sizeof(vccnf.configfile_location),
"%s/vuurmuur/vuurmuur_conf.conf", vctx.conf.etcdir);
#ifdef ENABLE_NLS
setlocale(LC_ALL, "");
setlocale(LC_TIME, "");
setlocale(LC_MESSAGES, "");
setlocale(LC_COLLATE, "");
setlocale(LC_CTYPE, "");
setlocale(LC_MONETARY, "");
setlocale(LC_NUMERIC, "");
#endif
/* check if we are in utf-8 mode */
utf8_mode = 0;
if ((s = getenv("LC_ALL")) || (s = getenv("LC_CTYPE")) ||
(s = getenv("LANG"))) {
if (strstr(s, "UTF-8"))
utf8_mode = 1;
}
#ifdef ENABLE_NLS
bindtextdomain("vuurmuur", xstr(VRMR_LOCALEDIR));
textdomain("vuurmuur");
#endif
/* process commandline options */
while ((optch = getopt_long(argc, argv, optstring, long_options,
&longopt_index)) != -1) {
switch (optch) {
case 'h':
print_commandline_args();
break;
/* configfile */
case 'c':
if (strlcpy(vctx.conf.configfile, optarg,
sizeof(vctx.conf.configfile)) >=
sizeof(vctx.conf.configfile)) {
vrmr_error(EXIT_FAILURE, VR_ERR,
gettext("commandline argument too long for option "
"-c."));
exit(EXIT_FAILURE);
}
break;
case 'd':
/* convert the debug string and check the result */
debug_level = atoi(optarg);
if (debug_level < 0 || debug_level > HIGH) {
vrmr_error(EXIT_FAILURE, VR_ERR,
gettext("commandline debuglevel out of range."));
exit(EXIT_FAILURE);
}
vrmr_debug_level = debug_level;
fprintf(stdout, "vuurmuur_conf: debugging enabled.\n");
fprintf(stdout, "vuurmuur_conf: debug level: %d\n",
debug_level);
break;
case 'V':
/* print version */
fprintf(stdout, "Vuurmuur_conf %s\n", version_string);
fprintf(stdout, "%s\n", VUURMUUR_COPYRIGHT);
exit(EXIT_SUCCESS);
case 'W': {
char wizard_path[512] = "";
snprintf(wizard_path, sizeof(wizard_path),
"%s/scripts/vuurmuur-wizard.sh", vctx.conf.datadir);
printf("Running %s...\n", wizard_path);
exec_wizard(wizard_path);
exit(EXIT_SUCCESS);
}
default:
vrmr_error(EXIT_FAILURE, VR_ERR,
gettext("unknown commandline option."));
exit(EXIT_FAILURE);
}
}
/* close the STDERR_FILENO because it gives us annoying "Broken
Pipe" errors on some systems with bash3. Let's see if this
has negative side-effects. */
close(STDERR_FILENO);
/* init vuurmuur_conf config already to get background */
(void)init_vcconfig(&vctx.conf, vccnf.configfile_location, &vccnf);
/* Initialize curses */
(void)initscr();
(void)start_color();
(void)cbreak();
(void)noecho();
(void)keypad(stdscr, (bool)TRUE);
setup_colors();
/* create the three main windows */
if (!(status_frame_win = create_newwin(
3, COLS, LINES - 3, 0, NULL, vccnf.color_bgd)))
exit(EXIT_FAILURE);
if (!(status_win = create_newwin(
1, COLS - 4, LINES - 2, 2, NULL, vccnf.color_bgd)))
exit(EXIT_FAILURE);
if (!(top_win = create_newwin(3, COLS, 0, 0, NULL, vccnf.color_bgd)))
exit(EXIT_FAILURE);
if (!(main_win = create_newwin(
LINES - 6, COLS, 3, 0, NULL, vccnf.color_bgd)))
exit(EXIT_FAILURE);
if (!(mainlog_win = newwin(LINES - 8, COLS - 2, 4, 1)))
exit(EXIT_FAILURE);
(void)wbkgd(mainlog_win, vccnf.color_bgd);
wattron(status_frame_win, vccnf.color_bgd);
mvwprintw(status_frame_win, 0, 2, " %s ", gettext("Status"));
mvwprintw(status_frame_win, 2,
(int)(COLS - 4 - StrLen(vctx.user_data.realusername) - 6),
" user: %s ", vctx.user_data.realusername);
wattroff(status_frame_win, vccnf.color_bgd);
/* Attach a panel to each window */
main_panels[0] = new_panel(top_win);
main_panels[1] = new_panel(main_win);
main_panels[2] = new_panel(status_win);
main_panels[3] = new_panel(mainlog_win);
main_panels[4] = new_panel(status_frame_win);
(void)update_panels();
(void)doupdate();
/* init the vrprint functions for the Gui */
vrprint.error = vuumuurconf_print_error;
vrprint.warning = vuumuurconf_print_warning;
vrprint.info = vuumuurconf_print_info;
if (status_print(status_win, gettext("This is Vuurmuur_conf %s, %s"),
version_string, VUURMUUR_COPYRIGHT) < 0)
exit(EXIT_FAILURE);
/* setup the global busywin */
VrBusyWinCreate();
VrBusyWinHide();
// form_test();
/* startup_screen inits the config, loads the zones, rules, etc */
if (startup_screen(&vctx, &vctx.rules, &vctx.zones, &vctx.services,
&vctx.interfaces, &vctx.blocklist, &vctx.reg) < 0) {
/* failure! Lets quit. */
/* delete panels and windows */
(void)del_panel(main_panels[0]);
(void)del_panel(main_panels[1]);
(void)del_panel(main_panels[2]);
(void)del_panel(main_panels[3]);
(void)del_panel(main_panels[4]);
(void)destroy_win(top_win);
(void)destroy_win(main_win);
(void)destroy_win(status_win);
(void)destroy_win(status_frame_win);
/* clear screen */
(void)refresh();
/* end ncurses mode */
(void)endwin();
exit(EXIT_FAILURE);
}
/* setup statuslist */
(void)setup_statuslist();
status_print(status_win, STR_READY);
mm_status_checkall(&vctx, NULL, &vctx.rules, &vctx.zones, &vctx.interfaces,
&vctx.services);
/* main menu loop */
while (main_menu(&vctx, &vctx.rules, &vctx.zones, &vctx.interfaces,
&vctx.services, &vctx.blocklist, &vctx.reg) == 1)
;
/* clean up the status list */
vrmr_list_cleanup(&vuurmuur_status.StatusList);
/* detach from shared memory, if we were attached */
if (vuurmuur_shmp != NULL && vuurmuur_shmp != (char *)(-1) &&
vuurmuur_shmtable != 0) {
if (vrmr_lock(vuurmuur_semid)) {
vuurmuur_shmtable->configtool.connected = 3;
vrmr_unlock(vuurmuur_semid);
}
(void)shmdt(vuurmuur_shmp);
}
if (vuurmuurlog_shmp != NULL && vuurmuurlog_shmp != (char *)(-1) &&
vuurmuurlog_shmtable != 0) {
if (vrmr_lock(vuurmuurlog_semid)) {
vuurmuurlog_shmtable->configtool.connected = 3;
vrmr_unlock(vuurmuurlog_semid);
}
(void)shmdt(vuurmuurlog_shmp);
}
/* destroy the global busywin */
VrBusyWinDelete();
/* delete panels and windows */
(void)del_panel(main_panels[0]);
(void)del_panel(main_panels[1]);
(void)del_panel(main_panels[2]);
(void)del_panel(main_panels[3]);
(void)del_panel(main_panels[4]);
(void)destroy_win(mainlog_win);
(void)destroy_win(top_win);
(void)destroy_win(main_win);
(void)destroy_win(status_win);
(void)destroy_win(status_frame_win);
/* clear screen */
(void)refresh();
/* end ncurses mode */
(void)endwin();
/* set error functions to the stdout versions */
vrprint.error = vrmr_stdoutprint_error;
vrprint.warning = vrmr_stdoutprint_warning;
vrprint.info = vrmr_stdoutprint_info;
vrprint.debug = vrmr_stdoutprint_debug;
vrprint.audit = vrmr_stdoutprint_audit;
/* unload the backends */
if (vrmr_backends_unload(&vctx.conf, &vctx) < 0) {
vrmr_error(-1, VR_ERR, gettext("unloading the backends failed"));
retval = -1;
}
/* cleanup the datastructures */
(void)vrmr_list_cleanup(&vctx.blocklist.list);
(void)vrmr_destroy_serviceslist(&vctx.services);
(void)vrmr_destroy_zonedatalist(&vctx.zones);
(void)vrmr_rules_cleanup_list(&vctx.rules);
(void)vrmr_destroy_interfaceslist(&vctx.interfaces);
vrmr_deinit(&vctx);
return (retval);
}