Context Navigation

libmondo-archive.c@ 2462

Visit:

Last change on this file since 2462 was 2462, checked in by Bruno Cornec, 15 years ago

r3548@localhost: bruno | 2009-10-16 19:18:27 +0200

mindi now boots in a QEMU VM without busybox
mindi is now noarch as a consequence
MINDI_LIB becomes MINDI_DATA for coherency and as a consequence
CACHEDIR becomes MINDI_CACHE for coherency and it's a build parameter and not hardcoded anymore in mindi
THat variable is also used at restore time for mondorestore.cfg e.g.
FAILSAFE kernel is gone. Just use another kernel of your choice. Most std kernels work anyway
TurnTgzIntoRdz rewritten and now really computes data disk size and not suppose its size
Interface mondo/mindi changed again => incompatible
Non-bootable media not supported anymore.
Mondorescue adapted to these changes but not tested yet
Doc updated as well

Property svn:keywords set to Id

File size: 96.7 KB

Line
1	/* libmondo-archive.c
2	$Id: libmondo-archive.c 2462 2009-10-20 14:07:00Z bruno $
3
4	subroutines to handle the archiving of files
5	*/
6
7	/**
8	* @file
9	* Functions to handle backing up data.
10	* This is the main file (at least the longest one) in libmondo.
11	*/
12
13	#include "my-stuff.h"
14	#include "mr_mem.h"
15	#include "mr_str.h"
16	#include "mondostructures.h"
17	#include "libmondo-string-EXT.h"
18	#include "libmondo-stream-EXT.h"
19	#include "libmondo-devices-EXT.h"
20	#include "libmondo-tools-EXT.h"
21	#include "libmondo-gui-EXT.h"
22	#include "libmondo-fork-EXT.h"
23	#include "libmondo-files-EXT.h"
24	#include "libmondo-filelist-EXT.h"
25	#include "libmondo-tools-EXT.h"
26	#include "libmondo-verify-EXT.h"
27	#include "libmondo-archive.h"
28	#include "lib-common-externs.h"
29	#include <sys/sem.h>
30	#include <sys/types.h>
31	#include <sys/ipc.h>
32	#include <stdarg.h>
33	#define DVDRWFORMAT 1
34
35
36
37	#ifndef _SEMUN_H
38	#define _SEMUN_H
39
40	/**
41	* The semaphore union, provided only in case the user's system doesn't.
42	*/
43	union semun {
44	int val;
45	struct semid_ds *buf;
46	unsigned short int *array;
47	struct seminfo *__buf;
48	};
49	#endif
50
51	/@unused@/
52	//static char cvsid[] = "$Id: libmondo-archive.c 2462 2009-10-20 14:07:00Z bruno $";
53	//
54	extern char get_non_rewind_dev(char );
55
56	/* ************************* external global vars ****************/
57	extern int g_current_media_number;
58	extern int g_currentY;
59	extern bool g_text_mode;
60	extern bool g_exiting;
61	extern long g_current_progress;
62	extern FILE *g_tape_stream;
63	extern long long g_tape_posK;
64	extern bool g_cd_recovery;
65	extern char *g_mondo_home;
66
67	/**
68	* The serial string (used to differentiate between backups) of the current backup.
69	*/
70	char *g_serial_string = NULL;
71
72	extern char *g_getfacl;
73	extern char *g_getfattr;
74	extern char *MONDO_LOGFILE;
75
76	/* Reference to global bkpinfo */
77	extern struct s_bkpinfo *bkpinfo;
78
79
80	/**
81	* @addtogroup globalGroup
82	* @{
83	*/
84	/**
85	* The current backup media type in use.
86	*/
87	t_bkptype g_backup_media_type = none;
88
89	/**
90	* Incremented by each archival thread when it starts up. After that,
91	* this is the number of threads running.
92	*/
93	int g_current_thread_no = 0;
94
95	/* @} - end of globalGroup */
96
97	extern int g_noof_rows;
98
99	/* Semaphore-related code */
100
101	static int set_semvalue(void);
102	static void del_semvalue(void);
103	static int semaphore_p(void);
104	static int semaphore_v(void);
105
106	static int g_sem_id;
107	static int g_sem_key;
108
109	/**
110	* Initialize the semaphore.
111	* @see del_semvalue
112	* @see semaphore_p
113	* @see semaphore_v
114	* @return 1 for success, 0 for failure.
115	*/
116	static int set_semvalue(void) // initializes semaphore
117	{
118	union semun sem_union;
119	sem_union.val = 1;
120	if (semctl(g_sem_id, 0, SETVAL, sem_union) == -1) {
121	return (0);
122	}
123	return (1);
124	}
125
126	/**
127	* Frees (deletes) the semaphore. Failure is indicated by a log
128	* message.
129	* @see set_semvalue
130	*/
131	static void del_semvalue(void) // deletes semaphore
132	{
133	union semun sem_union;
134
135	if (semctl(g_sem_id, 0, IPC_RMID, sem_union) == -1) {
136	log_msg(3, "Failed to delete semaphore");
137	}
138	}
139
140	/**
141	* Acquire (increment) the semaphore (change status to P).
142	* @return 1 for success, 0 for failure.
143	* @see semaphore_v
144	*/
145	static int semaphore_p(void) // changes status to 'P' (waiting)
146	{
147	struct sembuf sem_b;
148
149	sem_b.sem_num = 0;
150	sem_b.sem_op = -1; // P()
151	sem_b.sem_flg = SEM_UNDO;
152	if (semop(g_sem_id, &sem_b, 1) == -1) {
153	log_msg(3, "semaphore_p failed");
154	return (0);
155	}
156	return (1);
157	}
158
159	/**
160	* Free (decrement) the semaphore (change status to V).
161	* @return 1 for success, 0 for failure.
162	*/
163	static int semaphore_v(void) // changes status to 'V' (free)
164	{
165	struct sembuf sem_b;
166
167	sem_b.sem_num = 0;
168	sem_b.sem_op = 1; // V()
169	sem_b.sem_flg = SEM_UNDO;
170	if (semop(g_sem_id, &sem_b, 1) == -1) {
171	log_msg(3, "semaphore_v failed");
172	return (0);
173	}
174	return (1);
175	}
176
177
178	//------------------------------------------------------
179
180
181	/**
182	* Size in megabytes of the buffer afforded to the executable "buffer".
183	* This figure is used when we calculate how much data we have probably 'lost'
184	* when writing off the end of tape N, so that we can then figure out how much
185	* data we must recreate & write to the start of tape N+1.
186	*/
187	extern int g_tape_buffer_size_MB;
188
189
190
191
192	int
193	archive_this_fileset_with_star(char filelist, char fname, int setno)
194	{
195	int retval = 0;
196	unsigned int res = 0;
197	int tries = 0;
198	char *command = NULL;
199	char *tmp = NULL;
200	char *p;
201
202
203	if (!does_file_exist(filelist)) {
204	log_to_screen("(archive_this_fileset) - filelist %s does not exist", filelist);
205	return (1);
206	}
207
208	mr_asprintf(tmp, "echo hi > %s 2> /dev/null", fname);
209	if (system(tmp)) {
210	mr_free(tmp);
211	fatal_error("Unable to write tarball to scratchdir");
212	}
213	paranoid_free(tmp);
214
215	mr_asprintf(command, "star H=exustar list=%s -c " STAR_ACL_SZ " file=%s", filelist, fname);
216	if (bkpinfo->use_lzo) {
217	mr_free(command);
218	fatal_error("Can't use lzop");
219	}
220	if (bkpinfo->compression_level > 0) {
221	mr_strcat(command, " -bz");
222	}
223	mr_strcat(command, " 2>> %s", MONDO_LOGFILE);
224	log_msg(4, "command = '%s'", command);
225
226	for (res = 99, tries = 0; tries < 3 && res != 0; tries++) {
227	log_msg(5, "command='%s'", command);
228	res = system(command);
229	tmp = last_line_of_file(MONDO_LOGFILE);
230	log_msg(1, "res=%d; tmp='%s'", res, tmp);
231	if (bkpinfo->use_star && (res == 254 \|\| res == 65024)
232	&& strstr(tmp, "star: Processed all possible files")
233	&& tries > 0) {
234	log_msg(1, "Star returned nonfatal error");
235	res = 0;
236	}
237	mr_free(tmp);
238
239	if (res) {
240	log_OS_error(command);
241	p = strstr(command, "-acl ");
242	if (p) {
243	p[0] = p[1] = p[2] = p[3] = ' ';
244	log_msg(1, "new command = '%s'", command);
245	} else {
246	log_msg(3,
247	"Attempt #%d failed. Pausing 3 seconds and retrying...",
248	tries + 1);
249	sleep(3);
250	}
251	}
252	}
253	mr_free(command);
254
255	retval += res;
256	if (retval) {
257	log_msg(3, "Failed to write set %d", setno);
258	} else if (tries > 1) {
259	log_msg(3, "Succeeded in writing set %d, on try #%d", setno,
260	tries);
261	}
262	return (retval);
263	}
264
265
266	/**
267	* Call @c afio to archive the filelist @c filelist to the file @c fname.
268	*
269	* @param bkpinfo The backup information structure. Fields used:
270	* - @c compression_level
271	* - @c scratchdir (only verifies existence)
272	* - @c tmpdir (only verifies existence)
273	* - @c zip_exe
274	* - @c zip_suffix
275	* @param filelist The path to a file containing a list of files to be archived
276	* in this fileset.
277	* @param fname The output file to archive to.
278	* @param setno This fileset number.
279	* @return The number of errors encountered (0 for success).
280	* @ingroup LLarchiveGroup
281	*/
282	int
283	archive_this_fileset(char filelist, char fname, int setno)
284	{
285
286	/@ int ************************************************************** */
287	int retval = 0;
288	int res = 0;
289	int tries = 0;
290	/*
291	int i = 0;
292	static int free_ramdisk_space = 9999;
293	*/
294
295	/@ buffers *********************************************************** */
296	char *command = NULL;
297	char *zipparams = NULL;
298	char *tmp = NULL;
299
300	assert(bkpinfo != NULL);
301	assert_string_is_neither_NULL_nor_zerolength(filelist);
302	assert_string_is_neither_NULL_nor_zerolength(fname);
303
304	if (bkpinfo->compression_level > 0 && bkpinfo->use_star) {
305	return (archive_this_fileset_with_star(filelist, fname, setno));
306	}
307
308	if (!does_file_exist(filelist)) {
309	log_to_screen("(archive_this_fileset) - filelist %s does not exist", filelist);
310	return (1);
311	}
312	mr_asprintf(tmp, "echo hi > %s 2> /dev/null", fname);
313	if (system(tmp)) {
314	mr_free(tmp);
315	fatal_error("Unable to write tarball to scratchdir");
316	}
317	mr_free(tmp);
318
319
320	if (bkpinfo->compression_level > 0) {
321	mr_asprintf(tmp, "%s/do-not-compress-these", g_mondo_home);
322	// -b %ld, TAPE_BLOCK_SIZE
323	mr_asprintf(zipparams, "-Z -P %s -G %d -T 3k", bkpinfo->zip_exe, bkpinfo->compression_level);
324	if (does_file_exist(tmp)) {
325	mr_strcat(zipparams, " -E %s",tmp);
326	} else {
327	log_msg(3, "%s not found. Cannot exclude zipfiles, etc.", tmp);
328	}
329	mr_free(tmp);
330	} else {
331	mr_asprintf(zipparams, "");
332	}
333
334	if (!does_file_exist(bkpinfo->tmpdir)) {
335	log_OS_error("tmpdir not found");
336	fatal_error("tmpdir not found");
337	}
338	if (!does_file_exist(bkpinfo->scratchdir)) {
339	log_OS_error("scratchdir not found");
340	fatal_error("scratchdir not found");
341	}
342	mr_asprintf(command, "rm -f %s %s. %s.gz %s.%s", fname, fname, fname, fname, bkpinfo->zip_suffix);
343	paranoid_system(command);
344	mr_free(command);
345
346	mr_asprintf(command, "afio -o -b %ld -M 16m %s %s < %s 2>> %s", TAPE_BLOCK_SIZE, zipparams, fname, filelist, MONDO_LOGFILE);
347	mr_free(zipparams);
348
349	mr_asprintf(tmp, "echo hi > %s 2> /dev/null", fname);
350	if (system(tmp)) {
351	mr_free(tmp);
352	fatal_error("Unable to write tarball to scratchdir");
353	}
354	mr_free(tmp);
355
356	for (res = 99, tries = 0; tries < 3 && res != 0; tries++) {
357	log_msg(5, "command='%s'", command);
358	res = system(command);
359	if (res) {
360	log_OS_error(command);
361	log_msg(3,
362	"Attempt #%d failed. Pausing 3 seconds and retrying...",
363	tries + 1);
364	sleep(3);
365	}
366	}
367	paranoid_free(command);
368
369	retval += res;
370	if (retval) {
371	log_msg(3, "Failed to write set %d", setno);
372	} else if (tries > 1) {
373	log_msg(3, "Succeeded in writing set %d, on try #%d", setno,
374	tries);
375	}
376
377	return (retval);
378	}
379
380
381
382
383
384
385	/**
386	* Wrapper function for all the backup commands.
387	* Calls these other functions: @c prepare_filelist(),
388	* @c call_filelist_chopper(), @c copy_mondo_and_mindi_stuff_to_scratchdir(),
389	* @c call_mindi_to_supply_boot_disks(), @c do_that_initial_phase(),
390	* @c make_those_afios_phase(), @c make_those_slices_phase(), and
391	* @c do_that_final_phase(). If anything fails before @c do_that_initial_phase(),
392	* @c fatal_error is called with a suitable message.
393	* @param bkpinfo The backup information structure. Uses most fields.
394	* @return The number of non-fatal errors encountered (0 for success).
395	* @ingroup archiveGroup
396	*/
397	int backup_data()
398	{
399	int retval = 0, res = 0;
400	char *tmp = NULL;
401
402	assert(bkpinfo != NULL);
403	set_g_cdrom_and_g_dvd_to_bkpinfo_value();
404	if (bkpinfo->backup_media_type == dvd) {
405	#ifdef DVDRWFORMAT
406	tmp = find_home_of_exe("dvd+rw-format");
407	if (!tmp) {
408	mr_free(tmp);
409	fatal_error("Cannot find dvd+rw-format. Please install it or fix your PATH.");
410	}
411	mr_free(tmp);
412	#endif
413	tmp = find_home_of_exe("growisofs");
414	if (!tmp) {
415	mr_free(tmp);
416	fatal_error("Cannot find growisofs. Please install it or fix your PATH.");
417	}
418	mr_free(tmp);
419	}
420
421	if ((res = prepare_filelist())) { /* generate scratchdir/filelist.full */
422	fatal_error("Failed to generate filelist catalog");
423	}
424	if (call_filelist_chopper()) {
425	fatal_error("Failed to run filelist chopper");
426	}
427
428	mr_asprintf(tmp, "gzip -9 %s/archives/filelist.full", bkpinfo->scratchdir);
429	if (run_program_and_log_output(tmp, 2)) {
430	mr_free(tmp);
431	fatal_error("Failed to gzip filelist.full");
432	}
433	mr_free(tmp);
434
435	mr_asprintf(tmp, "cp -f %s/archives/list.gz %s", bkpinfo->scratchdir, bkpinfo->tmpdir);
436	if (run_program_and_log_output(tmp, 2)) {
437	mr_free(tmp);
438	fatal_error("Failed to copy to tmpdir");
439	}
440	mr_free(tmp);
441
442	copy_mondo_and_mindi_stuff_to_scratchdir(); // payload, too, if it exists
443	mr_free(bkpinfo->kernel_path);
444	#if __FreeBSD__ == 5
445	mr_asprintf(bkpinfo->kernel_path, "/boot/kernel/kernel");
446	#elif __FreeBSD__ == 4
447	mr_asprintf(bkpinfo->kernel_path, "/kernel");
448	#elif linux
449	if ((bkpinfo->kernel_path = figure_out_kernel_path_interactively_if_necessary()) == NULL) {
450	fatal_error("Kernel not found. Please specify manually with the '-k' switch.");
451	}
452	#else
453	#error "I don't know about this system!"
454	#endif
455	if ((res = call_mindi_to_supply_boot_disks())) {
456	fatal_error("Failed to generate boot+data disks");
457	}
458	retval += do_that_initial_phase(); // prepare
459	mr_asprintf(tmp, "rm -f %s/images/*.iso", bkpinfo->scratchdir);
460	run_program_and_log_output(tmp, 1);
461	mr_free(tmp);
462
463	retval += make_those_afios_phase(); // backup regular files
464	retval += make_those_slices_phase(); // backup BIG files
465	retval += do_that_final_phase(); // clean up
466	log_msg(1, "Creation of archives... complete.");
467	if (bkpinfo->verify_data) {
468	sleep(2);
469	}
470	return (retval);
471	}
472
473
474
475
476	/**
477	* Call Mindi to generate boot and data disks.
478	* @note This binds correctly to the new Perl version of mindi.
479	* @param bkpinfo The backup information structure. Fields used:
480	* - @c backup_media_type
481	* - @c boot_loader
482	* - @c boot_device
483	* - @c compression_level
484	* - @c differential
485	* - @c exclude_paths
486	* - @c image_devs
487	* - @c kernel_path
488	* - @c make_cd_use_lilo
489	* - @c media_device
490	* - @c media_size
491	* - @c nonbootable_backup
492	* - @c scratchdir
493	* - @c tmpdir
494	* - @c use_lzo
495	*
496	* @return The number of errors encountered (0 for success)
497	* @bug The code to automagically determine the boot drive
498	* is messy and system-dependent. In particular, it breaks
499	* for Linux RAID and LVM users.
500	* @ingroup MLarchiveGroup
501	*/
502	int call_mindi_to_supply_boot_disks()
503	{
504	/@ buffer *********************************************************** */
505	char *tmp = NULL;
506	char *tmp2 = NULL;
507	char *command = NULL;
508	char *use_lzo_sz = NULL;
509	char *use_gzip_sz = NULL;
510	char *use_lzma_sz = NULL;
511	char *use_comp_sz = NULL;
512	char *use_star_sz = NULL;
513	char *bootldr_str = NULL;
514	char *tape_device = NULL;
515	char *broken_bios_sz = NULL;
516	char *cd_recovery_sz = NULL;
517	char *tape_size_sz = NULL;
518	char use_lilo_sz = NULL; / BCO: shared between LILO/ELILO */
519	char *value = NULL;
520	char *bootdev = NULL;
521	char *ntapedev = NULL;
522
523
524
525	/@ char ************************************************************* */
526	char ch = '\0';
527
528	/@ long ********************************************************* */
529	long lines_in_filelist = 0;
530
531	/@ int ************************************************************ */
532	int res = 0;
533	long estimated_total_noof_slices = 0;
534
535	assert(bkpinfo != NULL);
536
537	mr_asprintf(tmp, "%s/filelist.full", bkpinfo->tmpdir);
538	if (!does_file_exist(tmp)) {
539	mr_free(tmp);
540	mr_asprintf(tmp, "%s/tmpfs/filelist.full", bkpinfo->tmpdir);
541	if (!does_file_exist(tmp)) {
542	mr_free(tmp);
543	fatal_error ("Cannot find filelist.full, so I cannot count its lines");
544	}
545	}
546	lines_in_filelist = count_lines_in_file(tmp);
547	mr_free(tmp);
548
549	if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
550	mr_asprintf(tape_size_sz, "%ld", bkpinfo->media_size[1]);
551	if (bkpinfo->media_device) {
552	ntapedev = get_non_rewind_dev(bkpinfo->media_device);
553	}
554	if ((bkpinfo->use_obdr) && (ntapedev != NULL)) {
555	mr_free(bkpinfo->media_device);
556	mr_asprintf(bkpinfo->media_device,"%s",ntapedev);
557	} else {
558	if (ntapedev == NULL) {
559	log_it("Not able to create OBDR - Restore will have to be done manually");
560	}
561	}
562	mr_free(ntapedev);
563	if (bkpinfo->media_device) {
564	mr_asprintf(tape_device, "%s", bkpinfo->media_device);
565	} else {
566	mr_asprintf(tape_device, "");
567	}
568	} else {
569	mr_asprintf(tape_size_sz, "%ld", 0L);;
570	mr_asprintf(tape_device, "");
571	}
572	if (bkpinfo->use_lzo) {
573	mr_asprintf(use_lzo_sz, "yes");
574	} else {
575	mr_asprintf(use_lzo_sz, "no");
576	}
577	if (bkpinfo->use_gzip) {
578	mr_asprintf(use_gzip_sz, "yes");
579	} else {
580	mr_asprintf(use_gzip_sz, "no");
581	}
582	if (bkpinfo->use_lzma) {
583	mr_asprintf(use_lzma_sz, "yes");
584	} else {
585	mr_asprintf(use_lzma_sz, "no");
586	}
587	if (bkpinfo->use_star) {
588	mr_asprintf(use_star_sz, "yes");
589	} else {
590	mr_asprintf(use_star_sz, "no");
591	}
592
593	if (bkpinfo->compression_level > 0) {
594	mr_asprintf(use_comp_sz, "yes");
595	} else {
596	mr_asprintf(use_comp_sz, "no");
597	}
598
599	mr_asprintf(broken_bios_sz, "yes"); /* assume so */
600	if (g_cd_recovery) {
601	mr_asprintf(cd_recovery_sz, "yes");
602	} else {
603	mr_asprintf(cd_recovery_sz, "no");
604	}
605	if (bkpinfo->make_cd_use_lilo) {
606	mr_asprintf(use_lilo_sz, "yes");
607	} else {
608	mr_asprintf(use_lilo_sz, "no");
609	}
610
611	if (!bkpinfo->nonbootable_backup && (bkpinfo->boot_loader == '\0' \|\| bkpinfo->boot_device == NULL)) {
612
613	#ifdef __FreeBSD__
614	bootdev = call_program_and_get_last_line_of_output("mount \| grep ' /boot ' \| head -1 \| cut -d' ' -f1 \| sed 's/\$[0-9]\$.*/\\1/'");
615	if (!bootdev[0]) {
616	mr_free(bootdev);
617	bootdev = call_program_and_get_last_line_of_output("mount \| grep ' / ' \| head -1 \| cut -d' ' -f1 \| sed 's/\$[0-9]\$.*/\\1/'");
618	}
619	#else
620	/* Linux */
621	#ifdef __IA64__
622	bootdev = call_program_and_get_last_line_of_output("mount \| grep ' /boot/efi ' \| head -1 \| cut -d' ' -f1 \| sed 's/[0-9].*//'");
623	#else
624	bootdev = call_program_and_get_last_line_of_output("mount \| grep ' /boot ' \| head -1 \| cut -d' ' -f1 \| sed 's/[0-9].*//'");
625	#endif
626	if (strstr(bootdev, "/dev/cciss/")) {
627	mr_free(bootdev);
628	#ifdef __IA64__
629	bootdev = call_program_and_get_last_line_of_output("mount \| grep ' /boot/efi ' \| head -1 \| cut -d' ' -f1 \| cut -dp -f1");
630	#else
631	bootdev = call_program_and_get_last_line_of_output("mount \| grep ' /boot ' \| head -1 \| cut -d' ' -f1 \| cut -dp -f1");
632	#endif
633	}
634	if (!bootdev[0]) {
635	mr_free(bootdev);
636	bootdev = call_program_and_get_last_line_of_output("mount \| grep ' / ' \| head -1 \| cut -d' ' -f1 \| sed 's/[0-9].*//'");
637	if (strstr(bootdev, "/dev/cciss/")) {
638	mr_free(bootdev);
639	bootdev = call_program_and_get_last_line_of_output("mount \| grep ' / ' \| head -1 \| cut -d' ' -f1 \| cut -dp -f1");
640	}
641	}
642	/* Linux */
643	#endif
644	if (bootdev[0])
645	ch = which_boot_loader(bootdev);
646	else
647	ch = 'U';
648	if (bkpinfo->boot_loader != '\0') {
649	log_msg(2, "User specified boot loader. It is '%c'.", bkpinfo->boot_loader);
650	} else {
651	bkpinfo->boot_loader = ch;
652	}
653	if (bkpinfo->boot_device != NULL) {
654	log_msg(2, "User specified boot device. It is '%s'.", bkpinfo->boot_device);
655	} else {
656	mr_asprintf(bkpinfo->boot_device, "%s", bootdev);
657	}
658	}
659	mr_free(bootdev);
660
661	if (
662	#ifdef __FreeBSD__
663	bkpinfo->boot_loader != 'B' && bkpinfo->boot_loader != 'D' &&
664	#endif
665	#ifdef __IA64__
666	bkpinfo->boot_loader != 'E' &&
667	#endif
668	bkpinfo->boot_loader != 'L' && bkpinfo->boot_loader != 'G'
669	&& bkpinfo->boot_loader != 'R'
670	&& !bkpinfo->nonbootable_backup) {
671	fatal_error
672	("Please specify your boot loader and device, e.g. -l GRUB -f /dev/hda. Type 'man mondoarchive' to read the manual.");
673	}
674	if (bkpinfo->boot_loader == 'L') {
675	mr_asprintf(bootldr_str, "LILO");
676	if (!does_file_exist("/etc/lilo.conf")) {
677	fatal_error("The de facto standard location for your boot loader's config file is /etc/lilo.conf but I cannot find it there. What is wrong with your Linux distribution?");
678	}
679	} else if (bkpinfo->boot_loader == 'G') {
680	mr_asprintf(bootldr_str, "GRUB");
681	if (!does_file_exist("/boot/grub/menu.lst") && does_file_exist("/boot/grub/grub.conf")) {
682	run_program_and_log_output("ln -sf /boot/grub/grub.conf /boot/grub/menu.lst", 5);
683	}
684	if ((!does_file_exist("/boot/grub/menu.lst")) && (!does_file_exist("/boot/grub/grub.cfg"))) {
685	fatal_error("The de facto standard location for your boot loader's config file is /boot/grub/menu.lst or /boot/grub/grub.cfg but I cannot find it there. What is wrong with your Linux distribution?");
686	}
687	} else if (bkpinfo->boot_loader == 'E') {
688	mr_asprintf(bootldr_str, "ELILO");
689	/* BCO: fix it for Debian, Mandrake, ... */
690	if (!does_file_exist("/etc/elilo.conf") && does_file_exist("/boot/efi/efi/redhat/elilo.conf")) {
691	run_program_and_log_output("ln -sf /boot/efi/efi/redhat/elilo.conf /etc/elilo.conf", 5);
692	}
693	if (!does_file_exist("/etc/elilo.conf") && does_file_exist("/boot/efi/efi/SuSE/elilo.conf")) {
694	run_program_and_log_output("ln -sf /boot/efi/efi/SuSE/elilo.conf /etc/elilo.conf", 5);
695	}
696	if (!does_file_exist("/etc/elilo.conf") && does_file_exist("/boot/efi/efi/debian/elilo.conf")) {
697	run_program_and_log_output ("ln -sf /boot/efi/efi/debian/elilo.conf /etc/elilo.conf", 5);
698	}
699	if (!does_file_exist("/etc/elilo.conf") && does_file_exist("/boot/efi/debian/elilo.conf")) {
700	run_program_and_log_output ("ln -sf /boot/efi/debian/elilo.conf /etc/elilo.conf", 5);
701	}
702	if (!does_file_exist("/etc/elilo.conf")) {
703	fatal_error("The de facto mondo standard location for your boot loader's config file is /etc/elilo.conf but I cannot find it there. What is wrong with your Linux distribution? Try finding it under /boot/efi and do 'ln -s /boot/efi/..../elilo.conf /etc/elilo.conf'");
704	}
705	} else if (bkpinfo->boot_loader == 'R') {
706	mr_asprintf(bootldr_str, "RAW");
707	}
708	#ifdef __FreeBSD__
709	else if (bkpinfo->boot_loader == 'D') {
710	mr_asprintf(bootldr_str, "DD");
711	}
712
713	else if (bkpinfo->boot_loader == 'B') {
714	mr_asprintf(bootldr_str, "BOOT0");
715	}
716	#endif
717	else {
718	mr_asprintf(bootldr_str, "unknown");
719	}
720	log_to_screen("Your boot loader is %s and it boots from %s", bootldr_str, bkpinfo->boot_device);
721
722	mr_asprintf(tmp, "%s/BOOTLOADER.DEVICE", bkpinfo->tmpdir);
723	if (write_one_liner_data_file(tmp, bkpinfo->boot_device)) {
724	log_msg(1, "%ld: Unable to write one-liner boot device", __LINE__);
725	}
726	mr_free(tmp);
727
728	switch (bkpinfo->backup_media_type) {
729	case cdr:
730	mr_asprintf(value, "cdr");
731	break;
732	case cdrw:
733	mr_asprintf(value, "cdrw");
734	break;
735	case cdstream:
736	mr_asprintf(value, "cdstream");
737	break;
738	case tape:
739	mr_asprintf(value, "tape");
740	break;
741	case udev:
742	mr_asprintf(value, "udev");
743	break;
744	case iso:
745	mr_asprintf(value, "iso");
746	break;
747	case netfs:
748	mr_asprintf(value, "netfs");
749	break;
750	case dvd:
751	mr_asprintf(value, "dvd");
752	break;
753	case usb:
754	mr_asprintf(value, "usb");
755	break;
756	default:
757	fatal_error("Unknown backup_media_type");
758	}
759	mr_free(value);
760
761	if ((bkpinfo->backup_media_type == usb) && (bkpinfo->media_device)) {
762	mr_asprintf(tmp2, "--usb %s", bkpinfo->media_device);
763	} else {
764	mr_asprintf(tmp2," ");
765	}
766
767	mr_asprintf(tmp, "%s/BOOTLOADER.NAME", bkpinfo->tmpdir);
768	if (write_one_liner_data_file(tmp, bootldr_str)) {
769	res++;
770	log_msg(1, "%ld: Unable to write one-liner bootloader.name", __LINE__);
771	}
772	mr_free(bootldr_str);
773	mr_free(tmp);
774
775	estimated_total_noof_slices = size_of_all_biggiefiles_K(bkpinfo) / bkpinfo->optimal_set_size + 1;
776
777	/* BERLIOS: add netfs stuff here? */
778	mr_asprintf(command, "mkdir -p %s/images", bkpinfo->scratchdir);
779	if (system(command)) {
780	res++;
781	log_OS_error("Unable to make images directory");
782	}
783	paranoid_free(command);
784	log_msg(1, "lines_in_filelist = %ld", lines_in_filelist);
785
786	/* "mindi --custom 2=%s 3=%s/images 4=\"%s\" 5=\"%s\" \
787	6=\"%s\" 7=%ld 8=\"%s\" 9=\"%s\" 10=\"%s\" \
788	11=\"%s\" 12=%s 13=%ld 14=\"%s\" 15=\"%s\" 16=\"%s\" 17=\"%s\" 18=%ld 19=%d",*/
789	mr_asprintf(command, "mindi %s --custom %s %s/images '%s' '%s' '%s' %ld '%s' '%s' '%s' \
790	'%s' %s %ld '%s' '%s' '%s' '%s' %ld %d '%s' '%s' >> %s",
791	tmp2, // parameter #1
792	bkpinfo->tmpdir, // parameter #2
793	bkpinfo->scratchdir, // parameter #3
794	bkpinfo->kernel_path, // parameter #4
795	tape_device, // parameter #5
796	tape_size_sz, // parameter #6
797	lines_in_filelist, // parameter #7 (INT)
798	use_lzo_sz, // parameter #8
799	cd_recovery_sz, // parameter #9
800	(bkpinfo->image_devs == NULL) ? "\"\"" : bkpinfo->image_devs, // parameter #10
801	broken_bios_sz, // parameter #11
802	estimated_total_noof_slices, // parameter #12 (INT)
803	(bkpinfo->exclude_devs == NULL) ? "\"\"" : bkpinfo->exclude_devs, // parameter #13
804	use_comp_sz, // parameter #14
805	use_lilo_sz, // parameter #15
806	use_star_sz, // parameter #16
807	bkpinfo->internal_tape_block_size, // parameter #17 (LONG)
808	bkpinfo->differential, // parameter #18 (INT)
809	use_gzip_sz, // parameter #19 (STRING)
810	use_lzma_sz, // parameter #20 (STRING)
811	MONDO_LOGFILE);
812
813	mr_free(tmp2);
814	mr_free(tape_device);
815	mr_free(use_lzo_sz);
816	mr_free(use_gzip_sz);
817	mr_free(use_lzma_sz);
818	mr_free(use_star_sz);
819	mr_free(use_comp_sz);
820	mr_free(broken_bios_sz);
821	mr_free(cd_recovery_sz);
822	mr_free(use_lilo_sz);
823	mr_free(tape_size_sz);
824
825	/* This parameter is always the last one and optional */
826	if (bkpinfo->nonbootable_backup) {
827	mr_strcat(command, " NONBOOTABLE");
828	}
829	log_msg(2, command);
830
831	// popup_and_OK("Pausing");
832
833	mvaddstr_and_log_it(g_currentY, 0, "Calling MINDI to create boot+data disks");
834	res = run_external_binary_with_percentage_indicator_NEW("Generating boot+data disks", command);
835	paranoid_free(command);
836
837	if (bkpinfo->nonbootable_backup) {
838	res = 0;
839	} // hack
840	if (!res) {
841	log_to_screen("Boot+data disks were created OK");
842	mr_asprintf(command, "cp -f %s/images/mindi.iso %s/mondorescue.iso", bkpinfo->scratchdir, MINDI_CACHE);
843	log_msg(2, command);
844	run_program_and_log_output(command, FALSE);
845	mr_free(command);
846
847	if (bkpinfo->nonbootable_backup) {
848	mr_asprintf(command, "cp -f %s/all.tar.gz %s/images", bkpinfo->tmpdir, bkpinfo->scratchdir);
849	if (system(command)) {
850	mr_free(command);
851	fatal_error("Unable to create temporary all tarball");
852	}
853	mr_free(command);
854	}
855	/* For USB we already have everything on the key */
856	if (bkpinfo->backup_media_type == usb) {
857	mr_asprintf(command, "rm -rf %s/images", bkpinfo->scratchdir);
858	run_program_and_log_output(command, FALSE);
859	mr_free(command);
860	} else {
861	mr_asprintf(tmp, "cp -f %s/images/all.tar.gz %s", bkpinfo->scratchdir, bkpinfo->tmpdir);
862	if (system(tmp)) {
863	mr_free(tmp);
864	fatal_error("Cannot find all.tar.gz in tmpdir");
865	}
866	mr_free(tmp);
867	}
868	if (res) {
869	mvaddstr_and_log_it(g_currentY++, 74, "Errors.");
870	} else {
871	mvaddstr_and_log_it(g_currentY++, 74, "Done.");
872	}
873	} else {
874	log_to_screen("Mindi failed to create your boot+data disks.");
875	mr_asprintf(command, "grep 'Fatal error' /var/log/mindi.log");
876	tmp = call_program_and_get_last_line_of_output(command);
877	mr_free(command);
878
879	if (strlen(tmp) > 1) {
880	popup_and_OK(tmp);
881	}
882	mr_free(tmp);
883	}
884	return (res);
885	}
886
887
888
889	/**
890	* Maximum number of filesets allowed in this function.
891	*/
892	#define MAX_NOOF_SETS_HERE 32767
893
894	/**
895	* Offset of the bkpinfo pointer (in bytes) from the
896	* buffer passed to create_afio_files_in_background.
897	*/
898	#define BKPINFO_LOC_OFFSET (16+MAX_NOOF_SETS_HERE/8+16)
899
900	/**
901	* Main function for each @c afio thread.
902	* @param inbuf A transfer block containing:
903	* - @c p_last_set_archived: [offset 0] pointer to an @c int
904	* containing the last set archived.
905	* - @c p_archival_threads_running: [offset 4] pointer to an @c int
906	* containing the number of archival threads currently running.
907	* - @c p_next_set_to_archive: [offset 8] pointer to an @c int containing
908	* the next set that should be archived.
909	* - @c p_list_of_fileset_flags: [offset 12] @c char pointer pointing to a
910	* bit array, where each bit corresponds to a filelist (1=needs
911	* to be archived, 0=archived).
912	* - @c bkpinfo: [offset BKPINFO_LOC_OFFSET] pointer to backup information
913	* structure. Fields used:
914	* - @c tmpdir
915	* - @c zip_suffix
916	*
917	* Any of the above may be modified by the caller at any time.
918	*
919	* @bug Assumes @c int pointers are 4 bytes.
920	* @see archive_this_fileset
921	* @see make_afioballs_and_images
922	* @return NULL, always.
923	* @ingroup LLarchiveGroup
924	*/
925	void create_afio_files_in_background(void inbuf)
926	{
927	long int archiving_set_no = 0L;
928	char *archiving_filelist_fname = NULL;
929	char *archiving_afioball_fname = NULL;
930	char *curr_xattr_list_fname = NULL;
931	char *curr_acl_list_fname = NULL;
932
933	struct s_bkpinfo *bkpinfo_bis;
934	char *tmp = NULL;
935	int res = 0, retval = 0;
936	int *p_archival_threads_running;
937	int *p_last_set_archived;
938	int *p_next_set_to_archive;
939	char *p_list_of_fileset_flags;
940	int this_thread_no = g_current_thread_no++;
941
942	p_last_set_archived = (int *) inbuf;
943	p_archival_threads_running = (int *) (inbuf + 4);
944	p_next_set_to_archive = (int *) (inbuf + 8);
945	p_list_of_fileset_flags = (char *) (inbuf + 12);
946	bkpinfo_bis = (struct s_bkpinfo *) (inbuf + BKPINFO_LOC_OFFSET);
947
948	mr_asprintf(archiving_filelist_fname, FILELIST_FNAME_RAW_SZ, bkpinfo->tmpdir, 0L);
949
950	while (does_file_exist(archiving_filelist_fname)) {
951	if (g_exiting) {
952	mr_free(archiving_filelist_fname);
953	fatal_error("Execution run aborted (pthread)");
954	}
955	if (archiving_set_no >= MAX_NOOF_SETS_HERE) {
956	mr_free(archiving_filelist_fname);
957	fatal_error("Maximum number of filesets exceeded. Adjust MAX_NOOF_SETS_HERE, please.");
958	}
959	if (!semaphore_p()) {
960	log_msg(3, "P sem failed (pid=%d)", (int) getpid());
961	mr_free(archiving_filelist_fname);
962	fatal_error("Cannot get semaphore P");
963	}
964	if (archiving_set_no < *p_next_set_to_archive) {
965	archiving_set_no = *p_next_set_to_archive;
966	}
967	p_next_set_to_archive = p_next_set_to_archive + 1;
968	if (!semaphore_v()) {
969	mr_free(archiving_filelist_fname);
970	fatal_error("Cannot get semaphore V");
971	}
972
973	/* backup this set of files */
974	mr_asprintf(archiving_afioball_fname, AFIOBALL_FNAME_RAW_SZ, bkpinfo->tmpdir, archiving_set_no, bkpinfo->zip_suffix);
975	mr_free(archiving_filelist_fname);
976	mr_asprintf(archiving_filelist_fname, FILELIST_FNAME_RAW_SZ, bkpinfo->tmpdir, archiving_set_no);
977	if (!does_file_exist(archiving_filelist_fname)) {
978	log_msg(3, "[%d:%d] - well, I would archive %d, except that it doesn't exist. I'll stop now.", getpid(), this_thread_no, archiving_set_no);
979	mr_free(archiving_afioball_fname);
980	break;
981	}
982
983	mr_asprintf(tmp, AFIOBALL_FNAME_RAW_SZ, bkpinfo->tmpdir, archiving_set_no - ARCH_BUFFER_NUM, bkpinfo->zip_suffix);
984	if (does_file_exist(tmp)) {
985	log_msg(4, "[%d:%d] - waiting for storer", getpid(), this_thread_no);
986	while (does_file_exist(tmp)) {
987	sleep(1);
988	}
989	log_msg(4, "[%d] - continuing", getpid());
990	}
991	mr_free(tmp);
992
993	log_msg(4, "[%d:%d] - EXATing %d...", getpid(), this_thread_no, archiving_set_no);
994
995	if (g_getfattr) {
996	mr_asprintf(curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ, bkpinfo->tmpdir, archiving_set_no);
997	get_fattr_list(archiving_filelist_fname, curr_xattr_list_fname);
998	mr_free(curr_xattr_list_fname);
999	}
1000	if (g_getfacl) {
1001	mr_asprintf(curr_acl_list_fname, ACL_LIST_FNAME_RAW_SZ, bkpinfo->tmpdir, archiving_set_no);
1002	get_acl_list(archiving_filelist_fname, curr_acl_list_fname);
1003	mr_free(curr_acl_list_fname);
1004	}
1005
1006	log_msg(4, "[%d:%d] - archiving %d...", getpid(), this_thread_no, archiving_set_no);
1007	res = archive_this_fileset(archiving_filelist_fname, archiving_afioball_fname, archiving_set_no);
1008	mr_free(archiving_afioball_fname);
1009
1010	retval += res;
1011
1012	if (res) {
1013	log_to_screen("Errors occurred while archiving set %ld. Please review logs.", archiving_set_no);
1014	}
1015
1016	if (!semaphore_p()) {
1017	mr_free(archiving_filelist_fname);
1018	fatal_error("Cannot get semaphore P");
1019	}
1020
1021	set_bit_N_of_array(p_list_of_fileset_flags, archiving_set_no, 5);
1022
1023	if (*p_last_set_archived < archiving_set_no) {
1024	*p_last_set_archived = archiving_set_no;
1025	} // finished archiving this one
1026
1027	if (!semaphore_v()) {
1028	mr_free(archiving_filelist_fname);
1029	fatal_error("Cannot get semaphore V");
1030	}
1031	log_msg(4, "[%d:%d] - archived %d OK", getpid(), this_thread_no, archiving_set_no);
1032	archiving_set_no++;
1033
1034	mr_free(archiving_filelist_fname);
1035	mr_asprintf(archiving_filelist_fname, FILELIST_FNAME_RAW_SZ, bkpinfo->tmpdir, archiving_set_no);
1036	}
1037	mr_free(archiving_filelist_fname);
1038
1039	if (!semaphore_p()) {
1040	fatal_error("Cannot get semaphore P");
1041	}
1042	(*p_archival_threads_running)--;
1043	if (!semaphore_v()) {
1044	fatal_error("Cannot get semaphore V");
1045	}
1046	log_msg(3, "[%d:%d] - exiting", getpid(), this_thread_no);
1047	pthread_exit(NULL);
1048	}
1049
1050
1051
1052
1053
1054	/**
1055	* Finalize the backup.
1056	* For streaming backups, this writes the closing block
1057	* to the stream. For CD-based backups, this creates
1058	* the final ISO image.
1059	* @param bkpinfo The backup information structure, used only
1060	* for the @c backup_media_type.
1061	* @ingroup MLarchiveGroup
1062	*/
1063	int do_that_final_phase()
1064	{
1065
1066	/@ int ************************************* */
1067	int res = 0;
1068	int retval = 0;
1069
1070	/@ buffers ********************************* */
1071
1072	assert(bkpinfo != NULL);
1073	mvaddstr_and_log_it(g_currentY, 0,
1074	"Writing any remaining data to media ");
1075
1076	log_msg(1, "Closing tape/CD/USB ... ");
1077	if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
1078	/* write tape/cdstream */
1079	closeout_tape();
1080	} else {
1081	/* write final ISO/USB */
1082	res = write_final_iso_if_necessary();
1083	retval += res;
1084	if (res) {
1085	log_msg(1, "write_final_iso_if_necessary returned an error");
1086	}
1087	}
1088	log_msg(2, "Fork is exiting ... ");
1089
1090	mvaddstr_and_log_it(g_currentY++, 74, "Done.");
1091
1092	/* final stuff */
1093	if (retval) {
1094	mvaddstr_and_log_it(g_currentY++, 74, "Errors.");
1095	} else {
1096	mvaddstr_and_log_it(g_currentY++, 74, "Done.");
1097	}
1098
1099	return (retval);
1100	}
1101
1102
1103	/**
1104	* Initialize the backup.
1105	* Does the following:
1106	* - Sets up the serial number.
1107	* - For streaming backups, opens the tape stream and writes the data disks
1108	* and backup headers.
1109	* - For CD-based backups, wipes the ISOs in the target directory.
1110	*
1111	* @param bkpinfo The backup information structure. Fields used:
1112	* - @c backup_media_type
1113	* - @c cdrw_speed
1114	* - @c prefix
1115	* - @c isodir
1116	* - @c media_device
1117	* - @c scratchdir
1118	* - @c tmpdir
1119	* @return The number of errors encountered (0 for success).
1120	* @ingroup MLarchiveGroup
1121	*/
1122	int do_that_initial_phase()
1123	{
1124	/@ int ************************************** */
1125	int retval = 0;
1126
1127	/@ buffers ********************************** */
1128	char *command = NULL;
1129	char *tmpfile = NULL;
1130	char *data_disks_file = NULL;
1131
1132	assert(bkpinfo != NULL);
1133	mr_asprintf(data_disks_file, "%s/all.tar.gz", bkpinfo->tmpdir);
1134
1135	g_serial_string = call_program_and_get_last_line_of_output("dd if=/dev/urandom bs=16 count=1 2> /dev/null \| hexdump \| tr -s ' ' '0' \| head -n1");
1136	mr_strip_spaces(g_serial_string);
1137	mr_strcat(g_serial_string, "...word.");
1138	log_msg(2, "g_serial_string = '%s'", g_serial_string);
1139
1140	mr_asprintf(tmpfile, "%s/archives/SERIAL-STRING", bkpinfo->scratchdir);
1141	if (write_one_liner_data_file(tmpfile, g_serial_string)) {
1142	log_msg(1, "%ld: Failed to write serial string", __LINE__);
1143	}
1144	mr_free(tmpfile);
1145
1146	mvaddstr_and_log_it(g_currentY, 0, "Preparing to archive your data");
1147	if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
1148	if (bkpinfo->backup_media_type == cdstream) {
1149	openout_cdstream(bkpinfo->media_device, bkpinfo->cdrw_speed);
1150	} else {
1151	openout_tape(); /* sets g_tape_stream */
1152	}
1153	if (!g_tape_stream) {
1154	fatal_error("Cannot open backup (streaming) device");
1155	}
1156	log_msg(1, "Backup (stream) opened OK");
1157	write_data_disks_to_stream(data_disks_file);
1158	} else {
1159	if (bkpinfo->backup_media_type == usb) {
1160	log_msg(1, "Backing up to USB's");
1161	} else {
1162	log_msg(1, "Backing up to CD's");
1163	}
1164	}
1165	mr_free(data_disks_file);
1166
1167	if ((bkpinfo->isodir != NULL) && (bkpinfo->prefix != NULL)) {
1168	if (bkpinfo->netfs_remote_dir) {
1169	// NFS
1170	mr_asprintf(command, "rm -f %s/%s/%s-[1-9]*.iso", bkpinfo->isodir, bkpinfo->netfs_remote_dir, bkpinfo->prefix);
1171	} else {
1172	// ISO
1173	mr_asprintf(command, "rm -f %s/%s-[1-9]*.iso", bkpinfo->isodir, bkpinfo->prefix);
1174	}
1175	paranoid_system(command);
1176	mr_free(command);
1177	}
1178
1179	wipe_archives(bkpinfo->scratchdir);
1180	mvaddstr_and_log_it(g_currentY++, 74, "Done.");
1181	if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
1182	write_header_block_to_stream((off_t)0, "start-of-tape",
1183	BLK_START_OF_TAPE);
1184	write_header_block_to_stream((off_t)0, "start-of-backup",
1185	BLK_START_OF_BACKUP);
1186	}
1187	return (retval);
1188	}
1189
1190
1191	/**
1192	* Get the <tt>N</tt>th bit of @c array.
1193	* @param array The bit-array (as a @c char pointer).
1194	* @param N The number of the bit you want.
1195	* @return TRUE (bit is set) or FALSE (bit is not set).
1196	* @see set_bit_N_of_array
1197	* @ingroup utilityGroup
1198	*/
1199	bool get_bit_N_of_array(char *array, int N)
1200	{
1201	int element_number;
1202	int bit_number;
1203	int mask;
1204
1205	element_number = N / 8;
1206	bit_number = N % 8;
1207	mask = 1 << bit_number;
1208	if (array[element_number] & mask) {
1209	return (TRUE);
1210	} else {
1211	return (FALSE);
1212	}
1213	}
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223	/**
1224	* @addtogroup LLarchiveGroup
1225	* @{
1226	*/
1227	/**
1228	* Start up threads to archive your files.
1229	*
1230	* This function starts @c ARCH_THREADS threads,
1231	* each starting execution in @c create_afio_files_in_background().
1232	* Each thread will archive individual filesets, based on the
1233	* pointers passed to it and continually updated, until all files
1234	* have been backed up. This function coordinates the threads
1235	* and copies their output to the @c scratchdir.
1236	*
1237	* @param bkpinfo The backup information structure. Fields used:
1238	* - @c backup_media_type
1239	* - @c scratchdir
1240	* - @c tmpdir
1241	* - @c zip_suffix
1242	*
1243	* @return The number of errors encountered (0 for success)
1244	*/
1245	int make_afioballs_and_images()
1246	{
1247
1248	/@ int ************************************************* */
1249	int retval = 0;
1250	long int storing_set_no = 0;
1251	int res = 0;
1252	bool done_storing = FALSE;
1253	char *result_str;
1254	char *transfer_block;
1255	void *vp;
1256	void **pvp;
1257
1258	/@ buffers ********************************************* */
1259	char *storing_filelist_fname = NULL;
1260	char *storing_afioball_fname = NULL;
1261	char *tmp = NULL;
1262	char *media_usage_comment = NULL;
1263	pthread_t archival_thread[ARCH_THREADS];
1264	char *p_list_of_fileset_flags;
1265	int *p_archival_threads_running;
1266	int *p_last_set_archived;
1267	int *p_next_set_to_archive;
1268	int noof_threads;
1269	int i;
1270	char *curr_xattr_list_fname = NULL;
1271	char *curr_acl_list_fname = NULL;
1272	int misc_counter_that_is_not_important = 0;
1273
1274	log_msg(8, "here");
1275	assert(bkpinfo != NULL);
1276	malloc_string(result_str);
1277	transfer_block = malloc(sizeof(struct s_bkpinfo) + BKPINFO_LOC_OFFSET + 64);
1278	memset((void *) transfer_block, 0, sizeof(struct s_bkpinfo) + BKPINFO_LOC_OFFSET + 64);
1279	p_last_set_archived = (int *) transfer_block;
1280	p_archival_threads_running = (int *) (transfer_block + 4);
1281	p_next_set_to_archive = (int *) (transfer_block + 8);
1282	p_list_of_fileset_flags = (char *) (transfer_block + 12);
1283	memcpy((void ) (transfer_block + BKPINFO_LOC_OFFSET), (void ) bkpinfo, sizeof(struct s_bkpinfo));
1284	pvp = &vp;
1285	vp = (void *) result_str;
1286	*p_archival_threads_running = 0;
1287	*p_last_set_archived = -1;
1288	*p_next_set_to_archive = 0;
1289	log_to_screen("Archiving regular files");
1290	log_msg(5, "Go, Shorty. It's your birthday.");
1291	open_progress_form("Backing up filesystem",
1292	"I am backing up your live filesystem now.",
1293	"Please wait. This may take a couple of hours.",
1294	"Working...",
1295	(long)get_last_filelist_number() + 1L);
1296
1297	log_msg(5, "We're gonna party like it's your birthday.");
1298
1299	srand((unsigned int) getpid());
1300	g_sem_key = 1234 + random() % 30000;
1301	if ((g_sem_id =
1302	semget((key_t) g_sem_key, 1,
1303	IPC_CREAT \| S_IREAD \| S_IWRITE)) == -1) {
1304	fatal_error("MABAI - unable to semget");
1305	}
1306	if (!set_semvalue()) {
1307	fatal_error("Unable to init semaphore");
1308	} // initialize semaphore
1309	for (noof_threads = 0; noof_threads < ARCH_THREADS; noof_threads++) {
1310	log_msg(8, "Creating thread #%d", noof_threads);
1311	(*p_archival_threads_running)++;
1312	if ((res =
1313	pthread_create(&archival_thread[noof_threads], NULL,
1314	create_afio_files_in_background,
1315	(void *) transfer_block))) {
1316	fatal_error("Unable to create an archival thread");
1317	}
1318	}
1319
1320	log_msg(8, "About to enter while() loop");
1321	while (!done_storing) {
1322	if (g_exiting) {
1323	fatal_error("Execution run aborted (main loop)");
1324	}
1325	if (*p_archival_threads_running == 0
1326	&& *p_last_set_archived == storing_set_no - 1) {
1327	log_msg(2,
1328	"No archival threads are running. The last stored set was %d and I'm looking for %d. Take off your make-up; the party's over... :-)",
1329	*p_last_set_archived, storing_set_no);
1330	done_storing = TRUE;
1331	} else
1332	if (!get_bit_N_of_array
1333	(p_list_of_fileset_flags, storing_set_no)) {
1334	misc_counter_that_is_not_important = (misc_counter_that_is_not_important + 1) % 5;
1335	sleep(1);
1336	} else {
1337	// store set N
1338	mr_asprintf(storing_filelist_fname, FILELIST_FNAME_RAW_SZ, bkpinfo->tmpdir, storing_set_no);
1339	mr_asprintf(storing_afioball_fname, AFIOBALL_FNAME_RAW_SZ, bkpinfo->tmpdir, storing_set_no, bkpinfo->zip_suffix);
1340	if (g_getfattr) {
1341	mr_asprintf(curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ, bkpinfo->tmpdir, storing_set_no);
1342	}
1343	if (g_getfacl) {
1344	mr_asprintf(curr_acl_list_fname, ACL_LIST_FNAME_RAW_SZ, bkpinfo->tmpdir, storing_set_no);
1345	}
1346
1347	log_msg(2, "Storing set %d", storing_set_no);
1348	while (!does_file_exist(storing_filelist_fname)
1349	\|\| !does_file_exist(storing_afioball_fname)) {
1350	log_msg(2,
1351	"Warning - either %s or %s doesn't exist yet. I'll pause 5 secs.",
1352	storing_filelist_fname, storing_afioball_fname);
1353	sleep(5);
1354	}
1355	/* copy to CD (scratchdir) ... and an actual CD-R if necessary */
1356	if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
1357	register_in_tape_catalog(fileset, storing_set_no, -1,
1358	storing_afioball_fname);
1359	maintain_collection_of_recent_archives(storing_afioball_fname);
1360	log_it("Writing EXAT files");
1361	res +=
1362	write_EXAT_files_to_tape(curr_xattr_list_fname,
1363	curr_acl_list_fname);
1364	// archives themselves
1365	res +=
1366	move_files_to_stream(storing_afioball_fname,
1367	NULL);
1368	} else {
1369	if (g_getfacl) {
1370	if (g_getfattr) {
1371	res = move_files_to_cd(storing_filelist_fname,
1372	curr_xattr_list_fname,
1373	curr_acl_list_fname,
1374	storing_afioball_fname, NULL);
1375	} else {
1376	res = move_files_to_cd(storing_filelist_fname,
1377	curr_acl_list_fname,
1378	storing_afioball_fname, NULL);
1379	}
1380	} else {
1381	if (g_getfattr) {
1382	res = move_files_to_cd(storing_filelist_fname,
1383	curr_xattr_list_fname,
1384	storing_afioball_fname, NULL);
1385	} else {
1386	res = move_files_to_cd(storing_filelist_fname,
1387	storing_afioball_fname, NULL);
1388	}
1389	}
1390	}
1391	retval += res;
1392	g_current_progress++;
1393
1394	media_usage_comment = percent_media_full_comment();
1395	update_progress_form(media_usage_comment);
1396	mr_free(media_usage_comment);
1397	if (res) {
1398	log_to_screen("Failed to add archive %ld's files to CD dir\n", storing_set_no);
1399	fatal_error("Is your hard disk full? If not, please send the author the logfile.");
1400	}
1401	storing_set_no++;
1402	// sleep(2);
1403	if (g_getfacl) {
1404	mr_free(curr_acl_list_fname);
1405	}
1406	if (g_getfattr) {
1407	mr_free(curr_xattr_list_fname);
1408	}
1409	mr_free(storing_filelist_fname);
1410	mr_free(storing_afioball_fname);
1411	}
1412	}
1413	close_progress_form();
1414
1415	mr_asprintf(tmp, "Your regular files have been archived ");
1416	log_msg(2, "Joining background threads to foreground thread");
1417	for (i = 0; i < noof_threads; i++) {
1418	pthread_join(archival_thread[i], pvp);
1419	log_msg(3, "Thread %d of %d: closed OK", i + 1, noof_threads);
1420	}
1421	del_semvalue();
1422	log_msg(2, "Done.");
1423	if (retval) {
1424	mr_strcat(tmp, "(with errors).");
1425	} else {
1426	mr_strcat(tmp, "successfully.");
1427	}
1428	log_to_screen(tmp);
1429	mr_free(tmp);
1430
1431	paranoid_free(transfer_block);
1432	paranoid_free(result_str);
1433	return (retval);
1434	}
1435
1436
1437	void pause_for_N_seconds(int how_long, char *msg)
1438	{
1439	int i;
1440	open_evalcall_form(msg);
1441	for (i = 0; i < how_long; i++) {
1442	update_evalcall_form((int) ((100.0 / (float) (how_long) * i)));
1443	sleep(1);
1444	}
1445	close_evalcall_form();
1446	}
1447
1448
1449
1450
1451	/**
1452	* Create a USB image in @c destfile, from files in @c bkpinfo->scratchdir.
1453	*
1454	* @param bkpinfo The backup information structure. Fields used:
1455	* - @c backup_media_type
1456	* - @c nonbootable_backup
1457	* - @c scratchdir
1458	*
1459	* @param destfile Where to put the generated USB image.
1460	* @return The number of errors encountered (0 for success)
1461	*/
1462	int make_usb_fs()
1463	{
1464	/@ int ********************************************* */
1465	int retval = 0;
1466	int res;
1467
1468	/@ buffers ***************************************** */
1469	char *tmp = NULL;
1470	char *tmp1 = NULL;
1471	char *result_sz = NULL;
1472	char *message_to_screen = NULL;
1473	char *old_pwd;
1474	char *mds = NULL;
1475
1476	malloc_string(old_pwd);
1477	assert(bkpinfo != NULL);
1478
1479	log_msg(2, "make_usb_fs --- scratchdir=%s", bkpinfo->scratchdir);
1480	(void) getcwd(old_pwd, MAX_STR_LEN - 1);
1481	mr_asprintf(tmp, "chmod 755 %s", bkpinfo->scratchdir);
1482	run_program_and_log_output(tmp, FALSE);
1483	mr_free(tmp);
1484	(void)chdir(bkpinfo->scratchdir);
1485
1486	mds = media_descriptor_string(bkpinfo->backup_media_type);
1487	mr_asprintf(message_to_screen, "Copying data to make %s #%d",mds, g_current_media_number);
1488	mr_free(mds);
1489	log_msg(1, message_to_screen);
1490
1491	if (bkpinfo->media_device) {
1492	mr_asprintf(tmp1, "%s1", bkpinfo->media_device);
1493	} else {
1494	mr_asprintf(tmp1, "");
1495	}
1496	if (is_this_device_mounted(tmp1)) {
1497	log_msg(1, "USB device mounted. Remounting it at the right place");
1498	mr_asprintf(tmp, "umount %s", tmp1);
1499	run_program_and_log_output(tmp, FALSE);
1500	mr_free(tmp);
1501	}
1502	mr_free(tmp1);
1503
1504	log_msg(1, "Mounting USB device.");
1505	mr_asprintf(tmp1, "%s/usb", bkpinfo->tmpdir);
1506	mr_asprintf(tmp, "mkdir -p %s", tmp1);
1507	run_program_and_log_output(tmp, FALSE);
1508	mr_free(tmp);
1509
1510	/* Mindi always create one single parition on the USB dev */
1511	mr_asprintf(tmp, "mount %s1 %s", bkpinfo->media_device, tmp1);
1512	run_program_and_log_output(tmp, FALSE);
1513	mr_free(tmp);
1514
1515	if (bkpinfo->nonbootable_backup) {
1516	log_msg(1, "Making nonbootable USB backup not implemented yet");
1517	} else {
1518	log_msg(1, "Making bootable backup");
1519
1520	/* Command to execute */
1521	mr_asprintf(tmp,"mv %s/* %s", bkpinfo->scratchdir, tmp1);
1522	res = eval_call_to_make_USB(tmp, message_to_screen);
1523	if (res) {
1524	mr_asprintf(result_sz, "%s ...failed",tmp);
1525	} else {
1526	mr_asprintf(result_sz, "%s ...OK",tmp);
1527	}
1528	log_to_screen(result_sz);
1529	mr_free(result_sz);
1530	mr_free(tmp);
1531	retval += res;
1532
1533	/* Recreate the required structure under the scratch dir */
1534	mr_asprintf(tmp,"mkdir %s/archive", bkpinfo->scratchdir);
1535	run_program_and_log_output(tmp, FALSE);
1536	mr_free(tmp);
1537	}
1538	paranoid_free(message_to_screen);
1539	paranoid_free(tmp1);
1540
1541	if (is_this_device_mounted(bkpinfo->media_device)) {
1542	mr_asprintf(tmp, "umount %s1", bkpinfo->media_device);
1543	run_program_and_log_output(tmp, FALSE);
1544	mr_free(tmp);
1545	}
1546
1547	(void)chdir(old_pwd);
1548	if (retval) {
1549	log_msg(1, "WARNING - make_usb_fs returned an error");
1550	}
1551	paranoid_free(old_pwd);
1552	return (retval);
1553	}
1554
1555
1556	/**
1557	* Create an ISO image in @c destfile, from files in @c bkpinfo->scratchdir.
1558	*
1559	* @param bkpinfo The backup information structure. Fields used:
1560	* - @c backup_media_type
1561	* - @c call_after_iso
1562	* - @c call_before_iso
1563	* - @c call_burn_iso
1564	* - @c call_make_iso
1565	* - @c make_cd_use_lilo
1566	* - @c manual_cd_tray
1567	* - @c nonbootable_backup
1568	* - @c scratchdir
1569	*
1570	* @param destfile Where to put the generated ISO image.
1571	* @return The number of errors encountered (0 for success)
1572	*/
1573	int make_iso_fs(char *destfile)
1574	{
1575	/@ int ********************************************* */
1576	int retval = 0;
1577	int res;
1578
1579	/@ buffers ***************************************** */
1580	char *tmp = NULL;
1581	char *old_pwd;
1582	char *result_sz = NULL;
1583	char *message_to_screen = NULL;
1584	char *sz_blank_disk = NULL;
1585	char *tmp2 = NULL;
1586	char *tmp3 = NULL;
1587	char *mds = NULL;
1588	bool cd_is_mountable;
1589
1590	malloc_string(old_pwd);
1591	assert(bkpinfo != NULL);
1592	assert_string_is_neither_NULL_nor_zerolength(destfile);
1593
1594	mr_asprintf(tmp, "%s/isolinux.bin", bkpinfo->scratchdir);
1595	mr_asprintf(tmp2, "%s/isolinux.bin", bkpinfo->tmpdir);
1596	if (does_file_exist(tmp)) {
1597	mr_asprintf(tmp3, "cp -f %s %s", tmp, tmp2);
1598	paranoid_system(tmp3);
1599	mr_free(tmp3);
1600	}
1601	if (!does_file_exist(tmp) && does_file_exist(tmp2)) {
1602	mr_asprintf(tmp3, "cp -f %s %s", tmp2, tmp);
1603	paranoid_system(tmp3);
1604	mr_free(tmp3);
1605	}
1606	mr_free(tmp2);
1607	mr_free(tmp);
1608
1609	if (bkpinfo->backup_media_type == iso && bkpinfo->manual_cd_tray) {
1610	popup_and_OK("Please insert new media and press Enter.");
1611	}
1612
1613	log_msg(2, "make_iso_fs --- scratchdir=%s --- destfile=%s", bkpinfo->scratchdir, destfile);
1614	(void) getcwd(old_pwd, MAX_STR_LEN - 1);
1615	mr_asprintf(tmp, "chmod 755 %s", bkpinfo->scratchdir);
1616	run_program_and_log_output(tmp, FALSE);
1617	mr_free(tmp);
1618
1619	chdir(bkpinfo->scratchdir);
1620
1621	if (bkpinfo->call_before_iso) {
1622	mr_asprintf(message_to_screen, "Running pre-ISO call for CD#%d", g_current_media_number);
1623	res = eval_call_to_make_ISO(bkpinfo->call_before_iso, destfile, g_current_media_number, message_to_screen);
1624	if (res) {
1625	mr_strcat(message_to_screen, "...failed");
1626	} else {
1627	mr_strcat(message_to_screen, "...OK");
1628	}
1629	log_to_screen(message_to_screen);
1630	paranoid_free(message_to_screen);
1631
1632	retval += res;
1633	}
1634
1635	if (bkpinfo->call_make_iso) {
1636	log_msg(2, "bkpinfo->call_make_iso = %s", bkpinfo->call_make_iso);
1637	mds = media_descriptor_string(bkpinfo->backup_media_type);
1638	mr_asprintf(message_to_screen, "Making an ISO (%s #%d)", mds, g_current_media_number);
1639	mr_free(mds);
1640
1641	pause_and_ask_for_cdr(2, &cd_is_mountable); /* if g_current_media_number >= 2 then pause & ask */
1642	if (retval) {
1643	log_to_screen
1644	("Serious error(s) occurred already. I shan't try to write to media.");
1645	} else {
1646	res =
1647	eval_call_to_make_ISO(bkpinfo->call_make_iso, bkpinfo->scratchdir, g_current_media_number, message_to_screen);
1648	if (res) {
1649	log_to_screen("%s...failed to write", message_to_screen);
1650	} else {
1651	log_to_screen("%s...OK", message_to_screen);
1652	mr_asprintf(tmp, "tail -n10 %s \| grep -F ':-('", MONDO_LOGFILE);
1653	if (!run_program_and_log_output(tmp, 1)) {
1654	log_to_screen
1655	("Despite nonfatal errors, growisofs confirms the write was successful.");
1656	}
1657	mr_free(tmp);
1658	}
1659	retval += res;
1660	#ifdef DVDRWFORMAT
1661	mr_asprintf(tmp, "tail -n8 %s \| grep 'blank=full.dvd-compat.DAO'", MONDO_LOGFILE);
1662	if (g_backup_media_type == dvd
1663	&& (res \|\| !run_program_and_log_output(tmp, 1))) {
1664	log_to_screen
1665	("Failed to write to disk. I shall blank it and then try again.");
1666	sleep(5);
1667	sync();
1668	pause_for_N_seconds(5, "Letting DVD drive settle");
1669
1670	// dvd+rw-format --- OPTION 2
1671	if (!bkpinfo->please_dont_eject) {
1672	log_to_screen("Ejecting media to clear drive status.");
1673	eject_device(bkpinfo->media_device);
1674	inject_device(bkpinfo->media_device);
1675	}
1676	pause_for_N_seconds(5, "Letting DVD drive settle");
1677	if (bkpinfo->media_device) {
1678	mr_asprintf(sz_blank_disk, "dvd+rw-format -force %s", bkpinfo->media_device);
1679	} else {
1680	mr_asprintf(sz_blank_disk, "dvd+rw-format");
1681	}
1682	log_msg(3, "sz_blank_disk = '%s'", sz_blank_disk);
1683	res = run_external_binary_with_percentage_indicator_NEW("Blanking DVD disk", sz_blank_disk);
1684	if (res) {
1685	log_to_screen("Warning - format failed. (Was it a DVD-R?) Sleeping for 5 seconds to take a breath...");
1686	pause_for_N_seconds(5, "Letting DVD drive settle... and trying again.");
1687	res = run_external_binary_with_percentage_indicator_NEW("Blanking DVD disk", sz_blank_disk);
1688	if (res) {
1689	log_to_screen("Format failed a second time.");
1690	}
1691	} else {
1692	log_to_screen
1693	("Format succeeded. Sleeping for 5 seconds to take a breath...");
1694	}
1695	mr_free(sz_blank_disk);
1696	pause_for_N_seconds(5, "Letting DVD drive settle");
1697	if (!bkpinfo->please_dont_eject) {
1698	log_to_screen("Ejecting media to clear drive status.");
1699	eject_device(bkpinfo->media_device);
1700	inject_device(bkpinfo->media_device);
1701	}
1702	pause_for_N_seconds(5, "Letting DVD drive settle");
1703	res = eval_call_to_make_ISO(bkpinfo->call_make_iso, bkpinfo->scratchdir, g_current_media_number, message_to_screen);
1704	retval += res;
1705	if (!bkpinfo->please_dont_eject) {
1706	log_to_screen("Ejecting media.");
1707	eject_device(bkpinfo->media_device);
1708	}
1709	if (res) {
1710	log_to_screen("Dagnabbit. It still failed.");
1711	} else {
1712	log_to_screen
1713	("OK, this time I successfully backed up to DVD.");
1714	}
1715	}
1716	mr_free(tmp);
1717	#endif
1718	if (g_backup_media_type == dvd && !bkpinfo->please_dont_eject) {
1719	eject_device(bkpinfo->media_device);
1720	}
1721	}
1722	paranoid_free(message_to_screen);
1723	} else {
1724	mds = media_descriptor_string(bkpinfo->backup_media_type);
1725	mr_asprintf(message_to_screen, "Running mkisofs to make %s #%d", mds, g_current_media_number);
1726	log_msg(1, message_to_screen);
1727	mr_asprintf(result_sz, "Call to mkisofs to make ISO (%s #%d) ", mds, g_current_media_number);
1728	mr_free(mds);
1729	if (bkpinfo->nonbootable_backup) {
1730	log_msg(1, "Making nonbootable backup");
1731	// FIXME --- change mkisofs string to MONDO_MKISOFS_NONBOOTABLE and add ' .' at end
1732	res = eval_call_to_make_ISO("mkisofs -o '_ISO_' -r -p MondoRescue -publisher www.mondorescue.org -A MondoRescue_GPL -V _CD#_ .", destfile, g_current_media_number, message_to_screen);
1733	} else {
1734	log_msg(1, "Making bootable backup");
1735
1736	#ifdef __FreeBSD__
1737	bkpinfo->make_cd_use_lilo = TRUE;
1738	#endif
1739
1740
1741	log_msg(1, "make_cd_use_lilo is actually %d",
1742	bkpinfo->make_cd_use_lilo);
1743	if (bkpinfo->make_cd_use_lilo) {
1744	log_msg(1, "make_cd_use_lilo = TRUE");
1745	// FIXME --- change mkisofs string to MONDO_MKISOFS_REGULAR_SYSLINUX/LILO depending on bkpinfo->make_cd_usE_lilo
1746	// and add ' .' at end
1747	#ifdef __IA64__
1748	log_msg(1, "IA64 --> elilo");
1749	res = eval_call_to_make_ISO("mkisofs -no-emul-boot -b images/mindi-bootroot." IA64_BOOT_SIZE ".img -c boot.cat -o '_ISO_' -J -r -p MondoRescue -publisher www.mondorescue.org -A Mondo_Rescue_GPL -V _CD#_ .", destfile, g_current_media_number, message_to_screen);
1750	#else
1751	// FIXME --- change mkisofs string to MONDO_MKISOFS_REGULAR_SYSLINUX/LILO depending on bkpinfo->make_cd_usE_lilo
1752	// and add ' .' at end
1753	log_msg(1, "Non-ia64 --> lilo");
1754	res =
1755	eval_call_to_make_ISO("mkisofs -b images/mindi-bootroot.2880.img -c boot.cat -o '_ISO_' -J -r -p MondoRescue -publisher www.mondorescue.org -A Mondo_Rescue_GPL -V _CD#_ .", destfile, g_current_media_number, message_to_screen);
1756	#endif
1757	} else {
1758	log_msg(1, "make_cd_use_lilo = FALSE");
1759	log_msg(1, "Isolinux");
1760	res = eval_call_to_make_ISO("mkisofs -no-emul-boot -b isolinux.bin -boot-load-size 4 -boot-info-table -c boot.cat -o '_ISO_' -J -r -p MondoRescue -publisher www.mondorescue.org -A Mondo_Rescue_GPL -V _CD#_ .", destfile, g_current_media_number, message_to_screen);
1761	}
1762	}
1763	paranoid_free(message_to_screen);
1764
1765	if (res) {
1766	mr_strcat(result_sz, "...failed");
1767	} else {
1768	mr_strcat(result_sz, "...OK");
1769	}
1770	log_to_screen(result_sz);
1771	paranoid_free(result_sz);
1772	retval += res;
1773	}
1774
1775	if (bkpinfo->backup_media_type == cdr
1776	\|\| bkpinfo->backup_media_type == cdrw) {
1777	if (is_this_device_mounted(bkpinfo->media_device)) {
1778	log_msg(2, "Warning - %s mounted. I'm unmounting it before I burn to it.", bkpinfo->media_device);
1779	mr_asprintf(tmp, "umount %s", bkpinfo->media_device);
1780	run_program_and_log_output(tmp, FALSE);
1781	mr_free(tmp);
1782	}
1783	}
1784
1785	if (bkpinfo->call_burn_iso) {
1786	log_msg(2, "bkpinfo->call_burn_iso = %s", bkpinfo->call_burn_iso);
1787	mds = media_descriptor_string(bkpinfo->backup_media_type);
1788	mr_asprintf(message_to_screen, "Burning %s #%d", mds, g_current_media_number);
1789	mr_free(mds);
1790	pause_and_ask_for_cdr(2, &cd_is_mountable);
1791	res = eval_call_to_make_ISO(bkpinfo->call_burn_iso, destfile, g_current_media_number, message_to_screen);
1792	if (res) {
1793	mr_strcat(message_to_screen, "...failed");
1794	} else {
1795	mr_strcat(message_to_screen, "...OK");
1796	}
1797	log_to_screen(message_to_screen);
1798	paranoid_free(message_to_screen);
1799
1800	retval += res;
1801	}
1802
1803	if (bkpinfo->call_after_iso) {
1804	mds = media_descriptor_string(bkpinfo->backup_media_type);
1805	mr_asprintf(message_to_screen, "Running post-ISO call (%s #%d)", mds, g_current_media_number);
1806	mr_free(mds);
1807	res = eval_call_to_make_ISO(bkpinfo->call_after_iso, destfile, g_current_media_number, message_to_screen);
1808	if (res) {
1809	mr_strcat(message_to_screen, "...failed");
1810	} else {
1811	mr_strcat(message_to_screen, "...OK");
1812	}
1813	log_to_screen(message_to_screen);
1814	paranoid_free(message_to_screen);
1815
1816	retval += res;
1817	}
1818
1819	chdir(old_pwd);
1820	if (retval) {
1821	log_msg(1, "WARNING - make_iso_fs returned an error");
1822	}
1823	paranoid_free(old_pwd);
1824	return (retval);
1825	}
1826
1827
1828	bool is_dev_an_NTFS_dev(char *bigfile_fname)
1829	{
1830	char *tmp = NULL;
1831	char *command = NULL;
1832	bool ret = TRUE;
1833
1834	mr_asprintf(command, "dd if=%s bs=512 count=1 2> /dev/null \| strings \| head -n1", bigfile_fname);
1835	log_msg(1, "command = '%s'", command);
1836	tmp = call_program_and_get_last_line_of_output(command);
1837	mr_free(command);
1838
1839	log_msg(1, "--> tmp = '%s'", tmp);
1840	if (strstr(tmp, "NTFS")) {
1841	log_it("TRUE");
1842	ret = TRUE;
1843	} else {
1844	log_it("FALSE");
1845	ret = FALSE;
1846	}
1847	mr_free(tmp);
1848	return(ret);
1849	}
1850
1851
1852	/**
1853	* Back up big files by chopping them up.
1854	* This function backs up all "big" files (where "big" depends
1855	* on your backup media) in "chunks" (whose size again depends
1856	* on your media).
1857	*
1858	* @param bkpinfo The backup information structure. Fields used:
1859	* - @c backup_media_type
1860	* - @c optimal_set_size
1861	* @param biggielist_fname The path to a file containing a list of
1862	* all "big" files.
1863	* @return The number of errors encountered (0 for success)
1864	* @see slice_up_file_etc
1865	*/
1866	int
1867	make_slices_and_images(char *biggielist_fname)
1868	{
1869
1870	/@ pointers ****************************************** */
1871	FILE *fin = NULL;
1872
1873	/@ buffers ******************************************* */
1874	char *tmp = NULL;
1875	char *bigfile_fname = NULL;
1876	char *sz_devfile = NULL;
1877	char *ntfsprog_fifo = NULL;
1878	/@ long ********************************************** */
1879	long biggie_file_number = 0;
1880	long noof_biggie_files = 0;
1881	long estimated_total_noof_slices = 0;
1882
1883	/@ int *********************************************** */
1884	int retval = 0;
1885	int res = 0;
1886	pid_t pid;
1887	FILE *ftmp = NULL;
1888	bool delete_when_done;
1889	bool use_ntfsprog;
1890	off_t biggie_fsize;
1891
1892	assert(bkpinfo != NULL);
1893	assert_string_is_neither_NULL_nor_zerolength(biggielist_fname);
1894
1895	estimated_total_noof_slices =
1896	size_of_all_biggiefiles_K() / bkpinfo->optimal_set_size + 1;
1897
1898	log_msg(1, "size of all biggiefiles = %ld",
1899	size_of_all_biggiefiles_K());
1900	log_msg(1, "estimated_total_noof_slices = %ld KB / %ld KB = %ld",
1901	size_of_all_biggiefiles_K(), bkpinfo->optimal_set_size,
1902	estimated_total_noof_slices);
1903
1904	if (length_of_file(biggielist_fname) < 6) {
1905	log_msg(1, "No biggiefiles; fair enough...");
1906	return (0);
1907	}
1908	mr_asprintf(tmp, "I am now backing up all large files.");
1909	log_to_screen(tmp);
1910	noof_biggie_files = count_lines_in_file(biggielist_fname);
1911	open_progress_form("Backing up big files", tmp, "Please wait. This may take some time.", "", estimated_total_noof_slices);
1912	mr_free(tmp);
1913
1914	if (!(fin = fopen(biggielist_fname, "r"))) {
1915	log_OS_error("Unable to openin biggielist");
1916	return (1);
1917	}
1918
1919	for (mr_getline(bigfile_fname, fin); !feof(fin); mr_getline(bigfile_fname, fin), biggie_file_number++) {
1920	use_ntfsprog = FALSE;
1921	if (bigfile_fname[strlen(bigfile_fname) - 1] < 32) {
1922	bigfile_fname[strlen(bigfile_fname) - 1] = '\0';
1923	}
1924	biggie_fsize = length_of_file(bigfile_fname);
1925	delete_when_done = FALSE;
1926
1927	if (!does_file_exist(bigfile_fname)) {
1928	ftmp = fopen(bigfile_fname, "w");
1929	if (ftmp == NULL) {
1930	log_msg(3, "Unable to write to %s", bigfile_fname);
1931	// So skip it as it doesn't exist
1932	mr_free(bigfile_fname);
1933	continue;
1934	} else {
1935	paranoid_fclose(ftmp);
1936	}
1937	delete_when_done = TRUE;
1938	} else {
1939	// Call ntfsclone (formerly partimagehack) if it's a /dev entry
1940	// (i.e. a partition to be imaged)
1941	log_msg(2, "bigfile_fname = %s", bigfile_fname);
1942	use_ntfsprog = FALSE;
1943	if (!strncmp(bigfile_fname, "/dev/", 5) && is_dev_an_NTFS_dev(bigfile_fname)) {
1944	use_ntfsprog = TRUE;
1945	log_msg(2, "Calling ntfsclone in background because %s is an NTFS partition", bigfile_fname);
1946	mr_asprintf(sz_devfile, "%s/%d.%d.000", bkpinfo->tmpdir, (int) (random() % 32768), (int) (random() % 32768));
1947	mkfifo(sz_devfile, 0x770);
1948	ntfsprog_fifo = sz_devfile;
1949	switch (pid = fork()) {
1950	case -1:
1951	mr_free(bigfile_fname);
1952	mr_free(sz_devfile);
1953	fatal_error("Fork failure");
1954	case 0:
1955	log_msg(2, "CHILD - fip - calling feed_into_ntfsprog(%s, %s)", bigfile_fname, sz_devfile);
1956	res = feed_into_ntfsprog(bigfile_fname, sz_devfile);
1957	/* The child needs to unalocate memory as well */
1958	mr_free(bigfile_fname);
1959	mr_free(sz_devfile);
1960	exit(res);
1961	break;
1962	default:
1963	log_msg(2, "feed_into_ntfsprog() called in background --- pid=%ld", (long int) (pid));
1964	mr_free(sz_devfile);
1965	}
1966	}
1967	// Otherwise, use good old 'dd' and 'bzip2'
1968	else {
1969	ntfsprog_fifo = NULL;
1970	}
1971
1972	// Whether partition or biggiefile, just do your thang :-)
1973	if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
1974	write_header_block_to_stream(biggie_fsize, bigfile_fname, use_ntfsprog ? BLK_START_A_PIHBIGGIE : BLK_START_A_NORMBIGGIE);
1975	}
1976	res = slice_up_file_etc(bigfile_fname, ntfsprog_fifo, biggie_file_number, noof_biggie_files, use_ntfsprog);
1977	if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
1978	tmp = calc_checksum_of_file(bigfile_fname);
1979	write_header_block_to_stream((off_t)0, tmp, BLK_STOP_A_BIGGIE);
1980	mr_free(tmp);
1981	}
1982	retval += res;
1983	mr_asprintf(tmp, "Archiving %s ... ", bigfile_fname);
1984	if (res) {
1985	mr_strcat(tmp, "Failed!");
1986	} else {
1987	mr_strcat(tmp, "OK");
1988	}
1989	if (delete_when_done) {
1990	unlink(bigfile_fname);
1991	delete_when_done = FALSE;
1992	}
1993	}
1994	mr_free(bigfile_fname);
1995	if (!g_text_mode) {
1996	newtDrawRootText(0, g_noof_rows - 2, tmp);
1997	newtRefresh();
1998	}
1999	mr_free(tmp);
2000	}
2001	mr_free(bigfile_fname);
2002
2003	log_msg(1, "Finished backing up bigfiles");
2004	log_msg(1, "estimated slices = %ld; actual slices = %ld",
2005	estimated_total_noof_slices, g_current_progress);
2006	close_progress_form();
2007	paranoid_fclose(fin);
2008	return (retval);
2009	}
2010
2011
2012
2013
2014	/**
2015	* Single-threaded version of @c make_afioballs_and_images().
2016	* @see make_afioballs_and_images
2017	*/
2018	int make_afioballs_and_images_OLD()
2019	{
2020
2021	/@ int ************************************************* */
2022	int retval = 0;
2023	long int curr_set_no = 0L;
2024	int res = 0;
2025
2026	/@ buffers ********************************************* */
2027	char *curr_filelist_fname = NULL;
2028	char *curr_afioball_fname = NULL;
2029	char *curr_xattr_list_fname = NULL;
2030	char *curr_acl_list_fname = NULL;
2031	char *tmp = NULL;
2032	char *media_usage_comment = NULL;
2033
2034	log_to_screen("Archiving regular files");
2035
2036	open_progress_form("Backing up filesystem",
2037	"I am backing up your live filesystem now.",
2038	"Please wait. This may take a couple of hours.",
2039	"Working...",
2040	get_last_filelist_number() + 1);
2041
2042	for (; does_file_exist(curr_filelist_fname); curr_set_no++) {
2043	/* backup this set of files */
2044	mr_asprintf(curr_filelist_fname, FILELIST_FNAME_RAW_SZ, bkpinfo->tmpdir, curr_set_no);
2045	if (! does_file_exist(curr_filelist_fname)) {
2046	mr_free(curr_filelist_fname);
2047	break;
2048	}
2049
2050	mr_asprintf(curr_afioball_fname, AFIOBALL_FNAME_RAW_SZ, bkpinfo->tmpdir, curr_set_no, bkpinfo->zip_suffix);
2051
2052	log_msg(1, "EXAT'g set %ld", curr_set_no);
2053	if (g_getfattr) {
2054	mr_asprintf(curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ, bkpinfo->tmpdir, curr_set_no);
2055	get_fattr_list(curr_filelist_fname, curr_xattr_list_fname);
2056	}
2057	if (g_getfacl) {
2058	mr_asprintf(curr_acl_list_fname, ACL_LIST_FNAME_RAW_SZ, bkpinfo->tmpdir, curr_set_no);
2059	get_acl_list(curr_filelist_fname, curr_acl_list_fname);
2060	}
2061
2062	log_msg(1, "Archiving set %ld", curr_set_no);
2063	res =
2064	archive_this_fileset(curr_filelist_fname,
2065	curr_afioball_fname, curr_set_no);
2066	retval += res;
2067	if (res) {
2068	log_to_screen("Errors occurred while archiving set %ld. Perhaps your live filesystem changed?", curr_set_no);
2069	}
2070
2071	/* copy to CD (scratchdir) ... and an actual CD-R if necessary */
2072	if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
2073	register_in_tape_catalog(fileset, curr_set_no, -1, curr_afioball_fname);
2074	maintain_collection_of_recent_archives(curr_afioball_fname);
2075	log_it("Writing EXAT files");
2076	res +=
2077	write_EXAT_files_to_tape(curr_xattr_list_fname,
2078	curr_acl_list_fname);
2079	// archives themselves
2080	res = move_files_to_stream(curr_afioball_fname, NULL);
2081	} else {
2082	if (g_getfacl) {
2083	if (g_getfattr) {
2084	res = move_files_to_cd(curr_filelist_fname,
2085	curr_xattr_list_fname,
2086	curr_acl_list_fname,
2087	curr_afioball_fname, NULL);
2088	} else {
2089	res = move_files_to_cd(curr_filelist_fname,
2090	curr_acl_list_fname,
2091	curr_afioball_fname, NULL);
2092	}
2093	} else {
2094	if (g_getfattr) {
2095	res = move_files_to_cd(curr_filelist_fname,
2096	curr_xattr_list_fname,
2097	curr_afioball_fname, NULL);
2098	} else {
2099	res = move_files_to_cd(curr_filelist_fname,
2100	curr_afioball_fname, NULL);
2101	}
2102	}
2103	}
2104	if (g_getfattr) {
2105	mr_free(curr_xattr_list_fname);
2106	}
2107	if (g_getfacl) {
2108	mr_free(curr_acl_list_fname);
2109	}
2110	retval += res;
2111	g_current_progress++;
2112
2113	media_usage_comment = percent_media_full_comment();
2114	update_progress_form(media_usage_comment);
2115	mr_free(media_usage_comment);
2116
2117	if (res) {
2118	log_to_screen("Failed to add archive %ld's files to CD dir\n", curr_set_no);
2119	fatal_error("Is your hard disk is full? If not, please send the author the logfile.");
2120	}
2121	mr_free(curr_filelist_fname);
2122	mr_free(curr_afioball_fname);
2123	}
2124	close_progress_form();
2125	mr_asprintf(tmp, "Your regular files have been archived ");
2126	if (retval) {
2127	mr_strcat(tmp, "(with errors).");
2128	} else {
2129	mr_strcat(tmp, "successfully.");
2130	}
2131	log_to_screen(tmp);
2132	mr_free(tmp);
2133	return (retval);
2134	}
2135
2136	/* @} - end of LLarchiveGroup */
2137
2138
2139	/**
2140	* Wrapper around @c make_afioballs_and_images().
2141	* @param bkpinfo the backup information structure. Only the
2142	* @c backup_media_type field is used within this function.
2143	* @return return code of make_afioballs_and_images
2144	* @see make_afioballs_and_images
2145	* @ingroup MLarchiveGroup
2146	*/
2147	int make_those_afios_phase()
2148	{
2149	/@ int ****************************************** */
2150	int res = 0;
2151	int retval = 0;
2152
2153	assert(bkpinfo != NULL);
2154
2155	mvaddstr_and_log_it(g_currentY, 0,
2156	"Archiving regular files to media ");
2157
2158	if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
2159	write_header_block_to_stream((off_t)0, "start-of-afioballs",
2160	BLK_START_AFIOBALLS);
2161	#if __FreeBSD__ == 5
2162	log_msg(1,
2163	"Using single-threaded make_afioballs_and_images() to suit b0rken FreeBSD 5.0");
2164	res = make_afioballs_and_images_OLD();
2165	#else
2166	res = make_afioballs_and_images_OLD();
2167	#endif
2168	write_header_block_to_stream((off_t)0, "stop-afioballs",
2169	BLK_STOP_AFIOBALLS);
2170	} else {
2171	res = make_afioballs_and_images();
2172	}
2173
2174	retval += res;
2175	if (res) {
2176	mvaddstr_and_log_it(g_currentY++, 74, "Errors.");
2177	log_msg(1, "make_afioballs_and_images returned an error");
2178	} else {
2179	mvaddstr_and_log_it(g_currentY++, 74, "Done.");
2180	}
2181	return (retval);
2182	}
2183
2184	/**
2185	* Wrapper around @c make_slices_and_images().
2186	* @param bkpinfo The backup information structure. Fields used:
2187	* - @c backup_media_type
2188	* - @c scratchdir
2189	* - @c tmpdir
2190	* @return The number of errors encountered (0 for success)
2191	* @ingroup MLarchiveGroup
2192	*/
2193	int make_those_slices_phase()
2194	{
2195
2196	/@ int **************************************************** */
2197	int res = 0;
2198	int retval = 0;
2199
2200	/@ buffers ************************************************* */
2201	char *biggielist = NULL;
2202	char *command = NULL;
2203	char *blah = NULL;
2204	char *xattr_fname = NULL;
2205	char *acl_fname = NULL;
2206
2207	assert(bkpinfo != NULL);
2208	/* slice big files */
2209	mvaddstr_and_log_it(g_currentY, 0,
2210	"Archiving large files to media ");
2211	mr_asprintf(biggielist, "%s/archives/biggielist.txt", bkpinfo->scratchdir);
2212	if (g_getfattr) {
2213	mr_asprintf(xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
2214	}
2215	if (g_getfacl) {
2216	mr_asprintf(acl_fname, ACL_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
2217	}
2218
2219	mr_asprintf(command, "cp %s/biggielist.txt %s", bkpinfo->tmpdir,
2220	biggielist);
2221	paranoid_system(command);
2222	mr_free(command);
2223
2224	mr_asprintf(blah, "biggielist = %s", biggielist);
2225	log_msg(2, blah);
2226	mr_free(blah);
2227
2228	if (!does_file_exist(biggielist)) {
2229	log_msg(1, "BTW, the biggielist does not exist");
2230	}
2231
2232	if (g_getfattr) {
2233	get_fattr_list(biggielist, xattr_fname);
2234	mr_asprintf(command, "cp %s %s/archives/", xattr_fname, bkpinfo->scratchdir);
2235	paranoid_system(command);
2236	mr_free(command);
2237	}
2238	if (g_getfacl) {
2239	get_acl_list(biggielist, acl_fname);
2240	mr_asprintf(command, "cp %s %s/archives/", acl_fname, bkpinfo->scratchdir);
2241	paranoid_system(command);
2242	mr_free(command);
2243	}
2244
2245	if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
2246	res += write_EXAT_files_to_tape(xattr_fname, acl_fname);
2247	mr_asprintf(blah, "%ld", count_lines_in_file(biggielist));
2248	write_header_block_to_stream((off_t)0, blah, BLK_START_BIGGIEFILES);
2249	mr_free(blah);
2250	}
2251	res = make_slices_and_images(biggielist);
2252	if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
2253	write_header_block_to_stream((off_t)0, "end-of-biggiefiles",
2254	BLK_STOP_BIGGIEFILES);
2255	}
2256	retval += res;
2257	if (res) {
2258	log_msg(1, "make_slices_and_images returned an error");
2259	mvaddstr_and_log_it(g_currentY++, 74, "Errors.");
2260	} else {
2261	mvaddstr_and_log_it(g_currentY++, 74, "Done.");
2262	}
2263	mr_free(biggielist);
2264	mr_free(xattr_fname);
2265	mr_free(acl_fname);
2266	return (retval);
2267	}
2268
2269
2270	/**
2271	* @addtogroup LLarchiveGroup
2272	* @{
2273	*/
2274	/**
2275	* Function pointer to an appropriate @c move_files_to_cd routine.
2276	* You can set this to your own function (for example, one to
2277	* transfer files over the network) or leave it as is.
2278	*/
2279	int (move_files_to_cd) (char , ...) =
2280	_move_files_to_cd;
2281
2282	/**
2283	* Move some files to the ISO scratch directory.
2284	* This function moves files specified as parameters, into the directory
2285	* @c bkpinfo->scratchdir, where the files that will be stored on the next
2286	* CD are waiting.
2287	*
2288	* @param bkpinfo The backup information structure. Fields used:
2289	* - @c media_size
2290	* - @c scratchdir
2291	* @param files_to_add The files to add to the scratchdir.
2292	* @warning The list of @c files_to_add must be terminated with @c NULL.
2293	* @note If and when the space occupied by the scratchdir would exceed
2294	* the capacity of the current CD,
2295	* <tt>write_iso_and_go_on(bkpinfo, FALSE)</tt> is called and the
2296	* scratchdir is emptied.
2297	*
2298	* @return The number of errors encountered (0 for success)
2299	*/
2300	int _move_files_to_cd(char *files_to_add, ...)
2301	{
2302
2303	/@ int *********************************************************** */
2304	int retval = 0;
2305	int res = 0;
2306
2307	/@ buffers ******************************************************* */
2308	char *tmp = NULL;
2309	char *curr_file = NULL;
2310	char *cf;
2311
2312	/@ long *********************************************************** */
2313	va_list ap;
2314	long long would_occupy;
2315
2316	assert(bkpinfo != NULL);
2317	would_occupy = space_occupied_by_cd(bkpinfo->scratchdir);
2318	va_start(ap, files_to_add); // initialize the variable arguments
2319	for (cf = files_to_add; cf != NULL; cf = va_arg(ap, char *)) {
2320	if (!cf) {
2321	continue;
2322	}
2323	mr_asprintf(curr_file, "%s", cf);
2324	if (!does_file_exist(curr_file)) {
2325	log_msg(1,
2326	"Warning - you're trying to add a non-existent file - '%s' to the CD",
2327	curr_file);
2328	} else {
2329	log_msg(8, "Trying to add file %s to CD", curr_file);
2330	would_occupy += length_of_file(curr_file) / 1024;
2331	}
2332	mr_free(curr_file);
2333	}
2334	va_end(ap);
2335
2336	if (bkpinfo->media_size[g_current_media_number] <= 0) {
2337	fatal_error("move_files_to_cd() - unknown media size");
2338	}
2339	if (would_occupy / 1024 > bkpinfo->media_size[g_current_media_number]) {
2340	res = write_iso_and_go_on(FALSE); /* FALSE because this is not the last CD we'll write */
2341	retval += res;
2342	if (res) {
2343	log_msg(1, "WARNING - write_iso_and_go_on returned an error");
2344	}
2345	}
2346
2347	va_start(ap, files_to_add); // initialize the variable arguments
2348	for (cf = files_to_add; cf != NULL; cf = va_arg(ap, char *)) {
2349	if (!cf) {
2350	continue;
2351	}
2352	mr_asprintf(curr_file, "%s", cf);
2353
2354	mr_asprintf(tmp, "mv -f %s %s/archives/", curr_file, bkpinfo->scratchdir);
2355	mr_free(curr_file);
2356	res = run_program_and_log_output(tmp, 5);
2357	retval += res;
2358	if (res) {
2359	log_msg(1, "(move_files_to_cd) '%s' failed", tmp);
2360	} else {
2361	log_msg(8, "Moved %s to CD OK", tmp);
2362	}
2363	mr_free(tmp);
2364	}
2365	va_end(ap);
2366
2367	if (retval) {
2368	log_msg(1,
2369	"Warning - errors occurred while I was adding files to CD dir");
2370	}
2371	return (retval);
2372	}
2373
2374	/* @} - end of LLarchiveGroup */
2375
2376
2377	/**
2378	* @addtogroup LLarchiveGroup
2379	* @{
2380	*/
2381	/**
2382	* Function pointer to an appropriate @c move_files_to_stream routine.
2383	* You can set this to your own function (for example, one to
2384	* transfer files over the network) or leave it as is.
2385	*/
2386	int (move_files_to_stream) (char , ...) =
2387	_move_files_to_stream;
2388
2389	/**
2390	* Copy some files to tape.
2391	* This function copies the files specified as parameters into the tape stream.
2392	*
2393	* @param bkpinfo The backup information structure. Used only in the call to
2394	* @c write_file_to_stream_from_file().
2395	*
2396	* @param files_to_add The files to copy to the tape stream.
2397	* @warning The list of @c files_to_add must be terminated with @c NULL.
2398	* @note Files may be split across multiple tapes if necessary.
2399	*
2400	* @return The number of errors encountered (0 for success)
2401	*/
2402	int
2403	_move_files_to_stream(char *files_to_add, ...)
2404	{
2405
2406	/@ int *********************************************************** */
2407	int retval = 0;
2408	int res = 0;
2409	/@ buffers ******************************************************* */
2410
2411	/@ char ********************************************************** */
2412	char start_chr;
2413	char stop_chr;
2414	char *curr_file = NULL;
2415	char *cf;
2416	/@ long long ***************************************************** */
2417	off_t length_of_incoming_file = (off_t)0;
2418	t_archtype type;
2419	va_list ap;
2420
2421	assert(bkpinfo != NULL);
2422	va_start(ap, files_to_add);
2423	for (cf = files_to_add; cf != NULL; cf = va_arg(ap, char *)) {
2424	if (!cf) {
2425	continue;
2426	}
2427	mr_asprintf(curr_file, "%s", cf);
2428	if (!does_file_exist(curr_file)) {
2429	log_msg(1,
2430	"Warning - you're trying to add a non-existent file - '%s' to the tape",
2431	curr_file);
2432	}
2433	/* create header chars */
2434	start_chr = BLK_START_AN_AFIO_OR_SLICE;
2435	stop_chr = BLK_STOP_AN_AFIO_OR_SLICE;
2436	/* ask for new tape if necessary */
2437	length_of_incoming_file = length_of_file(curr_file);
2438	write_header_block_to_stream(length_of_incoming_file, curr_file,
2439	start_chr);
2440	if (strstr(curr_file, ".afio.") \|\| strstr(curr_file, ".star.")) {
2441	type = fileset;
2442	} else if (strstr(curr_file, "slice")) {
2443	type = biggieslice;
2444	} else {
2445	type = other;
2446	}
2447	res = write_file_to_stream_from_file(curr_file);
2448	retval += res;
2449	unlink(curr_file);
2450	mr_free(curr_file);
2451	/* write closing header */
2452	write_header_block_to_stream((off_t)0, "finished-writing-file", stop_chr);
2453	}
2454	va_end(ap);
2455
2456	if (retval) {
2457	log_msg(1,
2458	"Warning - errors occurred while I was adding file to tape");
2459	}
2460	return (retval);
2461	}
2462
2463	/* @} - end of LLarchiveGroup */
2464
2465
2466
2467	/**
2468	* @addtogroup utilityGroup
2469	* @{
2470	*/
2471	/**
2472	* Make sure the user has a valid CD-R(W) in the CD drive.
2473	* @return the CD-R(W) device checked or NULL
2474	*/
2475	char *interrogate_disk_currently_in_cdrw_drive() {
2476	char *cdrecord = NULL;
2477	char *cdrw_dev = NULL;
2478
2479	cdrw_dev = find_cdrw_device();
2480	if (cdrw_dev != NULL) {
2481	if (!system("which cdrecord > /dev/null 2> /dev/null")) {
2482	mr_asprintf(cdrecord, "cdrecord dev=%s -atip", cdrw_dev);
2483	} else if (!system("which dvdrecord > /dev/null 2> /dev/null")) {
2484	mr_asprintf(cdrecord, "cdrecord dev=%s -atip", cdrw_dev);
2485	} else {
2486	log_msg(2, "Oh well. I guess I'll just pray then.");
2487	}
2488	if (cdrecord != NULL) {
2489	retract_CD_tray_and_defeat_autorun();
2490	if (run_program_and_log_output(cdrecord, 5)) {
2491	/* As it didn't work, return NULL */
2492	mr_free(cdrw_dev);
2493	}
2494	}
2495	mr_free(cdrecord);
2496	}
2497	return(cdrw_dev);
2498	}
2499
2500
2501	/**
2502	* Asks the user to put a CD-R(W) in the drive.
2503	* @param ask_for_one_if_more_than_this (unused)
2504	* @param pmountable If non-NULL, pointed-to value is set to TRUE if the CD is mountable, FALSE otherwise.
2505	*/
2506	void
2507	pause_and_ask_for_cdr(int ask_for_one_if_more_than_this, bool * pmountable)
2508	{
2509
2510	/@ buffers ******************************************** */
2511	char *tmp = NULL;
2512	char *cdrom_dev = NULL;
2513	char *cdrw_dev = NULL;
2514	char *our_serial_str = NULL;
2515	bool ok_go_ahead_burn_it;
2516	int cd_number = -1;
2517	int attempt_to_mount_returned_this = 999;
2518	char *mtpt = NULL;
2519	char *szcdno = NULL;
2520	char *szserfname = NULL;
2521	char *szunmount = NULL;
2522	char *mds = NULL;
2523
2524	mds = media_descriptor_string(g_backup_media_type);
2525	log_to_screen("I am about to burn %s #%d", mds, g_current_media_number);
2526	mr_free(mds);
2527	if (g_current_media_number < ask_for_one_if_more_than_this) {
2528	return;
2529	}
2530	log_to_screen("Scanning CD-ROM drive...");
2531	sprintf(mtpt, "%s/cd.mtpt", bkpinfo->tmpdir);
2532	make_hole_for_dir(mtpt);
2533
2534	gotos_make_me_puke:
2535	ok_go_ahead_burn_it = TRUE;
2536	if ((cdrom_dev = find_cdrom_device(FALSE)) != NULL) {
2537	/* When enabled, it made CD eject-and-retract when wrong CD inserted.. Weird
2538	log_msg(2, "paafcd: Retracting CD-ROM drive if possible" );
2539	retract_CD_tray_and_defeat_autorun();
2540	*/
2541	mr_asprintf(tmp, "umount %s", cdrom_dev);
2542	run_program_and_log_output(tmp, 1);
2543	mr_asprintf(szcdno, "%s/archives/THIS-CD-NUMBER", mtpt);
2544	mr_asprintf(szserfname, "%s/archives/SERIAL-STRING", mtpt);
2545	mr_asprintf(szunmount, "umount %s", mtpt);
2546	cd_number = -1;
2547	mr_asprintf(tmp, "mount %s %s", cdrom_dev, mtpt);
2548	mr_asprintf(our_serial_str, "%s", "");
2549	attempt_to_mount_returned_this = run_program_and_log_output(tmp, 1);
2550	mr_free(tmp);
2551
2552	if (attempt_to_mount_returned_this) {
2553	log_msg(4, "Failed to mount %s at %s", cdrom_dev, mtpt);
2554	log_to_screen("If there's a CD/DVD in the drive, it's blank.");
2555	} else if (!does_file_exist(szcdno) \|\| !does_file_exist(szserfname)) {
2556	mds = media_descriptor_string(g_backup_media_type);
2557	log_to_screen("%s has data on it but it's probably not a Mondo CD.", mds);
2558	mr_free(mds);
2559	} else {
2560	mds = media_descriptor_string(g_backup_media_type);
2561	log_to_screen("%s found in drive. It's a Mondo disk.", mds);
2562	mr_free(mds);
2563
2564	tmp = last_line_of_file(szcdno);
2565	cd_number = atoi(tmp);
2566	mr_free(tmp);
2567
2568	mr_asprintf(tmp, "cat %s 2> /dev/null", szserfname);
2569	mr_free(our_serial_str);
2570	our_serial_str = call_program_and_get_last_line_of_output(tmp);
2571	mr_free(tmp);
2572	// FIXME - should be able to use last_line_of_file(), surely?
2573	}
2574	mr_free(szcdno);
2575	mr_free(szserfname);
2576
2577	run_program_and_log_output(szunmount, 1);
2578	mr_free(szunmount);
2579
2580	log_msg(2, "paafcd: cd_number = %d", cd_number);
2581	log_msg(2, "our serial str = %s; g_serial_string = %s", our_serial_str, g_serial_string);
2582	if (cd_number > 0 && !strcmp(our_serial_str, g_serial_string)) {
2583	mds = media_descriptor_string(g_backup_media_type);
2584	log_msg(2, "This %s is part of this backup set!", mds);
2585	ok_go_ahead_burn_it = FALSE;
2586	if (cd_number == g_current_media_number - 1) {
2587	log_to_screen("I think you've left the previous %s in the drive.", mds);
2588	} else {
2589	log_to_screen("Please remove this %s. It is part of the backup set you're making now.", mds);
2590	}
2591	mr_free(mds);
2592
2593	} else {
2594	log_to_screen("...but not part of _our_ backup set.");
2595	}
2596	mr_free(our_serial_str);
2597	} else {
2598	mds = media_descriptor_string(g_backup_media_type);
2599	log_msg(2,
2600	"paafcd: Can't find CD-ROM drive. Perhaps it has a blank %s in it?", mds);
2601	cdrw_dev = interrogate_disk_currently_in_cdrw_drive();
2602	if (cdrw_dev == NULL) {
2603	ok_go_ahead_burn_it = FALSE;
2604	log_to_screen("There isn't a writable %s in the drive.", mds);
2605	}
2606	mr_free(cdrw_dev);
2607	mr_free(mds);
2608	}
2609
2610	if (!ok_go_ahead_burn_it) {
2611	eject_device(cdrom_dev);
2612	mds = media_descriptor_string(g_backup_media_type);
2613	mr_asprintf(tmp, "I am about to burn %s #%d of the backup set. Please insert %s and press Enter.", mds, g_current_media_number, mds);
2614	mr_free(mds);
2615
2616	popup_and_OK(tmp);
2617	mr_free(tmp);
2618	mr_free(cdrom_dev);
2619	goto gotos_make_me_puke;
2620	} else {
2621	log_msg(2, "paafcd: OK, going ahead and burning it.");
2622	}
2623	mr_free(cdrom_dev);
2624
2625	mds = media_descriptor_string(g_backup_media_type);
2626	log_msg(2, "paafcd: OK, I assume I have a blank/reusable %s in the drive...", mds);
2627
2628	log_to_screen("Proceeding w/ %s in drive.", mds);
2629	mr_free(mds);
2630
2631	paranoid_free(mtpt);
2632	if (pmountable) {
2633	if (attempt_to_mount_returned_this) {
2634	*pmountable = FALSE;
2635	} else {
2636	*pmountable = TRUE;
2637	}
2638	}
2639
2640	}
2641
2642
2643	/**
2644	* Set the <tt>N</tt>th bit of @c array to @c true_or_false.
2645	* @param array The bit array (as a @c char pointer).
2646	* @param N The bit number to set or reset.
2647	* @param true_or_false If TRUE then set bit @c N, if FALSE then reset bit @c N.
2648	* @see get_bit_N_of_array
2649	*/
2650	void set_bit_N_of_array(char *array, int N, bool true_or_false)
2651	{
2652	int bit_number;
2653	int mask, orig_val, to_add;
2654	int element_number;
2655
2656	assert(array != NULL);
2657
2658	element_number = N / 8;
2659	bit_number = N % 8;
2660	to_add = (1 << bit_number);
2661	mask = 255 - to_add;
2662	orig_val = array[element_number] & mask;
2663	// log_it("array[%d]=%02x; %02x&%02x = %02x", element_number, array[element_number], mask, orig_val);
2664	if (true_or_false) {
2665	array[element_number] = orig_val \| to_add;
2666	}
2667	}
2668
2669	/* @} - end of utilityGroup */
2670
2671
2672	/**
2673	* Chop up @c filename.
2674	* @param bkpinfo The backup information structure. Fields used:
2675	* - @c backup_media_type
2676	* - @c compression_level
2677	* - @c optimal_set_size
2678	* - @c tmpdir
2679	* - @c use_lzo
2680	* - @c zip_exe
2681	* - @c zip_suffix
2682	*
2683	* @param biggie_filename The file to chop up.
2684	* @param ntfsprog_fifo The FIFO to ntfsclone if this is an imagedev, NULL otherwise.
2685	* @param biggie_file_number The sequence number of this biggie file (starting from 0).
2686	* @param noof_biggie_files The number of biggie files there are total.
2687	* @return The number of errors encountered (0 for success)
2688	* @see make_slices_and_images
2689	* @ingroup LLarchiveGroup
2690	*/
2691	int
2692	slice_up_file_etc(char biggie_filename, char ntfsprog_fifo, long biggie_file_number, long noof_biggie_files, bool use_ntfsprog) {
2693
2694	/@ buffers ************************************************* */
2695	char *tmp = NULL;
2696	char *checksum_line = NULL;
2697	char *command = NULL;
2698	char *tempblock;
2699	char *curr_slice_fname_uncompressed = NULL;
2700	char *curr_slice_fname_compressed = NULL;
2701	char *file_to_archive = NULL;
2702	char *file_to_openin = NULL;
2703	/@ pointers ************************************************* */
2704	char *pB = NULL;
2705	FILE *fin = NULL;
2706	FILE *fout = NULL;
2707
2708	/@ bool ***************************************************** */
2709	bool finished = FALSE;
2710
2711	/@ long ***************************************************** */
2712	size_t blksize = (size_t)0;
2713	long slice_num = 0L;
2714	long i = 0L;
2715	bool should_I_compress_slices = TRUE;
2716	char *suffix = NULL; // for compressed slices
2717
2718	/@ long long ************************************************* */
2719	off_t totalread = (off_t)0;
2720	off_t totallength = (off_t)0;
2721
2722	/@ int ******************************************************* */
2723	int retval = 0;
2724	int res = 0;
2725
2726	/@ structures ************************************************* */
2727	struct s_filename_and_lstat_info biggiestruct;
2728
2729	assert(bkpinfo != NULL);
2730	assert_string_is_neither_NULL_nor_zerolength(biggie_filename);
2731
2732	biggiestruct.for_backward_compatibility = '\n';
2733	biggiestruct.use_ntfsprog = use_ntfsprog;
2734	if (is_this_file_compressed(biggie_filename) \|\| bkpinfo->compression_level == 0) {
2735	mr_asprintf(suffix, "%s", "");
2736	should_I_compress_slices = FALSE;
2737	} else {
2738	mr_asprintf(suffix, "%s", bkpinfo->zip_suffix);
2739	should_I_compress_slices = TRUE;
2740	}
2741
2742	if (bkpinfo->optimal_set_size < 999L) {
2743	fatal_error("bkpinfo->optimal_set_size is insanely small");
2744	}
2745
2746	if (ntfsprog_fifo) {
2747	file_to_openin = ntfsprog_fifo;
2748	mr_asprintf(checksum_line, "IGNORE");
2749	log_msg(2, "Not calculating checksum for %s: it would take too long", biggie_filename);
2750	tmp = find_home_of_exe("ntfsresize");
2751	if (!tmp) {
2752	mr_free(tmp);
2753	fatal_error("ntfsresize not found");
2754	}
2755	mr_free(tmp);
2756
2757	mr_asprintf(command, "ntfsresize --force --info %s\|grep '^You might resize at '\|cut -d' ' -f5", biggie_filename);
2758	log_it("command = %s", command);
2759	tmp = call_program_and_get_last_line_of_output(command);
2760	mr_free(command);
2761	log_it("res of it = %s", tmp);
2762	totallength = (off_t)atoll(tmp);
2763	mr_free(tmp);
2764	} else {
2765	file_to_openin = biggie_filename;
2766	if (strchr(biggie_filename,'\'') != NULL) {
2767	mr_asprintf(command, "md5sum \"%s\"", biggie_filename);
2768	} else {
2769	mr_asprintf(command, "md5sum '%s'", biggie_filename);
2770	}
2771	if (!(fin = popen(command, "r"))) {
2772	log_OS_error("Unable to popen-in command");
2773	mr_free(suffix);
2774	return (1);
2775	}
2776	mr_free(command);
2777	mr_getline(checksum_line, fin);
2778	pclose(fin);
2779	totallength = length_of_file (biggie_filename);
2780	}
2781	lstat(biggie_filename, &biggiestruct.properties);
2782	strcpy(biggiestruct.filename, biggie_filename);
2783	pB = strchr(checksum_line, ' ');
2784	if (!pB) {
2785	pB = strchr(checksum_line, '\t');
2786	}
2787	if (pB) {
2788	*pB = '\0';
2789	}
2790	strcpy(biggiestruct.checksum, checksum_line);
2791	mr_free(checksum_line);
2792
2793	mr_asprintf(tmp, "%s", slice_fname(biggie_file_number, 0, bkpinfo->tmpdir, ""));
2794	fout = fopen(tmp, "w");
2795	if (fout == NULL) {
2796	log_msg(1, "Unable to open and write to %s\n", tmp);
2797	mr_free(tmp);
2798	mr_free(suffix);
2799	return (1);
2800	}
2801	mr_free(tmp);
2802
2803	(void) fwrite((void *) &biggiestruct, 1, sizeof(biggiestruct), fout);
2804	fclose(fout);
2805
2806	log_msg(1, "Opening in %s; slicing it and writing to CD/tape", file_to_openin);
2807	if (!(fin = fopen(file_to_openin, "r"))) {
2808	log_OS_error("Unable to openin biggie_filename");
2809	log_to_screen("Cannot archive bigfile '%s': not found", biggie_filename);
2810
2811	mr_free(suffix);
2812	return (1);
2813	}
2814	if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
2815	res =
2816	move_files_to_stream(slice_fname(biggie_file_number, 0,
2817	bkpinfo->tmpdir, ""), NULL);
2818	} else {
2819	res =
2820	move_files_to_cd(slice_fname(biggie_file_number, 0,
2821	bkpinfo->tmpdir, ""), NULL);
2822	}
2823	i = bkpinfo->optimal_set_size / 256;
2824	for (slice_num = 1; !finished; slice_num++) {
2825	mr_asprintf(curr_slice_fname_uncompressed, "%s", slice_fname(biggie_file_number, slice_num, bkpinfo->tmpdir, ""));
2826	mr_asprintf(curr_slice_fname_compressed, "%s", slice_fname(biggie_file_number, slice_num, bkpinfo->tmpdir, suffix));
2827
2828
2829	tmp = percent_media_full_comment();
2830	update_progress_form(tmp);
2831	mr_free(tmp);
2832
2833	if (!(fout = fopen(curr_slice_fname_uncompressed, "w"))) {
2834	log_OS_error(curr_slice_fname_uncompressed);
2835	mr_free(suffix);
2836	return (1);
2837	}
2838	if ((i == bkpinfo->optimal_set_size / 256) && (totalread < 1.1 * totallength)) {
2839	tempblock = mr_malloc(256 * 1024);
2840	for (i = 0L; i < bkpinfo->optimal_set_size / 256; i++) {
2841	blksize = fread(tempblock, 1, 256 * 1024, fin);
2842	if (blksize > 0) {
2843	totalread = totalread + blksize;
2844	(void) fwrite(tempblock, 1, blksize, fout);
2845	} else {
2846	break;
2847	}
2848	}
2849	mr_free(tempblock);
2850	} else {
2851	i = 0L;
2852	}
2853	fclose(fout);
2854	if (i > 0L) // length_of_file (curr_slice_fname_uncompressed)
2855	{
2856	if (!does_file_exist(curr_slice_fname_uncompressed)) {
2857	log_msg(2, "Warning - '%s' doesn't exist. How can I compress slice?", curr_slice_fname_uncompressed);
2858	}
2859	if (should_I_compress_slices && bkpinfo->compression_level > 0) {
2860	mr_asprintf(command, "%s -%d %s", bkpinfo->zip_exe, bkpinfo->compression_level, curr_slice_fname_uncompressed);
2861	log_msg(2, command);
2862	if ((res = system(command))) {
2863	log_OS_error(command);
2864	}
2865	// did_I_compress_slice = TRUE;
2866	} else {
2867	mr_asprintf(command, "mv %s %s 2>> %s", curr_slice_fname_uncompressed, curr_slice_fname_compressed, MONDO_LOGFILE);
2868	res = 0; // don't do it :)
2869	// did_I_compress_slice = FALSE;
2870	}
2871	mr_free(command);
2872
2873	retval += res;
2874	if (res) {
2875	log_msg(2, "Failed to compress the slice");
2876	}
2877	if (bkpinfo->use_lzo && strcmp(curr_slice_fname_compressed, curr_slice_fname_uncompressed)) {
2878	unlink(curr_slice_fname_uncompressed);
2879	}
2880	if (res) {
2881	mr_asprintf(tmp, "Problem with slice # %ld", slice_num);
2882	} else {
2883	mr_asprintf(tmp, "%s - Bigfile #%ld, slice #%ld compressed OK ", biggie_filename, biggie_file_number + 1, slice_num);
2884	}
2885	if (!g_text_mode) {
2886	newtDrawRootText(0, g_noof_rows - 2, tmp);
2887	newtRefresh();
2888	} else {
2889	log_msg(2, tmp);
2890	}
2891	mr_free(tmp);
2892
2893	mr_asprintf(file_to_archive, "%s", curr_slice_fname_compressed);
2894	g_current_progress++;
2895	} else { /* if i==0 then ... */
2896
2897	finished = TRUE;
2898	mr_asprintf(file_to_archive, "%s", curr_slice_fname_uncompressed);
2899	if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
2900	break;
2901	}
2902	}
2903	mr_free(curr_slice_fname_uncompressed);
2904	mr_free(curr_slice_fname_compressed);
2905
2906	if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
2907	register_in_tape_catalog(biggieslice, biggie_file_number, slice_num, file_to_archive);
2908	maintain_collection_of_recent_archives(file_to_archive);
2909	res = move_files_to_stream(file_to_archive, NULL);
2910	} else {
2911	res = move_files_to_cd(file_to_archive, NULL);
2912	}
2913	mr_free(file_to_archive);
2914
2915	retval += res;
2916	if (res) {
2917	log_to_screen("Failed to add slice %ld of bigfile %ld to scratchdir", slice_num, biggie_file_number + 1);
2918	fatal_error("Hard disk full. You should have bought a bigger one.");
2919	}
2920	}
2921	mr_free(suffix);
2922	paranoid_fclose(fin);
2923	mr_asprintf(tmp, "Sliced bigfile #%ld", biggie_file_number + 1);
2924	if (retval) {
2925	mr_strcat(tmp, "...FAILED");
2926	} else {
2927	mr_strcat(tmp, "...OK!");
2928	}
2929	log_msg(1, tmp);
2930	mr_free(tmp);
2931
2932	return (retval);
2933	}
2934
2935
2936	/**
2937	* Remove the archives in @c d.
2938	* This could possibly include any of:
2939	* - all afioballs (compressed and not)
2940	* - all filelists
2941	* - all slices
2942	* - all checksums
2943	* - a zero filler file
2944	*
2945	* @param d The directory to wipe the archives from.
2946	* @ingroup utilityGroup
2947	*/
2948	void wipe_archives(char *d)
2949	{
2950	/@ buffers ******************************************** */
2951	char *tmp = NULL;
2952	char *dir = NULL;
2953
2954	assert_string_is_neither_NULL_nor_zerolength(d);
2955
2956	mr_asprintf(dir, "%s/archives", d);
2957	mr_asprintf(tmp, "find %s -name '.afio' -exec rm -f '{}' \\;", dir);
2958	run_program_and_log_output(tmp, FALSE);
2959	mr_free(tmp);
2960	mr_asprintf(tmp, "find %s -name 'list.[0-9]' -exec rm -f '{}' \\;", dir);
2961	run_program_and_log_output(tmp, FALSE);
2962	mr_free(tmp);
2963	mr_asprintf(tmp, "find %s -name 'slice*' -exec rm -f '{}' \\;", dir);
2964	run_program_and_log_output(tmp, FALSE);
2965	mr_free(tmp);
2966	mr_asprintf(tmp, "rm -f %s/cklist*", dir);
2967	run_program_and_log_output(tmp, FALSE);
2968	mr_free(tmp);
2969	mr_asprintf(tmp, "rm -f %s/zero", dir);
2970	run_program_and_log_output(tmp, FALSE);
2971	mr_free(tmp);
2972	log_msg(1, "Wiped %s's archives", dir);
2973	mr_asprintf(tmp, "ls -l %s", dir);
2974	mr_free(dir);
2975	run_program_and_log_output(tmp, FALSE);
2976	mr_free(tmp);
2977	}
2978
2979
2980	/**
2981	* @addtogroup LLarchiveGroup
2982	* @{
2983	*/
2984	/**
2985	* Write the final ISO image.
2986	* @param bkpinfo The backup information structure. Used only
2987	* in the call to @c write_iso_and_go_on().
2988	* @return The number of errors encountered (0 for success)
2989	* @see write_iso_and_go_on
2990	* @see make_iso_fs
2991	* @bug The final ISO is written even if there are no files on it. In practice,
2992	* however, this occurs rarely.
2993	*/
2994	int write_final_iso_if_necessary()
2995	{
2996	/@ int **************************************************** */
2997	int res;
2998
2999	/@ buffers ************************************************* */
3000	char *tmp;
3001
3002	malloc_string(tmp);
3003	assert(bkpinfo != NULL);
3004
3005	// I should really check if there are any slices or tarballs to be copied to CD-R(W)'s; the odds are approx. 1 in a million that there are no files here, so I'll just go ahead & make one more CD anyway
3006
3007	sprintf(tmp, "Writing the final ISO");
3008	log_msg(2, tmp);
3009	center_string(tmp, 80);
3010	if (!g_text_mode) {
3011	newtPushHelpLine(tmp);
3012	}
3013	res = write_iso_and_go_on(TRUE);
3014	if (!g_text_mode) {
3015	newtPopHelpLine();
3016	}
3017	log_msg(2, "Returning from writing final ISO (res=%d)", res);
3018	paranoid_free(tmp);
3019	return (res);
3020	}
3021
3022
3023	/**
3024	* Write an ISO image to <tt>[bkpinfo->isodir]/bkpinfo->prefix-[g_current_media_number].iso</tt>.
3025	* @param bkpinfo The backup information structure. Fields used:
3026	* - @c backup_media_type
3027	* - @c prefix
3028	* - @c isodir
3029	* - @c manual_cd_tray
3030	* - @c media_size
3031	* - @c netfs_mount
3032	* - @c netfs_remote_dir
3033	* - @c scratchdir
3034	* - @c verify_data
3035	*
3036	* @param last_cd If TRUE, this is the last CD to write; if FALSE, it's not.
3037	* @return The number of errors encountered (0 for success)
3038	* @see make_iso_fs
3039	*/
3040	int write_iso_and_go_on(bool last_cd)
3041	{
3042	/@ pointers *************************************************** */
3043	FILE *fout;
3044
3045	/@ buffers **************************************************** */
3046	char *tmp = NULL;
3047	char *tmp1 = NULL;
3048	char *cdno_fname = NULL;
3049	char *lastcd_fname = NULL;
3050	char *isofile = NULL;
3051	char *mds = NULL;
3052
3053	/@ bool ******************************************************* */
3054	bool that_one_was_ok;
3055	bool orig_vfy_flag_val;
3056
3057	/@ int ********************************************************** */
3058	int res = 0;
3059
3060	assert(bkpinfo != NULL);
3061	orig_vfy_flag_val = bkpinfo->verify_data;
3062	if (bkpinfo->media_size[g_current_media_number] <= 0) {
3063	fatal_error("write_iso_and_go_on() - unknown media size");
3064	}
3065
3066	mds = media_descriptor_string(bkpinfo->backup_media_type);
3067	log_msg(1, "OK, time to make %s #%d", mds, g_current_media_number);
3068	mr_free(mds);
3069
3070	/* label the ISO with its number */
3071
3072	mr_asprintf(cdno_fname, "%s/archives/THIS-CD-NUMBER", bkpinfo->scratchdir);
3073	fout = fopen(cdno_fname, "w");
3074	mr_free(cdno_fname);
3075
3076	fprintf(fout, "%d", g_current_media_number);
3077	paranoid_fclose(fout);
3078
3079	mr_asprintf(tmp1, "cp -f %s/autorun %s/", g_mondo_home, bkpinfo->scratchdir);
3080	if (run_program_and_log_output(tmp1, FALSE)) {
3081	log_msg(2, "Warning - unable to copy autorun to scratchdir");
3082	}
3083	mr_free(tmp1);
3084
3085	/* last CD or not? Label accordingly */
3086	mr_asprintf(lastcd_fname, "%s/archives/NOT-THE-LAST", bkpinfo->scratchdir);
3087	if (last_cd) {
3088	unlink(lastcd_fname);
3089	log_msg(2,
3090	"OK, you're telling me this is the last CD. Fair enough.");
3091	} else {
3092	fout = fopen(lastcd_fname, "w");
3093	fprintf(fout,
3094	"You're listening to 90.3 WPLN, Nashville Public Radio.\n");
3095	paranoid_fclose(fout);
3096	}
3097	mr_free(lastcd_fname);
3098
3099	if (space_occupied_by_cd(bkpinfo->scratchdir) / 1024 >
3100	bkpinfo->media_size[g_current_media_number]) {
3101	log_to_screen("Warning! CD is too big. It occupies %ld KB, which is more than the %ld KB allowed.", (long) space_occupied_by_cd(bkpinfo->scratchdir), (long) bkpinfo->media_size[g_current_media_number]);
3102	}
3103	if (((bkpinfo->isodir == NULL) && (bkpinfo->netfs_remote_dir == NULL)) \|\| (bkpinfo->prefix == NULL)) {
3104	fatal_error("Something wrong in your environement. Report to dev team");
3105	}
3106	if (bkpinfo->netfs_remote_dir) {
3107	// Network
3108	mr_asprintf(isofile, "%s/%s/%s-%d.iso", bkpinfo->isodir, bkpinfo->netfs_remote_dir, bkpinfo->prefix, g_current_media_number);
3109	} else {
3110	// ISO
3111	mr_asprintf(isofile, "%s/%s-%d.iso", bkpinfo->isodir, bkpinfo->prefix, g_current_media_number);
3112	}
3113
3114	for (that_one_was_ok = FALSE; !that_one_was_ok;) {
3115	if (bkpinfo->backup_media_type != usb) {
3116	res = make_iso_fs(isofile);
3117	} else {
3118	res = make_usb_fs();
3119	}
3120	if (g_current_media_number == 1 && !res
3121	&& (bkpinfo->backup_media_type == cdr
3122	\|\| bkpinfo->backup_media_type == cdrw)) {
3123	if ((tmp = find_cdrom_device(FALSE)) == NULL) {
3124	// make sure find_cdrom_device() finds, records CD-R's loc
3125	log_msg(3, "Sigh Mike, I hate your computer.");
3126	// if it can't be found then force pausing
3127	bkpinfo->manual_cd_tray = TRUE;
3128	} else {
3129	log_msg(3, "Great. Found Mike's CD-ROM drive.");
3130	}
3131	mr_free(tmp);
3132	}
3133	if (bkpinfo->verify_data && !res) {
3134	mds = media_descriptor_string(g_backup_media_type);
3135	log_to_screen("Please reboot from the 1st %s in Compare Mode, as a precaution.", mds);
3136	mr_free(mds);
3137	chdir("/");
3138	log_it("Before calling verification of image()");
3139	if (bkpinfo->backup_media_type == usb) {
3140	res += verify_usb_image();
3141	} else {
3142	res += verify_cd_image();
3143	}
3144	log_it("After calling verification of image()");
3145	}
3146	if (!res) {
3147	that_one_was_ok = TRUE;
3148	} else {
3149	mds = media_descriptor_string(bkpinfo->backup_media_type);
3150	mr_asprintf(tmp1, "Failed to create %s #%d. Retry?", mds, g_current_media_number);
3151	mr_free(mds);
3152	res = ask_me_yes_or_no(tmp1);
3153	mr_free(tmp1);
3154
3155	if (!res) {
3156	if (ask_me_yes_or_no("Abort the backup?")) {
3157	fatal_error("FAILED TO BACKUP");
3158	} else {
3159	break;
3160	}
3161	} else {
3162	log_msg(2, "Retrying, at user's request...");
3163	res = 0;
3164	}
3165	}
3166	}
3167	mr_free(isofile);
3168
3169	g_current_media_number++;
3170	if (g_current_media_number > MAX_NOOF_MEDIA) {
3171	fatal_error("Too many media. Use tape or net.");
3172	}
3173	wipe_archives(bkpinfo->scratchdir);
3174	mr_asprintf(tmp1, "rm -Rf %s/images/gz %s/images/data*img", bkpinfo->scratchdir, bkpinfo->scratchdir);
3175	if (system(tmp1)) {
3176	log_msg(2, "Error occurred when I tried to delete the redundant IMGs and GZs");
3177	}
3178	mr_free(tmp1);
3179
3180	if (last_cd) {
3181	log_msg(2, "This was your last media.");
3182	} else {
3183	log_msg(2, "Continuing to backup your data...");
3184	}
3185
3186	bkpinfo->verify_data = orig_vfy_flag_val;
3187	return (0);
3188	}
3189
3190	/* @} - end of LLarchiveGroup */
3191
3192
3193
3194
3195	/**
3196	* Verify the user's data.
3197	* @param bkpinfo The backup information structure. Fields used:
3198	* - @c backup_data
3199	* - @c backup_media_type
3200	* - @c media_device
3201	* - @c verify_data
3202	*
3203	* @return The number of errors encountered (0 for success)
3204	* @ingroup verifyGroup
3205	*/
3206	int verify_data()
3207	{
3208	int res = 0, retval = 0, cdno = 0;
3209	char *tmp = NULL;
3210	char *mds = NULL;
3211	long diffs = 0;
3212
3213	assert(bkpinfo != NULL);
3214	if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
3215	chdir("/");
3216	mvaddstr_and_log_it(g_currentY, 0,
3217	"Verifying archives against live filesystem");
3218	if (bkpinfo->backup_media_type == cdstream) {
3219	mr_free(bkpinfo->media_device);
3220	mr_asprintf(bkpinfo->media_device, "/dev/cdrom");
3221	}
3222	verify_tape_backups();
3223	mvaddstr_and_log_it(g_currentY++, 74, "Done.");
3224	} else if (bkpinfo->backup_data)
3225	//bkpinfo->backup_media_type == cdrw \|\| bkpinfo->backup_media_type == cdr))
3226	{
3227	log_msg(2,
3228	"Not verifying again. Per-CD/ISO verification already carried out.");
3229	mr_asprintf(tmp, "cat %s/changed.files > %s/changed.files 2> /dev/null",bkpinfo->tmpdir, MONDO_CACHE);
3230	paranoid_system(tmp);
3231	mr_free(tmp);
3232	} else {
3233	g_current_media_number = cdno;
3234	if (bkpinfo->backup_media_type != iso) {
3235	mr_free(bkpinfo->media_device);
3236	bkpinfo->media_device = find_cdrom_device(FALSE); // replace 0,0,0 with /dev/cdrom
3237	}
3238	chdir("/");
3239	for (cdno = 1; cdno < 99 && bkpinfo->verify_data; cdno++) {
3240	if (cdno != g_current_media_number) {
3241	log_msg(2,
3242	"Warning - had to change g_current_media_number from %d to %d",
3243	g_current_media_number, cdno);
3244	g_current_media_number = cdno;
3245	}
3246	if (bkpinfo->backup_media_type != iso) {
3247	insist_on_this_cd_number(cdno);
3248	}
3249	res = verify_cd_image(); // sets verify_data to FALSE if it's time to stop verifying
3250	retval += res;
3251	if (res) {
3252	mds = media_descriptor_string(bkpinfo->backup_media_type);
3253	log_to_screen("Warnings/errors were reported while checking %s #%d", mds, g_current_media_number);
3254	mr_free(mds);
3255
3256	}
3257	}
3258	mr_asprintf(tmp, "grep 'afio: ' %s \| sed 's/afio: //' \| grep -vE '^/dev/.*$' >> %s/changed.files", MONDO_LOGFILE, MONDO_CACHE);
3259	(void)system(tmp);
3260	mr_free(tmp);
3261
3262	mr_asprintf(tmp, "grep 'star: ' %s \| sed 's/star: //' \| grep -vE '^/dev/.*$' >> %s/changed.files", MONDO_LOGFILE, MONDO_CACHE);
3263	(void)system(tmp);
3264	mr_free(tmp);
3265	run_program_and_log_output("umount " MNT_CDROM, FALSE);
3266	// if (bkpinfo->backup_media_type != iso && !bkpinfo->please_dont_eject_when_restoring)
3267	//{
3268	eject_device(bkpinfo->media_device);
3269	//}
3270	}
3271	mr_asprintf(tmp, "%s/changed.files", MONDO_CACHE);
3272	diffs = count_lines_in_file(tmp);
3273	mr_free(tmp);
3274
3275	if (diffs > 0) {
3276	if (retval == 0) {
3277	retval = (int) (-diffs);
3278	}
3279	}
3280	return (retval);
3281	}
3282
3283
3284	void setenv_mondo_share(void) {
3285
3286	setenv("MONDO_SHARE", MONDO_SHARE, 1);
3287	}

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

Context Navigation

source: MondoRescue/branches/2.2.10/mondo/src/common/libmondo-archive.c@ 2462

Download in other formats: