Context Navigation

source: MondoRescue/branches/2.2.9/mondo/src/common/newt-specific.c@ 2374

Visit:

Last change on this file since 2374 was 2374, checked in by Bruno Cornec, 15 years ago
Try to fix garbled screen progression in text mode based on 2.2.10 modifications which are working
Property svn:keywords set to `Id`
File size: 46.5 KB

Rev	Line
[1]	1	/* newt-specific.c
[99]	2	$Id: newt-specific.c 2374 2009-09-08 18:04:07Z bruno $
[1]	3
	4	subroutines which do display-type things
	5	and use the newt library to do them
	6	*/
	7
	8
	9	/**
	10	* @file
	11	* Functions for doing display-type things with the Newt library.
	12	*/
	13
	14	#define MAX_NEWT_COMMENT_LEN 200
	15
	16	#if __cplusplus
	17	extern "C" {
	18	#endif
	19
	20	#include "my-stuff.h"
[2211]	21	#include "mr_mem.h"
[1]	22	#include "mondostructures.h"
	23	#include "newt-specific.h"
	24	#include "libmondo-string-EXT.h"
	25	#include "libmondo-files-EXT.h"
	26	#include "libmondo-devices-EXT.h"
	27	#include "libmondo-tools-EXT.h"
	28	#include "libmondo-fork-EXT.h"
[541]	29	#include "libmondo-gui-EXT.h"
	30	#include "lib-common-externs.h"
[1]	31
[1316]	32	extern char *MONDO_LOGFILE;
	33
[1665]	34	extern struct s_bkpinfo *bkpinfo;
	35
[1]	36	/@unused@/
[99]	37	//static char cvsid[] = "$Id: newt-specific.c 2374 2009-09-08 18:04:07Z bruno $";
[1]	38
[128]	39	extern pid_t g_mastermind_pid;
[2030]	40	/*
[128]	41	extern char *g_tmpfs_mountpt;
[2030]	42	*/
[128]	43	extern char *g_boot_mountpt;
[792]	44	extern char *ps_options;
[928]	45	extern char *ps_proc_id;
[1]	46
[128]	47	extern void set_signals(int);
[1]	48
	49	/**
	50	* @addtogroup globalGroup
	51	* @{
	52	*/
	53	/**
	54	* Whether we are currently in a nested call of fatal_error().
	55	*/
[128]	56	bool g_exiting = FALSE;
[1]	57
	58	/**
	59	* Padding below the Newt components, to overcome bugs in Newt.
	60	*/
[128]	61	char g_haharrrrr[500];
[1]	62
	63
[128]	64	newtComponent g_timeline = NULL, ///< The line of the progress form that shows the time elapsed/remaining
	65	g_percentline = NULL, ///< The line of the progress form that shows the percent completed/remaining
	66	g_scale = NULL, ///< The progress bar component in the progress form
	67	g_progressForm = NULL, ///< The progress form component itself
	68	g_blurb1 = NULL, ///< The component for line 1 of the blurb in the progress form
	69	g_blurb2 = NULL, ///< The component for line 2 of the blurb in the progress form
	70	g_blurb3 = NULL, ///< The component for line 3 (updated continuously) of the blurb in the progress form
	71	g_label = NULL; ///< ????? @bug ?????
[1]	72
	73	/**
	74	* Padding above the Newt components, to overcome bugs in Newt.
	75	*/
[128]	76	char g_jim_lad_yarr[500];
	77	char **err_log_lines = NULL, ///< The list of log lines to show on the screen.
	78	g_blurb_str_1[MAX_NEWT_COMMENT_LEN] = "", ///< The string for line 1 of the blurb in the progress form
	79	g_blurb_str_2[MAX_NEWT_COMMENT_LEN] = "", ///< The string for line 2 of the blurb in the progress form
	80	g_blurb_str_3[MAX_NEWT_COMMENT_LEN] = ""; ///< The string for line 3 (updated continuously) of the blurb in the progress form
	81	newtComponent g_isoform_main = NULL, ///< The evalcall form component itself
	82	g_isoform_header = NULL, ///< The component for the evalcall form title
	83	g_isoform_scale = NULL, ///< The progress bar component in the evalcall form
	84	g_isoform_timeline = NULL, ///< The line of the evalcall form that shows the time elapsed/remaining
	85	g_isoform_pcline = NULL; ///< The line of the evalcall form that shows the percent completed/remaining
	86	long g_isoform_starttime; ///< The time (in seconds since the epoch) that the evalcall form was opened.
	87	int g_isoform_old_progress = -1; ///< The most recent progress update of the evalcall form (percent).
	88	char g_isoform_header_str[MAX_STR_LEN] = " "; ///< The string for the evalcall form title.
	89	int g_mysterious_dot_counter; ///< The counter for the twirling baton (/ \| \\ - ...) on percentage less than 3
	90	int g_noof_log_lines = 6; ///< The number of lines to show in the log at the bottom of the screen.
	91	int g_noof_rows = 25; ///< The number of rows on the screen.
[1]	92
[128]	93	int g_currentY = 3; ///< The row to write background progress messages to. Incremented each time a message is written.
	94	extern int g_current_media_number;
	95	pid_t g_main_pid = 0; ///< The PID of the main Mondo process.
	96	long g_maximum_progress = 999; ///< The maximum amount of progress (100%) for the currently opened progress form.
	97	long g_current_progress = -999; ///< The current amount of progress (filelist #, etc.) for the currently opened progress form.
	98	long g_start_time = 0; ///< The time (in seconds since the epoch) that the progress form was opened.
	99	bool g_text_mode = TRUE; ///< If FALSE, use a newt interface; if TRUE, use an ugly (but more compatible) dumb terminal interface.
	100	char g_xmondo_stdin[MAX_NEWT_COMMENT_LEN], ///< ... @bug Unneeded w/current XMondo.
	101	g_xmondo_stdout[MAX_NEWT_COMMENT_LEN]; ///< .... @bug Unneeded w/current XMondo.
	102	bool g_called_by_xmondo = FALSE; ///< @bug Unneeded w/current XMondo.
	103	char *g_selfmounted_isodir; ///< Holds the NFS mountpoint if mounted via mondoarchive.
[1]	104
	105	/* @} - end of globalGroup */
	106
	107	//int g_fd_in=-1, g_fd_out=-1;
	108
[128]	109	void popup_and_OK(char *);
[1]	110
	111
	112	/**
	113	* @addtogroup guiGroup
	114	* @{
	115	*/
	116	/**
	117	* Ask the user a yes/no question.
	118	* @param prompt The question to ask the user.
	119	* @return TRUE for yes; FALSE for no.
	120	*/
[128]	121	bool ask_me_yes_or_no(char *prompt) {
[1]	122
[128]	123	/@ buffers ********************************************************* */
	124	int i;
[1]	125
[128]	126	assert_string_is_neither_NULL_nor_zerolength(prompt);
[1]	127
[128]	128	if (g_text_mode) {
[2136]	129
	130	char *tmp;
	131	tmp = malloc(MAX_NEWT_COMMENT_LEN);
	132
[128]	133	while (1) {
	134	system("sync");
	135	printf
[1899]	136	("---promptdialogYN---1--- %s\n---promptdialogYN---Q--- [yes] [no] ---\n--> ",
[128]	137	prompt);
	138	(void) fgets(tmp, MAX_NEWT_COMMENT_LEN, stdin);
	139	if (tmp[strlen(tmp) - 1] == '\n')
	140	tmp[strlen(tmp) - 1] = '\0';
[1]	141
[128]	142	i = (int) strlen(tmp);
	143	if (i > 0 && tmp[i - 1] < 32) {
	144	tmp[i - 1] = '\0';
	145	}
[541]	146	if (strstr("yesYES", tmp)) {
[128]	147	paranoid_free(tmp);
	148	return (TRUE);
[541]	149	} else if (strstr("NOno", tmp)) {
[128]	150	paranoid_free(tmp);
	151	return (FALSE);
	152	} else {
	153	system("sync");
	154	printf
[541]	155	("Please enter either YES or NO (or yes or no, or y or n, or...)\n");
[128]	156	}
	157	}
	158	} else {
[541]	159	return (popup_with_buttons(prompt, "Yes", "No"));
[128]	160	}
	161	}
[1]	162
	163
	164	/**
	165	* Give the user the opportunity to continue the current operation (OK)
	166	* or cancel it (Cancel).
	167	* @param prompt The string to be displayed.
	168	* @return TRUE for OK, FALSE for Cancel.
	169	*/
[128]	170	bool ask_me_OK_or_cancel(char *prompt) {
[1]	171
[128]	172	/@ buffer ********************************************************** */
	173	char *tmp;
	174	int i;
[1]	175
[128]	176	tmp = malloc(MAX_NEWT_COMMENT_LEN);
	177	assert_string_is_neither_NULL_nor_zerolength(prompt);
	178	if (g_text_mode) {
	179	system("sync");
	180	printf
[1899]	181	("---promptdialogOKC---1--- %s\n---promptdialogOKC---Q--- [OK] [Cancel] ---\n--> ",
[128]	182	prompt);
	183	(void) fgets(tmp, MAX_NEWT_COMMENT_LEN, stdin);
	184	if (tmp[strlen(tmp) - 1] == '\n')
	185	tmp[strlen(tmp) - 1] = '\0';
[1]	186
[128]	187	i = (int) strlen(tmp);
	188	if (i > 0 && tmp[i - 1] < 32) {
	189	tmp[i - 1] = '\0';
	190	}
[541]	191	if (strstr("okOKOkYESyes", tmp)) {
[128]	192	paranoid_free(tmp);
	193	return (TRUE);
	194	} else {
	195	paranoid_free(tmp);
	196	return (FALSE);
	197	}
	198	} else {
	199	paranoid_free(tmp);
[541]	200	return (popup_with_buttons(prompt, " Okay ", "Cancel"));
[128]	201	}
[1]	202	}
	203
	204
	205
	206	/**
	207	* Close the currently opened evalcall form.
	208	*/
[128]	209	void
	210	close_evalcall_form(void) {
	211	if (g_text_mode) {
	212	return;
	213	}
	214	if (g_isoform_main == NULL) {
	215	return;
	216	}
	217	update_evalcall_form(100);
	218	usleep(500000);
	219	if (g_text_mode) {
	220	log_msg(2, "Closing evalcall form");
	221	return;
	222	}
	223	newtPopHelpLine();
	224	newtFormDestroy(g_isoform_main);
	225	newtPopWindow();
[2290]	226
	227	/* Reset globals */
[128]	228	g_isoform_main = NULL;
	229	g_isoform_old_progress = -1;
[2290]	230	g_isoform_header = NULL;
	231	g_isoform_scale = NULL;
	232	g_isoform_timeline = NULL;
	233	g_isoform_pcline = NULL;
	234	}
[1]	235
	236	/**
	237	* Close the currently opened progress form.
	238	*/
[128]	239	void
	240	close_progress_form() {
	241	if (g_text_mode) {
	242	return;
	243	}
	244	if (g_current_progress == -999) {
	245	log_msg(2,
	246	"Trying to close the progress form when it ain't open!");
	247	return;
	248	}
	249	g_current_progress = g_maximum_progress;
	250	update_progress_form("Complete");
	251	sleep(1);
	252	if (g_text_mode) {
	253	log_msg(2, "Closing progress form");
	254	return;
	255	}
	256	newtPopHelpLine();
	257	newtFormDestroy(g_progressForm);
	258	newtPopWindow();
[2290]	259
	260	/* Reset globals */
[128]	261	g_progressForm = NULL;
	262	g_current_progress = -999;
[2290]	263	g_timeline = NULL;
	264	g_percentline = NULL;
	265	g_scale = NULL;
	266
[128]	267	}
[1]	268
[792]	269	/**
	270	* Kill any process containing the string @p str surrounded by spaces in its commandline.
	271	*/
	272	void kill_anything_like_this(char *str) {
[1]	273
[792]	274	char *tmp = NULL;
[1850]	275	char *tmp1 = NULL;
[1]	276
[2211]	277	mr_asprintf(&tmp,"ps %s \| grep \" %s \" \| awk '{print %s;}' \| grep -v \"grep\"", ps_options, str , ps_proc_id);
[1294]	278	run_program_and_log_output(tmp, TRUE);
[1850]	279	if (strlen(tmp) > 0) {
[2211]	280	mr_asprintf(&tmp1,"kill `%s`", tmp);
[1850]	281	run_program_and_log_output(tmp1, TRUE);
	282	paranoid_free(tmp1);
	283	}
[1294]	284	paranoid_free(tmp);
[792]	285	}
[1]	286
[792]	287
[1]	288	/**
	289	* Exit Mondo with a fatal error.
	290	* @param error_string The error message to present to the user before exiting.
	291	* @note This function never returns.
	292	*/
[128]	293	void
	294	fatal_error(char *error_string) {
	295	/@ buffers **************************************************** */
	296	char fatalstr[MAX_NEWT_COMMENT_LEN] =
	297	"-------FATAL ERROR---------";
	298	char *tmp;
	299	char *command;
	300	static bool already_exiting = FALSE;
[1]	301
[128]	302	/@ end vars *************************************************** */
[1]	303
[128]	304	malloc_string(command);
	305	tmp = malloc(MAX_NEWT_COMMENT_LEN);
	306	set_signals(FALSE); // link to external func
	307	g_exiting = TRUE;
	308	log_msg(1, "Fatal error received - '%s'", error_string);
	309	printf("Fatal error... %s\n", error_string);
	310	if (getpid() == g_mastermind_pid) {
	311	log_msg(2, "mastermind %d is exiting", (int) getpid());
	312	kill(g_main_pid, SIGTERM);
	313	paranoid_free(tmp);
	314	finish(1);
	315	}
[1]	316
[128]	317	if (getpid() != g_main_pid) {
	318	if (g_mastermind_pid != 0 && getpid() != g_mastermind_pid) {
	319	log_msg(2, "non-m/m %d is exiting", (int) getpid());
	320	kill(g_main_pid, SIGTERM);
	321	paranoid_free(tmp);
	322	finish(1);
	323	}
	324	}
[1]	325
[128]	326	log_msg(3, "OK, I think I'm the main PID.");
	327	if (already_exiting) {
	328	log_msg(3, "...I'm already exiting. Give me time, Julian!");
	329	paranoid_free(tmp);
	330	finish(1);
	331	}
[1]	332
[128]	333	already_exiting = TRUE;
	334	log_msg(2, "I'm going to do some cleaning up now.");
	335	paranoid_system("killall mindi 2> /dev/null");
	336	kill_anything_like_this("/mondo/do-not");
	337	kill_anything_like_this("tmp.mondo");
[296]	338	kill_anything_like_this("ntfsclone");
[128]	339	sync();
[2030]	340	/*
[128]	341	sprintf(tmp, "umount %s", g_tmpfs_mountpt);
	342	for (i = 0; i < 10 && run_program_and_log_output(tmp, 5); i++) {
	343	log_msg(2, "Waiting for child processes to terminate");
	344	sleep(1);
	345	run_program_and_log_output(tmp, 5);
	346	}
[2030]	347	*/
[1]	348
[2030]	349	chdir("/");
[128]	350	if (g_selfmounted_isodir) {
	351	sprintf(command, "umount %s", g_selfmounted_isodir);
	352	run_program_and_log_output(command, 5);
	353	sprintf(command, "rmdir %s", g_selfmounted_isodir);
	354	run_program_and_log_output(command, 5);
	355	}
[99]	356
[128]	357	if (!g_text_mode) {
	358	log_msg(0, fatalstr);
	359	log_msg(0, error_string);
	360	// popup_and_OK (error_string);
	361	newtFinished();
	362	}
[1]	363
[128]	364	printf("---FATALERROR--- %s\n", error_string);
[213]	365	printf
[541]	366	("If you require technical support, please contact the mailing list.\n");
	367	printf("See http://www.mondorescue.org for details.\n");
[213]	368	printf
[541]	369	("The list's members can help you, if you attach that file to your e-mail.\n");
	370	printf("Log file: %s\n", MONDO_LOGFILE);
	371	printf("Mondo has aborted.\n");
[128]	372	if (!g_main_pid) {
	373	log_msg(3, "FYI - g_main_pid is blank");
	374	}
	375	paranoid_free(tmp);
	376	paranoid_free(command);
	377	finish(254);
	378	}
[1]	379
[2241]	380	/* Free memory allocated for newt */
	381	void free_newt_stuff() {
[1]	382
[2241]	383	int i;
[1]	384
[2241]	385	for (i = 0; i < g_noof_log_lines; i++) {
	386	mr_free(err_log_lines[i]);
	387	}
	388	mr_free(err_log_lines);
	389	}
	390
	391
	392
[1]	393	/**
	394	* Exit Mondo normally.
	395	* @param signal The exit code (0 indicates a successful backup; 1 for Mondo means the
	396	* user aborted; 254 means a fatal error occured).
	397	* @note This function never returns.
	398	*/
[128]	399	void
	400	finish(int signal) {
[1708]	401	char *command = NULL;
[1]	402
[128]	403	/* if (signal==0) { popup_and_OK("Please press <enter> to quit."); } */
[1]	404
[128]	405	/* newtPopHelpLine(); */
[1]	406
[128]	407	chdir("/");
	408	run_program_and_log_output("umount " MNT_CDROM, FALSE);
	409	if (g_selfmounted_isodir) {
[2211]	410	mr_asprintf(&command, "umount %s", g_selfmounted_isodir);
[128]	411	run_program_and_log_output(command, 1);
[1708]	412	paranoid_free(command);
[2211]	413	mr_asprintf(&command, "rmdir %s", g_selfmounted_isodir);
[128]	414	run_program_and_log_output(command, 1);
[1708]	415	paranoid_free(command);
[128]	416	}
	417	if (!g_text_mode) {
	418	if (does_file_exist("/THIS-IS-A-RAMDISK")) {
	419	log_msg(1, "Calling newtFinished()");
	420	newtFinished();
	421	} else {
	422	log_msg(1, "Calling newtSuspend()");
	423	newtSuspend();
	424	}
	425	}
[541]	426	printf("Execution run ended; result=%d\n", signal);
	427	printf("Type 'less %s' to see the output log\n", MONDO_LOGFILE);
[2241]	428	if (bkpinfo->tmpdir) {
	429	log_msg(8,"tempdir is %s",bkpinfo->tmpdir);
	430	if (strstr(bkpinfo->tmpdir ,"mondo.tmp.") != NULL) {
	431	log_msg(8,"erasing tempdir");
	432	mr_asprintf(&command, "rm -Rf %s", bkpinfo->tmpdir);
	433	system(command);
	434	paranoid_free(command);
	435	}
[1999]	436	}
[2241]	437	if (bkpinfo->scratchdir) {
	438	log_msg(8,"scratchdir is %s", bkpinfo->scratchdir);
	439	if (strstr(bkpinfo->scratchdir ,"mondo.scratch.") != NULL) {
	440	log_msg(8,"erasing scratchdir");
	441	mr_asprintf(&command, "rm -Rf %s", bkpinfo->scratchdir);
	442	system(command);
	443	paranoid_free(command);
	444	}
	445	}
	446	/* Free all allocated strings in bkpinfo */
	447	mr_free(bkpinfo->nfs_user);
	448
	449	/* Then free the structure */
[1703]	450	paranoid_free(bkpinfo);
[128]	451	free_libmondo_global_strings();
[2241]	452	free_newt_stuff();
[128]	453	exit(signal);
	454	}
[1]	455
	456
	457
	458
	459
	460	/**
	461	* Log the last @p g_noof_log_lines lines of @p filename that match @p
	462	* grep_for_me to the screen.
	463	* @param filename The file to give the end of.
	464	* @param grep_for_me If not "", then only give lines in @p filename that match this regular expression.
	465	*/
[128]	466	void
	467	log_file_end_to_screen(char filename, char grep_for_me) {
[1]	468
[128]	469	/@ buffers ********************************************************* */
	470	char *command;
	471	char *tmp;
[1]	472
[128]	473	/@ pointers ******************************************************** */
	474	FILE *fin;
[1]	475
[128]	476	/@ int ************************************************************* */
	477	int i = 0;
[1]	478
[128]	479	malloc_string(command);
	480	malloc_string(tmp);
	481	assert_string_is_neither_NULL_nor_zerolength(filename);
	482	assert(grep_for_me != NULL);
[1]	483
[128]	484	if (!does_file_exist(filename)) {
	485	paranoid_free(command);
	486	paranoid_free(tmp);
	487	return;
[1]	488	}
[128]	489	if (grep_for_me[0] != '\0') {
	490	sprintf(command, "grep '%s' %s \| tail -n%d",
	491	grep_for_me, filename, g_noof_log_lines);
	492	} else {
[144]	493	sprintf(command, "tail -n%d %s", g_noof_log_lines,
[128]	494	filename);
[1]	495	}
[128]	496	fin = popen(command, "r");
	497	if (!fin) {
	498	log_OS_error(command);
	499	} else {
	500	for (i = 0; i < g_noof_log_lines; i++) {
	501	for (err_log_lines[i][0] = '\0';
	502	strlen(err_log_lines[i]) < 2 && !feof(fin);) {
	503	(void) fgets(err_log_lines[i], MAX_NEWT_COMMENT_LEN,
	504	fin);
[1274]	505	/* Commented to make valgrind happy and avoid crash
[128]	506	strip_spaces(err_log_lines[i]);
[1274]	507	*/
[128]	508	if (!strncmp(err_log_lines[i], "root:", 5)) {
	509	strcpy(tmp, err_log_lines[i] + 6);
	510	strcpy(err_log_lines[i], tmp);
	511	}
	512	if (feof(fin)) {
	513	break;
	514	}
	515	}
	516	}
	517	paranoid_pclose(fin);
	518	}
	519	refresh_log_screen();
	520	paranoid_free(command);
	521	paranoid_free(tmp);
[1]	522	}
	523
	524
	525	/**
	526	* Log a message to the screen.
	527	* @param fmt A printf-style format string to write. The following parameters are its arguments.
	528	* @note The message is also written to the logfile.
	529	*/
[128]	530	void
	531	log_to_screen(const char *fmt, ...) {
[1]	532
[128]	533	/@ int ************************************************************* */
	534	int i = 0;
	535	int j = 0;
	536	va_list args;
[1]	537
[128]	538	/@ buffers ********************************************************* */
	539	char *output;
[1]	540
[128]	541	malloc_string(output);
[1]	542
[128]	543	va_start(args, fmt);
	544	vsprintf(output, fmt, args);
	545	log_msg(0, output);
	546	output[80] = '\0';
	547	va_end(args);
	548	i = (int) strlen(output);
	549	if (i > 0 && output[i - 1] < 32) {
	550	output[i - 1] = '\0';
	551	}
[1]	552
[128]	553	if (err_log_lines) {
	554	for (i = 1; i < g_noof_log_lines; i++) {
	555	strcpy(err_log_lines[i - 1],
	556	" ");
	557	strcpy(err_log_lines[i - 1], err_log_lines[i]);
	558	}
	559	}
	560	while (strlen(output) > 0 && output[strlen(output) - 1] < 32) {
	561	output[strlen(output) - 1] = '\0';
	562	}
	563	for (j = 0; j < (int) strlen(output); j++) {
	564	if (output[j] < 32) {
	565	output[j] = ' ';
	566	}
	567	}
	568	if (err_log_lines)
	569	strcpy(err_log_lines[g_noof_log_lines - 1], output);
	570	if (g_text_mode) {
	571	printf("%s\n", output);
	572	} else {
	573	refresh_log_screen();
	574	}
	575	paranoid_free(output);
[1]	576	}
	577
	578
	579
	580
	581	/**
	582	* Write a string to the root window at (@p x, @p y) and also to the logfile.
	583	* @param y The row to write the string to.
	584	* @param x The column to write the string to.
	585	* @param output The string to write.
	586	*/
[128]	587	void
	588	mvaddstr_and_log_it(int y, int x, char *output) {
	589	assert_string_is_neither_NULL_nor_zerolength(output);
	590	log_msg(0, output);
	591	if (g_text_mode) {
	592	printf("%s\n", output);
	593	} else {
	594	newtDrawRootText(x, y, output);
	595	newtRefresh();
	596	}
	597	}
[1]	598
	599
	600
	601
	602	/**
	603	* Open an evalcall form with title @p ttl.
	604	* @param ttl The title to use for the evalcall form.
	605	*/
[128]	606	void
	607	open_evalcall_form(char *ttl) {
[1]	608
[128]	609	/@ buffers ******************************************************** */
	610	char *title;
	611	char *tmp;
[1]	612
[128]	613	/@ initialize ***************************************************** */
	614	g_isoform_old_progress = -1;
	615	g_mysterious_dot_counter = 0;
	616	malloc_string(title);
	617	malloc_string(tmp);
[1]	618
[128]	619	assert(ttl != NULL);
	620	strcpy(title, ttl);
	621	strcpy(g_isoform_header_str, title);
[1]	622	// center_string (title, 80);
[128]	623	if (g_text_mode) {
	624	log_msg(0, title);
	625	} else {
	626	strcpy(tmp, title);
	627	center_string(tmp, 80);
	628	newtPushHelpLine(tmp);
	629	}
	630	center_string(g_isoform_header_str, 36);
	631	g_isoform_starttime = get_time();
	632	if (g_text_mode) {
	633	log_msg(0, g_isoform_header_str);
	634	} else {
	635	g_isoform_header = newtLabel(1, 1, g_isoform_header_str);
	636	g_isoform_scale = newtScale(3, 3, 34, 100);
	637	// newtOpenWindow (20, 6, 40, 7, title); // "Please Wait");
	638	newtCenteredWindow(40, 7, title);
	639	g_isoform_main = newtForm(NULL, NULL, 0);
	640	g_isoform_timeline = newtLabel(1, 5, "This is the timeline");
	641	g_isoform_pcline = newtLabel(1, 6, "This is the pcline");
	642	newtFormAddComponents(g_isoform_main, g_isoform_timeline,
	643	g_isoform_pcline, g_isoform_header,
	644	g_isoform_scale, NULL);
	645	newtRefresh();
	646	}
	647	update_evalcall_form(0);
	648	paranoid_free(tmp);
	649	paranoid_free(title);
	650	}
[1]	651
	652
	653
	654	/**
	655	* Open a progress form with title @p title.
	656	* @param title The title to use for the progress form (will be put in the title bar on Newt).
	657	* @param b1 The first line of the blurb; generally static.
	658	* @param b2 The second line of the blurb; generally static.
	659	* @param b3 The third line of the blurb; generally dynamic (it is passed
	660	* to update_evalcall_form() every time).
	661	* @param max_val The maximum amount of progress (number of filesets, etc.)
	662	*/
[128]	663	void
	664	open_progress_form(char title, char b1, char b2, char b3,
	665	long max_val) {
[1]	666
[128]	667	/@ buffers ******************************************************** */
	668	char *b1c;
	669	char *blurb1;
	670	char *blurb2;
	671	char *blurb3;
[1]	672
[128]	673	/@ initialize ***************************************************** */
	674	g_mysterious_dot_counter = 0;
[1]	675
[128]	676	malloc_string(b1c);
	677	malloc_string(blurb1);
	678	malloc_string(blurb2);
	679	malloc_string(blurb3);
[1]	680
[128]	681	assert(title != NULL);
	682	assert(b1 != NULL);
	683	assert(b2 != NULL);
	684	assert(b3 != NULL);
[1]	685
[128]	686	strcpy(blurb1, b1);
	687	strcpy(blurb2, b2);
	688	strcpy(blurb3, b3);
	689	strcpy(b1c, b1);
	690	center_string(b1c, 80);
	691	if (max_val <= 0) {
	692	max_val = 1;
	693	}
[1]	694
[128]	695	g_start_time = get_time();
	696	g_maximum_progress = max_val;
	697	g_current_progress = 0;
	698	strcpy(g_blurb_str_1, blurb1);
	699	strcpy(g_blurb_str_2, blurb3);
	700	strcpy(g_blurb_str_3, blurb2);
	701	if (g_text_mode) {
	702	log_msg(0, blurb1);
	703	log_msg(0, blurb2);
	704	log_msg(0, blurb3);
	705	} else {
	706	g_blurb1 = newtLabel(2, 1, blurb1);
	707	g_blurb2 = newtLabel(2, 2, blurb3);
	708	g_blurb3 = newtLabel(2, 4, blurb2);
	709	// newtOpenWindow (10, 4, 60, 11, title);
	710	newtCenteredWindow(60, 11, title);
	711	g_scale = newtScale(3, 6, 54, g_maximum_progress);
	712	g_progressForm = newtForm(NULL, NULL, 0);
	713	g_percentline = newtLabel(10, 9, "This is the percentline");
	714	g_timeline = newtLabel(10, 8, "This is the timeline");
	715	newtFormAddComponents(g_progressForm, g_percentline,
	716	g_timeline, g_scale, g_blurb1, g_blurb3,
	717	g_blurb2, NULL);
	718	newtPushHelpLine(b1c);
	719	newtRefresh();
	720	}
	721	update_progress_form_full(blurb1, blurb2, blurb3);
	722	paranoid_free(b1c);
	723	paranoid_free(blurb1);
	724	paranoid_free(blurb2);
	725	paranoid_free(blurb3);
	726	}
	727
[1]	728	/**
	729	* Give a message to the user in the form of a dialog box (under Newt).
	730	* @param prompt The message.
	731	*/
[128]	732	void
	733	popup_and_OK(char *prompt) {
	734	char ch;
[1]	735
[128]	736	assert_string_is_neither_NULL_nor_zerolength(prompt);
[1]	737
[128]	738	log_msg(0, prompt);
	739	if (g_text_mode) {
	740	printf
[1899]	741	("---promptpopup---1--- %s\n---promptpopup---Q--- [OK] ---\n--> ",
[128]	742	prompt);
	743	while (((ch = getchar()) != '\n') && (ch != EOF));
	744	} else {
[541]	745	(void) popup_with_buttons(prompt, " OK ", "");
[128]	746	}
	747	}
[1]	748
	749	/**
	750	* Ask the user to enter a value.
	751	* @param title The title of the dialog box.
	752	* @param b The blurb (e.g. what you want the user to enter).
	753	* @param output The string to put the user's answer in.
	754	* @param maxsize The size in bytes allocated to @p output.
	755	* @return TRUE if the user pressed OK, FALSE if they pressed Cancel.
	756	*/
[128]	757	bool popup_and_get_string(char title, char b, char *output,
	758	int maxsize) {
[1]	759
[128]	760	/@ newt *********************************************************** */
	761	newtComponent myForm;
	762	newtComponent b_1;
	763	newtComponent b_2;
	764	newtComponent b_res;
	765	newtComponent text;
	766	newtComponent type_here;
[1]	767
[128]	768	/@ pointers ******************************************************** */
	769	char *entry_value;
[1]	770
[128]	771	/@ buffers ********************************************************* */
	772	char *blurb;
	773	char *original_contents;
[1]	774
[128]	775	blurb = malloc(MAX_NEWT_COMMENT_LEN);
	776	original_contents = malloc(MAX_NEWT_COMMENT_LEN);
	777	assert_string_is_neither_NULL_nor_zerolength(title);
	778	assert(b != NULL);
	779	assert(output != NULL);
[1]	780
[128]	781	if (g_text_mode) {
	782	printf
[1899]	783	("---promptstring---1--- %s\n---promptstring---2--- %s\n---promptstring---Q---\n--> ",
[128]	784	title, b);
	785	(void) fgets(output, maxsize, stdin);
	786	if (output[strlen(output) - 1] == '\n')
	787	output[strlen(output) - 1] = '\0';
	788	paranoid_free(blurb);
	789	paranoid_free(original_contents);
	790	return (TRUE);
	791	}
	792	strcpy(blurb, b);
	793	text = newtTextboxReflowed(2, 1, blurb, 48, 5, 5, 0);
	794	strcpy(original_contents, output);
	795	output[0] = '\0';
	796	type_here =
	797	newtEntry(2, newtTextboxGetNumLines(text) + 2,
	798	original_contents, 50,
[1]	799	#ifdef __cplusplus
[128]	800	0, NEWT_FLAG_RETURNEXIT
[1]	801	#else
[128]	802	(void *) &entry_value, NEWT_FLAG_RETURNEXIT
[1]	803	#endif
[128]	804	);
[541]	805	b_1 = newtButton(6, newtTextboxGetNumLines(text) + 4, " OK ");
	806	b_2 = newtButton(18, newtTextboxGetNumLines(text) + 4, "Cancel");
[128]	807	// newtOpenWindow (8, 5, 54, newtTextboxGetNumLines (text) + 9, title);
	808	newtCenteredWindow(54, newtTextboxGetNumLines(text) + 9, title);
	809	myForm = newtForm(NULL, NULL, 0);
	810	newtFormAddComponents(myForm, text, type_here, b_1, b_2, NULL);
	811	center_string(blurb, 80);
	812	newtPushHelpLine(blurb);
	813	b_res = newtRunForm(myForm);
	814	strcpy(output, entry_value);
	815	newtPopHelpLine();
	816	newtFormDestroy(myForm);
	817	newtPopWindow();
	818	if (b_res == b_2) {
	819	strcpy(output, original_contents);
	820	paranoid_free(blurb);
	821	paranoid_free(original_contents);
	822	return (FALSE);
	823	} else {
	824	paranoid_free(blurb);
	825	paranoid_free(original_contents);
	826	return (TRUE);
	827	}
	828	}
[1]	829
	830
	831	/**
	832	* Pop up a dialog box with user-defined buttons.
	833	* @param p The text to put in the dialog box.
	834	* @param button1 The label on the first button.
	835	* @param button2 The label on the second button, or "" if you only want one button.
	836	* @return TRUE if @p button1 was pushed, FALSE otherwise.
	837	*/
[128]	838	bool popup_with_buttons(char p, char button1, char *button2) {
[1]	839
[128]	840	/@ buffers ********************************************************** */
[2136]	841	char *prompt;
[1]	842
[128]	843	/@ newt ************************************************************* */
	844	newtComponent myForm;
	845	newtComponent b_1;
	846	newtComponent b_2;
	847	newtComponent b_res;
	848	newtComponent text;
[1]	849
[128]	850	assert_string_is_neither_NULL_nor_zerolength(p);
	851	assert(button1 != NULL);
	852	assert(button2 != NULL);
[2136]	853	prompt = malloc(MAX_NEWT_COMMENT_LEN);
[128]	854	if (g_text_mode) {
	855	if (strlen(button2) == 0) {
	856	printf("%s (%s) --> ", p, button1);
	857	} else {
	858	printf("%s (%s or %s) --> ", p, button1, button2);
	859	}
[2136]	860	for (prompt[0] = '\0';
	861	strcmp(prompt, button1) && (strlen(button2) == 0
	862	\|\| strcmp(prompt, button2));) {
[128]	863	printf("--> ");
[2136]	864	(void) fgets(prompt, MAX_NEWT_COMMENT_LEN, stdin);
[128]	865	}
[2136]	866	if (!strcmp(prompt, button1)) {
[128]	867	paranoid_free(prompt);
	868	return (TRUE);
	869	} else {
	870	paranoid_free(prompt);
	871	return (FALSE);
	872	}
	873	}
[1]	874
[877]	875	strncpy(prompt, p, MAX_NEWT_COMMENT_LEN - 1);
[883]	876	prompt[MAX_NEWT_COMMENT_LEN - 1] = '\0';
[128]	877	text = newtTextboxReflowed(1, 1, prompt, 40, 5, 5, 0);
	878	b_1 =
	879	newtButton(20 -
	880	((button2[0] !=
	881	'\0') ? strlen(button1) +
	882	2 : strlen(button1) / 2),
	883	newtTextboxGetNumLines(text) + 3, button1);
	884	if (button2[0] != '\0') {
	885	b_2 =
	886	newtButton(24, newtTextboxGetNumLines(text) + 3, button2);
	887	} else {
	888	b_2 = NULL;
	889	}
	890	// newtOpenWindow (25, 5, 46, newtTextboxGetNumLines (text) + 7, "Alert");
[541]	891	newtCenteredWindow(46, newtTextboxGetNumLines(text) + 7, "Alert");
[128]	892	myForm = newtForm(NULL, NULL, 0);
	893	newtFormAddComponents(myForm, text, b_1, b_2, NULL);
	894	center_string(prompt, 80);
	895	newtPushHelpLine(prompt);
	896	b_res = newtRunForm(myForm);
	897	newtPopHelpLine();
	898	newtFormDestroy(myForm);
	899	newtPopWindow();
	900	if (b_res == b_1) {
	901	paranoid_free(prompt);
	902	return (TRUE);
	903	} else {
	904	paranoid_free(prompt);
	905	return (FALSE);
	906	}
	907	}
[1]	908
	909
	910
[128]	911
[1]	912	/**
	913	* Synchronize the log messages stored in @p err_log_lines with those shown
	914	* on the screen.
	915	*/
[128]	916	void
	917	refresh_log_screen() {
[1]	918
[128]	919	/@ int ********************************************************** */
	920	int i = 0;
[1]	921
	922
[128]	923	if (g_text_mode \|\| !err_log_lines) {
	924	return;
	925	}
	926	for (i = g_noof_log_lines - 1; i >= 0; i--) {
	927	newtDrawRootText(0, i + g_noof_rows - 1 - g_noof_log_lines,
	928	" ");
	929	}
	930	newtRefresh();
	931	for (i = g_noof_log_lines - 1; i >= 0; i--) {
	932	err_log_lines[i][79] = '\0';
	933	newtDrawRootText(0, i + g_noof_rows - 1 - g_noof_log_lines,
	934	err_log_lines[i]);
	935	}
	936	newtRefresh();
	937	}
[1]	938
	939
	940	/**
	941	* Set up the Newt graphical environment. If @p g_text_mode is TRUE, then
	942	* only allocate some memory.
	943	*/
[128]	944	void
	945	setup_newt_stuff() {
[1]	946
[128]	947	/@ int ********************************************************** */
	948	int i = 0;
	949	int cols;
[1]	950
[128]	951	if (!g_text_mode) {
	952	newtInit();
	953	newtCls();
	954	newtPushHelpLine
[585]	955	("Welcome to Mondo Rescue, by Dev Team and the Internet. All rights reversed.");
[128]	956	/* newtDrawRootText(28,0,"Welcome to Mondo Rescue"); */
	957	newtDrawRootText(18, 0, WELCOME_STRING);
	958	newtRefresh();
	959	newtGetScreenSize(&cols, &g_noof_rows);
	960	g_noof_log_lines = (g_noof_rows / 5) + 1;
	961	}
[1]	962
[128]	963	err_log_lines =
	964	(char *) malloc(sizeof(char ) * g_noof_log_lines);
	965	if (!err_log_lines) {
	966	fatal_error("Out of memory");
	967	}
[1]	968
[128]	969	for (i = 0; i < g_noof_log_lines; i++) {
	970	err_log_lines[i] = (char *) malloc(MAX_NEWT_COMMENT_LEN);
	971	if (!err_log_lines[i]) {
	972	fatal_error("Out of memory");
	973	}
	974	}
[1]	975
[128]	976	for (i = 0; i < g_noof_log_lines; i++) {
	977	err_log_lines[i][0] = '\0';
	978	}
	979	}
[1]	980
	981
	982	/**
	983	* Update the evalcall form to show (<tt>num</tt>/<tt>denom</tt>)*100 %.
	984	* @param num The numerator of the ratio.
	985	* @param denom The denomenator of the ratio.
	986	*/
[128]	987	void
	988	update_evalcall_form_ratio(int num, int denom) {
[1]	989
[128]	990	/@ long *********************************************************** */
	991	long current_time = 0;
	992	long time_taken = 0;
	993	long time_total_est = 0;
	994	long time_remaining = 0;
[1]	995
[128]	996	/@ buffers ********************************************************* */
	997	char *timeline_str;
[2211]	998	char *pcline_str = NULL;
	999	char *taskprogress = NULL;
[1]	1000
[128]	1001	/@ int ************************************************************* */
	1002	int percentage = 0;
	1003	int i = 0;
	1004	int j = 0;
[1]	1005
[128]	1006	malloc_string(timeline_str);
	1007	timeline_str[0] = '\0';
[1]	1008	// log_it("update_eval_call_form called");
[128]	1009	if (num * 100 < denom) {
	1010	percentage = 1;
	1011	} else {
	1012	percentage = (num * 100 + denom / 2) / denom;
	1013	}
	1014
	1015	current_time = get_time();
	1016	time_taken = current_time - g_isoform_starttime;
	1017	if (num) {
	1018	time_total_est = time_taken * denom / num;
	1019	time_remaining = time_total_est - time_taken;
	1020	} else {
	1021	time_remaining = 0;
	1022	}
	1023	if (!g_text_mode) {
[1899]	1024	if (g_isoform_header) {
	1025	newtLabelSetText(g_isoform_header, g_isoform_header_str);
	1026	}
[128]	1027	}
	1028	g_mysterious_dot_counter = (g_mysterious_dot_counter + 1) % 27;
	1029	if ((percentage < 3 && g_isoform_old_progress < 3)
	1030	\|\| percentage > g_isoform_old_progress) {
	1031	g_isoform_old_progress = percentage;
	1032	sprintf(timeline_str,
[541]	1033	"%2ld:%02ld taken %2ld:%02ld remaining",
[2374]	1034	(long) time_taken / 60, (long) time_taken % 60, (long) time_remaining / 60,
	1035	(long) time_remaining % 60);
[128]	1036	if (percentage < 3) {
[2211]	1037	mr_asprintf(&pcline_str, " Working");
[128]	1038	for (j = 0; j < g_mysterious_dot_counter; j++) {
[2211]	1039	mr_strcat(pcline_str, ".");
[128]	1040	}
	1041	for (; j < 27; j++) {
[2211]	1042	mr_strcat(pcline_str, " ");
[128]	1043	}
[2211]	1044	mr_strcat(pcline_str, " %c", special_dot_char(g_mysterious_dot_counter));
[128]	1045	} else {
[2211]	1046	mr_asprintf(&pcline_str, " %3d%% done %3d%% to go",
[128]	1047	percentage, 100 - percentage);
	1048	}
	1049	if (g_text_mode) {
[2211]	1050	mr_asprintf(&taskprogress, "TASK: [");
[128]	1051	for (i = 0; i < percentage; i += 5) {
[2211]	1052	mr_strcat(taskprogress, "*");
[128]	1053	}
	1054	for (; i < 100; i += 5) {
[2211]	1055	mr_strcat(taskprogress, ".");
[128]	1056	}
	1057	if (percentage >= 3) {
[2211]	1058	mr_strcat(taskprogress, "] %3d%% done; %2ld:%02ld to go", percentage,
[2374]	1059	(long) time_remaining / 60, (long) time_remaining % 60);
[1899]	1060	printf("---evalcall---1--- %s\n",
[128]	1061	g_isoform_header_str);
[1899]	1062	printf("---evalcall---2--- %s\n", taskprogress);
	1063	printf("---evalcall---E---\n");
[128]	1064	}
[2211]	1065	paranoid_free(taskprogress);
[128]	1066	} else {
	1067	newtScaleSet(g_isoform_scale,
	1068	(unsigned long long) percentage);
[1899]	1069	if (g_isoform_pcline) {
	1070	newtLabelSetText(g_isoform_pcline, pcline_str);
	1071	}
	1072	if ((percentage >= 3) && (g_isoform_timeline)) {
[128]	1073	newtLabelSetText(g_isoform_timeline, timeline_str);
	1074	}
	1075	}
[2211]	1076	paranoid_free(pcline_str);
[128]	1077	}
	1078	if (!g_text_mode) {
	1079	// log_it("refreshing");
	1080	newtRefresh();
	1081	}
	1082	paranoid_free(timeline_str);
[1]	1083	}
	1084
	1085
	1086
	1087	/**
	1088	* Update the evalcall form to show @p curr %.
	1089	* @param curr The current amount of progress (percentage) in the evalcall form.
	1090	*/
[128]	1091	void
	1092	update_evalcall_form(int curr) {
	1093	update_evalcall_form_ratio(curr, 100);
	1094	}
[1]	1095
	1096
	1097
	1098	/**
	1099	* Update the progress form to show @p blurb3 and the current value of
	1100	* @p g_maximum_progress.
	1101	* @param blurb3 The new third line of the blurb; use @p g_blurb_str_2 (no, that's not a typo) to keep it the same.
	1102	*/
[128]	1103	void
	1104	update_progress_form(char *blurb3) {
	1105	/* log_it("update_progress_form --- called"); */
	1106	if (g_current_progress == -999) {
	1107	/* log_it("You're trying to update progress form when it ain't open. Aww, that's OK. I'll let it go. It's a bit naughty but it's a nonfatal error. No prob, Bob."); */
	1108	return;
	1109	}
	1110	strcpy(g_blurb_str_2, blurb3);
	1111	update_progress_form_full(g_blurb_str_1, g_blurb_str_2,
	1112	g_blurb_str_3);
	1113	}
[1]	1114
	1115
	1116	/**
	1117	* Update the progress form's complete blurb and show @p g_current_progress.
	1118	* @param blurb1 The first line of the blurb. Use @p g_blurb_str_1 to keep it unchanged.
	1119	* @param blurb2 The second line of the blurb. Use @p g_blurb_str_3 (no, that's not a typo) to keep it the same.
	1120	* @param blurb3 The third line of the blurb. Use @p g_blurb_str_2 (no, that's not a typo either) to keep it the same.
	1121	*/
[128]	1122	void
	1123	update_progress_form_full(char blurb1, char blurb2, char *blurb3) {
	1124	/@ long **************************************************** */
[2374]	1125	long current_time = 0L;
	1126	long time_taken = 0L;
	1127	long time_remaining = 0L;
	1128	long time_total_est = 0L;
[1]	1129
[128]	1130	/@ int ****************************************************** */
	1131	int percentage = 0;
	1132	int i = 0;
[1]	1133
[128]	1134	/@ buffers ************************************************** */
	1135	char *percentline_str;
	1136	char *timeline_str;
[2211]	1137	char *taskprogress = NULL;
[128]	1138	char *tmp;
[1]	1139
	1140	// log_msg(1, "'%s' '%s' '%s'", blurb1, blurb2, blurb3);
[128]	1141	percentline_str = malloc(MAX_NEWT_COMMENT_LEN);
	1142	timeline_str = malloc(MAX_NEWT_COMMENT_LEN);
	1143	malloc_string(tmp);
	1144	if (!g_text_mode) {
	1145	assert(blurb1 != NULL);
	1146	assert(blurb2 != NULL);
	1147	assert(blurb3 != NULL);
	1148	assert(g_timeline != NULL);
	1149	}
[1]	1150
[128]	1151	percentline_str[0] = '\0';
[1]	1152
[128]	1153	current_time = get_time();
	1154	time_taken = current_time - g_start_time;
	1155	if (g_maximum_progress == 0) {
	1156	percentage = 0;
	1157	} else {
	1158	if (g_current_progress > g_maximum_progress) {
	1159	sprintf(tmp,
	1160	"update_progress_form_full(%s,%s,%s) --- g_current_progress=%ld; g_maximum_progress=%ld",
	1161	blurb1, blurb2, blurb3, g_current_progress,
	1162	g_maximum_progress);
	1163	log_msg(0, tmp);
	1164	g_current_progress = g_maximum_progress;
	1165	}
	1166	percentage =
	1167	(int) ((g_current_progress * 100L) / g_maximum_progress);
	1168	}
	1169	if (percentage < 1) {
	1170	percentage = 1;
	1171	}
	1172	if (percentage > 100) {
	1173	percentage = 100;
	1174	}
	1175	if (g_current_progress) {
	1176	time_total_est =
	1177	time_taken * (long) g_maximum_progress /
	1178	(long) (g_current_progress);
	1179	time_remaining = time_total_est - time_taken;
	1180	} else {
[2374]	1181	time_remaining = 0L;
[128]	1182	}
	1183	g_mysterious_dot_counter = (g_mysterious_dot_counter + 1) % 27;
	1184	sprintf(timeline_str,
	1185	"%2ld:%02ld taken %2ld:%02ld remaining ",
[2374]	1186	(long) time_taken / 60, time_taken % 60, time_remaining / 60,
[128]	1187	time_remaining % 60);
	1188	sprintf(percentline_str, " %3d%% done %3d%% to go",
	1189	percentage, 100 - percentage);
[1]	1190
[128]	1191	if (g_text_mode) {
[1899]	1192	printf("---progress-form---1--- %s\n", blurb1);
	1193	printf("---progress-form---2--- %s\n", blurb2);
	1194	printf("---progress-form---3--- %s\n", blurb3);
[541]	1195	printf("---progress-form---E---\n");
[2211]	1196	mr_asprintf(&taskprogress, "TASK: [");
[128]	1197	for (i = 0; i < percentage; i += 5) {
[2211]	1198	mr_strcat(taskprogress, "*");
[128]	1199	}
	1200	for (; i < 100; i += 5) {
[2211]	1201	mr_strcat(taskprogress, ".");
[128]	1202	}
	1203	if (percentage > 100) {
[541]	1204	log_msg(2, "percentage = %d", percentage);
[128]	1205	}
[2374]	1206	mr_strcat(taskprogress, "] %3d%%", percentage);
[2211]	1207	mr_strcat(taskprogress, " done; %2ld:%02ld to go",
[2374]	1208	(long) time_remaining / 60, (long) time_remaining % 60);
[1899]	1209	printf("---progress-form---4--- %s\n", taskprogress);
[2211]	1210	paranoid_free(taskprogress);
[128]	1211	} else {
	1212	center_string(blurb1, 54);
	1213	center_string(blurb2, 54);
	1214	center_string(blurb3, 54);
[1899]	1215	if (g_blurb1) {
	1216	newtLabelSetText(g_blurb1, blurb1);
	1217	}
	1218	if (g_blurb2) {
	1219	newtLabelSetText(g_blurb2, blurb3);
	1220	}
	1221	if (g_blurb3) {
	1222	newtLabelSetText(g_blurb3, blurb2);
	1223	}
[128]	1224	newtScaleSet(g_scale, (unsigned long long) g_current_progress);
[1899]	1225	if ((percentage >= 2) && (g_timeline)) {
[128]	1226	newtLabelSetText(g_timeline, timeline_str);
	1227	}
[1899]	1228	if (g_percentline) {
	1229	newtLabelSetText(g_percentline, percentline_str);
	1230	}
[128]	1231	newtRefresh();
	1232	}
	1233	paranoid_free(percentline_str);
	1234	paranoid_free(timeline_str);
	1235	paranoid_free(tmp);
[1]	1236	}
	1237
	1238
	1239
	1240
	1241
	1242
	1243
	1244
	1245
	1246
	1247
	1248
	1249
	1250
	1251	/**
	1252	* Ask the user which backup media type they would like to use.
	1253	* The choices are @p none (exit to shell), @c cdr, @c cdrw, @c dvd,
	1254	* @c tape, @c cdstream, @c udev (only when @p g_text_mode is TRUE), @c nfs,
	1255	* and @c iso.
	1256	* @param restoring TRUE if we're restoring, FALSE if we're backing up.
	1257	* @return The backup type chosen, or @c none if the user chose "Exit to shell".
	1258	*/
[128]	1259	t_bkptype which_backup_media_type(bool restoring) {
[1]	1260
[128]	1261	/@ char *********************************************************** */
	1262	t_bkptype output;
[1]	1263
	1264
[128]	1265	/@ newt *********************************************************** */
	1266	char *title_sz;
	1267	char *minimsg_sz;
	1268	static t_bkptype possible_bkptypes[] =
	1269	{ none, cdr, cdrw, dvd, tape, cdstream, udev, nfs, iso };
	1270	static char *possible_responses[] =
	1271	{ "none", "cdr", "cdrw", "dvd", "tape", "cdstream", "udev",
	1272	"nfs", "iso", NULL };
	1273	char *outstr;
	1274	t_bkptype backup_type;
	1275	int i;
[1]	1276
[128]	1277	newtComponent b1;
	1278	newtComponent b2;
	1279	newtComponent b3;
	1280	newtComponent b4;
	1281	newtComponent b5;
	1282	newtComponent b6;
	1283	newtComponent b7;
	1284	newtComponent b8;
	1285	newtComponent b_res;
	1286	newtComponent myForm;
[1]	1287
[128]	1288	title_sz = malloc(MAX_NEWT_COMMENT_LEN);
	1289	minimsg_sz = malloc(MAX_NEWT_COMMENT_LEN);
	1290	outstr = malloc(MAX_NEWT_COMMENT_LEN);
	1291	if (g_text_mode) {
	1292	for (backup_type = none; backup_type == none;) {
[541]	1293	printf("Backup type (");
[128]	1294	for (i = 0; possible_responses[i]; i++) {
	1295	printf("%c%s", (i == 0) ? '\0' : ' ',
	1296	possible_responses[i]);
	1297	}
	1298	printf(")\n--> ");
	1299	(void) fgets(outstr, MAX_NEWT_COMMENT_LEN, stdin);
	1300	strip_spaces(outstr);
	1301	for (i = 0; possible_responses[i]; i++) {
	1302	if (!strcmp(possible_responses[i], outstr)) {
	1303	backup_type = possible_bkptypes[i];
	1304	}
	1305	}
	1306	}
	1307	paranoid_free(title_sz);
	1308	paranoid_free(minimsg_sz);
	1309	paranoid_free(outstr);
	1310	return (backup_type);
	1311	}
	1312	newtDrawRootText(18, 0, WELCOME_STRING);
	1313	if (restoring) {
	1314	strcpy(title_sz,
[541]	1315	"Please choose the backup media from which you want to read data.");
	1316	strcpy(minimsg_sz, "Read from:");
[128]	1317	} else {
	1318	strcpy(title_sz,
[541]	1319	"Please choose the backup media to which you want to archive data.");
	1320	strcpy(minimsg_sz, "Backup to:");
[128]	1321	}
	1322	newtPushHelpLine(title_sz);
	1323	// newtOpenWindow (23, 3, 34, 17, minimsg_sz);
	1324	newtCenteredWindow(34, 17, minimsg_sz);
[541]	1325	b1 = newtButton(1, 1, "CD-R disks ");
	1326	b2 = newtButton(17, 1, "CD-RW disks");
	1327	b3 = newtButton(1, 9, "Tape drive ");
[1703]	1328	b4 = newtButton(17, 5, "USB Key/Disk");
[541]	1329	b5 = newtButton(1, 5, " DVD disks ");
	1330	b6 = newtButton(17, 9, " NFS mount ");
	1331	b7 = newtButton(1, 13, " Hard disk ");
	1332	b8 = newtButton(17, 13, " Exit ");
[128]	1333	myForm = newtForm(NULL, NULL, 0);
	1334	newtFormAddComponents(myForm, b1, b5, b3, b7, b2, b4, b6, b8,
	1335	NULL);
	1336	b_res = newtRunForm(myForm);
	1337	newtFormDestroy(myForm);
	1338	newtPopWindow();
	1339	if (b_res == b1) {
	1340	output = cdr;
	1341	} else if (b_res == b2) {
	1342	output = cdrw;
	1343	} else if (b_res == b3) {
	1344	output = tape;
	1345	} else if (b_res == b4) {
[1703]	1346	output = usb;
[128]	1347	} else if (b_res == b5) {
	1348	output = dvd;
	1349	} else if (b_res == b6) {
	1350	output = nfs;
	1351	} else if (b_res == b7) {
	1352	output = iso;
	1353	} else {
	1354	output = none;
	1355	}
	1356	newtPopHelpLine();
	1357	paranoid_free(title_sz);
	1358	paranoid_free(minimsg_sz);
	1359	paranoid_free(outstr);
	1360	return (output);
	1361	}
[1]	1362
	1363
	1364
	1365
	1366	/**
	1367	* Ask the user how much compression they would like to use.
	1368	* The choices are "None" (0), "Minimum" (1), "Average" (4), and "Maximum" (9).
	1369	* @return The compression level (0-9) chosen, or -1 for "Exit".
	1370	*/
[128]	1371	int
	1372	which_compression_level() {
[1]	1373
[128]	1374	/@ char *********************************************************** */
	1375	int output = none;
[1]	1376
	1377
[128]	1378	/@ newt *********************************************************** */
[1]	1379
[128]	1380	newtComponent b1;
	1381	newtComponent b2;
	1382	newtComponent b3;
	1383	newtComponent b4;
	1384	newtComponent b5;
	1385	newtComponent b_res;
	1386	newtComponent myForm;
[1]	1387
[128]	1388	newtDrawRootText(18, 0, WELCOME_STRING);
	1389	newtPushHelpLine
[541]	1390	(" Please specify the level of compression that you want.");
[128]	1391	// newtOpenWindow (23, 3, 34, 13, "How much compression?");
[541]	1392	newtCenteredWindow(34, 13, "How much compression?");
	1393	b1 = newtButton(4, 1, "Maximum");
	1394	b2 = newtButton(18, 1, "Average");
[1463]	1395	b3 = newtButton(4, 5, "Minimum");
[541]	1396	b4 = newtButton(18, 5, " None ");
	1397	b5 = newtButton(4, 9, " Exit ");
[128]	1398	myForm = newtForm(NULL, NULL, 0);
	1399	newtFormAddComponents(myForm, b1, b3, b2, b4, b5, NULL);
	1400	b_res = newtRunForm(myForm);
	1401	newtFormDestroy(myForm);
	1402	newtPopWindow();
	1403	if (b_res == b1) {
	1404	output = 9;
	1405	} else if (b_res == b2) {
	1406	output = 4;
	1407	} else if (b_res == b3) {
	1408	output = 1;
	1409	} else if (b_res == b4) {
	1410	output = 0;
	1411	} else if (b_res == b5) {
	1412	output = -1;
	1413	}
	1414	newtPopHelpLine();
	1415	return (output);
	1416	}
[1]	1417
	1418
	1419
	1420
	1421
	1422	/**
	1423	* Load @p source_file (a list of files) into @p filelist. There can be no more than
	1424	* @p ARBITRARY_MAXIMUM entries.
	1425	* @param filelist The filelist structure to load @p source_file into.
	1426	* @param source_file The file containing a list of filenames to load into @p filelist.
	1427	*/
[128]	1428	int load_filelist_into_array(struct s_filelist *filelist,
	1429	char *source_file) {
	1430	int i;
[1662]	1431	int j = 0;
[128]	1432	bool done;
	1433	char *tmp;
[1662]	1434	char *tmp1 = NULL;
	1435	FILE fin, fout;
[128]	1436	struct s_filelist_entry dummy_fle;
[1]	1437
[128]	1438	assert(filelist != NULL);
	1439	assert_string_is_neither_NULL_nor_zerolength(source_file);
[1]	1440
[2230]	1441	log_it("entering");
[128]	1442	if (!(fin = fopen(source_file, "r"))) {
	1443	log_OS_error(source_file);
	1444	log_msg(2, "Can't open %s; therefore, cannot popup list",
	1445	source_file);
	1446	return (1);
	1447	}
[1662]	1448
[2211]	1449	mr_asprintf(&tmp1,"%s/icantfindthesefiles.txt",bkpinfo->tmpdir);
[1662]	1450	if (!(fout = fopen(tmp1, "a"))) {
	1451	log_msg(2, "Can't write to %s", tmp1);
	1452	return(1);
	1453	}
	1454
	1455	malloc_string(tmp);
[128]	1456	log_msg(2, "Loading %s", source_file);
	1457	for (filelist->entries = 0; filelist->entries <= ARBITRARY_MAXIMUM;
	1458	filelist->entries++) {
	1459	god_i_hate_gotos:
	1460	if (feof(fin)) {
	1461	break;
	1462	}
	1463	(void) fgets(tmp, MAX_NEWT_COMMENT_LEN, fin);
	1464	i = (int) strlen(tmp);
	1465	if (i < 2) {
	1466	goto god_i_hate_gotos;
	1467	}
	1468	if (tmp[i - 1] < 32) {
	1469	tmp[--i] = '\0';
	1470	}
	1471	if (i < 2) {
	1472	goto god_i_hate_gotos;
	1473	}
[1662]	1474	if (!does_file_exist(tmp) && !feof(fin)) {
	1475	j++;
	1476	fprintf(fout, "%s\n", tmp);
	1477
[128]	1478	goto god_i_hate_gotos;
	1479	}
	1480	filelist->el[filelist->entries].severity =
	1481	severity_of_difference(tmp, NULL);
	1482	strcpy(filelist->el[filelist->entries].filename, tmp);
	1483	if (feof(fin)) {
	1484	break;
	1485	}
	1486	}
	1487	paranoid_fclose(fin);
[1662]	1488	paranoid_fclose(fout);
	1489	if (j > 0) {
	1490	log_to_screen("%d files listed in %s/changed.files have been deleted since backup was made\nand are referenced in %s", j, bkpinfo->tmpdir,tmp1);
	1491	}
	1492	paranoid_free(tmp1);
[128]	1493	if (filelist->entries >= ARBITRARY_MAXIMUM) {
[541]	1494	log_to_screen("Arbitrary limits suck, man!");
[128]	1495	paranoid_free(tmp);
	1496	return (1);
	1497	}
	1498	for (done = FALSE; !done;) {
	1499	done = TRUE;
	1500	for (i = 0; i < filelist->entries - 1; i++) {
[1]	1501	// if (strcmp(filelist->el[i].filename, filelist->el[i+1].filename) > 0)
[128]	1502	if (filelist->el[i].severity < filelist->el[i + 1].severity
	1503	\|\| (filelist->el[i].severity ==
	1504	filelist->el[i + 1].severity
	1505	&& strcmp(filelist->el[i].filename,
	1506	filelist->el[i + 1].filename) > 0)) {
	1507	memcpy((void *) &dummy_fle,
	1508	(void *) &(filelist->el[i]),
	1509	sizeof(struct s_filelist_entry));
	1510	memcpy((void *) &(filelist->el[i]),
	1511	(void *) &(filelist->el[i + 1]),
	1512	sizeof(struct s_filelist_entry));
	1513	memcpy((void *) &(filelist->el[i + 1]),
	1514	(void *) &dummy_fle,
	1515	sizeof(struct s_filelist_entry));
	1516	log_msg(2, "Swapping %s and %s",
	1517	filelist->el[i].filename,
	1518	filelist->el[i + 1].filename);
	1519	done = FALSE;
	1520	}
	1521	}
	1522	}
	1523	paranoid_free(tmp);
[2230]	1524	log_it("leaving");
[128]	1525	return (0);
	1526	}
[1]	1527
	1528
	1529
	1530	/**
	1531	* Generate a pretty string based on @p flentry.
	1532	* @param flentry The filelist entry to stringify.
	1533	* @return The string form of @p flentry.
	1534	* @note The returned value points to static storage that will be overwritten with each call.
	1535	*/
[128]	1536	char filelist_entry_to_string(struct s_filelist_entry flentry) {
	1537	static char comment[100];
[2211]	1538	char *tmp = NULL;
[1]	1539
[2230]	1540	log_it("entering");
[128]	1541	assert(flentry != NULL);
	1542	if (flentry->severity == 0) {
[2211]	1543	mr_asprintf(&tmp, "0 ");
[128]	1544	} else if (flentry->severity == 1) {
[2211]	1545	mr_asprintf(&tmp, "low ");
[128]	1546	} else if (flentry->severity == 2) {
[2211]	1547	mr_asprintf(&tmp, "med ");
[128]	1548	} else {
[2211]	1549	mr_asprintf(&tmp, "high");
[128]	1550	}
[2211]	1551	mr_strcat(tmp, " ");
	1552	mr_strcat(tmp, flentry->filename);
	1553	strncpy(comment, tmp, 99);
[128]	1554	paranoid_free(tmp);
[2211]	1555
[2230]	1556	log_it("leaving");
[128]	1557	return (comment);
	1558	}
[1]	1559
	1560
	1561
	1562
	1563
	1564	/**
	1565	* Pop up a list containing the filenames in @p source_file and the severity if they have changed since the
	1566	* last backup. There can be no more than @p ARBITRARY_MAXIMUM files in @p source_file.
	1567	* @param source_file The file containing a list of changed files.
	1568	*/
[128]	1569	void popup_changelist_from_file(char *source_file) {
	1570	char *reason;
	1571	newtComponent myForm;
	1572	newtComponent bClose;
	1573	newtComponent bSelect;
	1574	newtComponent b_res;
	1575	newtComponent fileListbox;
	1576	newtComponent headerMsg;
[1]	1577
[128]	1578	/@ ???? *********************************************************** */
	1579	void *curr_choice;
	1580	void *keylist[ARBITRARY_MAXIMUM];
[1]	1581
[128]	1582	/@ int ************************************************************ */
	1583	int currline = 0;
	1584	int finished = FALSE;
[738]	1585
	1586	/@ long *********************************************************** */
	1587	long i = 0;
[128]	1588	long lng = 0;
[1]	1589
[128]	1590	/@ buffers ******************************************************** */
	1591	char *tmp;
	1592	char *differ_sz;
[1]	1593
[128]	1594	struct s_filelist *filelist;
	1595	malloc_string(reason);
	1596	tmp = malloc(5000);
	1597	malloc_string(differ_sz);
	1598	assert_string_is_neither_NULL_nor_zerolength(source_file);
	1599	if (g_text_mode) {
	1600	log_msg(2, "Text mode. Therefore, no popup list.");
	1601	goto free_to_go;
	1602	}
	1603	log_msg(2, "Examining file %s", source_file);
[1]	1604
[128]	1605	lng = count_lines_in_file(source_file);
	1606	if (lng < 1) {
	1607	log_msg(2, "No lines in file. Therefore, no popup list.");
	1608	paranoid_free(reason);
	1609	goto free_to_go;
	1610	} else if (lng >= ARBITRARY_MAXIMUM) {
	1611	log_msg(2, "Too many files differ for me to list.");
	1612	goto free_to_go;
	1613	}
[1]	1614
[128]	1615	filelist = (struct s_filelist *) malloc(sizeof(struct s_filelist));
	1616	fileListbox =
	1617	newtListbox(2, 2, 12, NEWT_FLAG_SCROLL \| NEWT_FLAG_RETURNEXIT);
	1618	newtListboxClear(fileListbox);
[1]	1619
[128]	1620	if (load_filelist_into_array(filelist, source_file)) {
	1621	log_msg(2, "Can't open %s; therefore, cannot popup list",
	1622	source_file);
	1623	paranoid_free(reason);
	1624	return;
	1625	}
	1626	log_msg(2, "%d files loaded into filelist array",
	1627	filelist->entries);
	1628	for (i = 0; i < filelist->entries; i++) {
	1629	keylist[i] = (void *) i;
	1630	newtListboxAppendEntry(fileListbox,
	1631	filelist_entry_to_string(&
	1632	(filelist->
	1633	el[i])),
	1634	keylist[i]);
	1635	}
	1636	sprintf(differ_sz,
[738]	1637	" %ld files differ. Hit 'Select' to pick a file. Hit 'Close' to quit the list.",
[128]	1638	i);
	1639	newtPushHelpLine(differ_sz);
[541]	1640	bClose = newtCompactButton(10, 15, " Close ");
	1641	bSelect = newtCompactButton(30, 15, " Select ");
	1642	sprintf(tmp, "%-10s %-20s", "Priority", "Filename");
[128]	1643	headerMsg = newtLabel(2, 1, tmp);
[541]	1644	newtOpenWindow(5, 4, 70, 16, "Non-matching files");
[128]	1645	myForm = newtForm(NULL, NULL, 0);
	1646	newtFormAddComponents(myForm, headerMsg, fileListbox, bClose,
	1647	bSelect, NULL);
	1648	while (!finished) {
	1649	b_res = newtRunForm(myForm);
	1650	if (b_res == bClose) {
	1651	finished = TRUE;
	1652	} else {
	1653	curr_choice = newtListboxGetCurrent(fileListbox);
	1654	for (i = 0;
	1655	i < filelist->entries && keylist[i] != curr_choice;
	1656	i++);
	1657	if (i == filelist->entries && filelist->entries > 0) {
[541]	1658	log_to_screen("I don't know what that button does!");
[128]	1659	} else {
	1660	currline = i;
	1661	if (filelist->entries > 0) {
	1662	severity_of_difference(filelist->el[currline].
	1663	filename, reason);
	1664	sprintf(tmp, "%s --- %s",
	1665	filelist->el[currline].filename, reason);
	1666	popup_and_OK(tmp);
	1667	}
	1668	}
	1669	}
	1670	}
	1671	newtFormDestroy(myForm);
	1672	newtPopWindow();
	1673	newtPopHelpLine();
	1674	free_to_go:
	1675	paranoid_free(reason);
	1676	paranoid_free(tmp);
	1677	paranoid_free(differ_sz);
	1678	return;
[1]	1679	}
	1680
	1681	/* @} - end of guiGroup */
	1682
	1683
	1684	#if __cplusplus
[128]	1685	} /* extern "C" */
[1]	1686	#endif
	1687
	1688
[128]	1689	void wait_until_software_raids_are_prepped(char *mdstat_file,
	1690	int wait_for_percentage);

Note: See TracBrowser for help on using the repository browser.

Download in other formats: