source: MondoRescue/branches/2.2.5/mondo/src/common/libmondo-archive.c @ 1696

Last change on this file since 1696 was 1696, checked in by Bruno Cornec, 12 years ago

Stil refining USB copy back to mondo (one command was not executed)

  • Property svn:keywords set to Id
File size: 119.2 KB
Line 
1/* libmondo-archive.c
2   $Id: libmondo-archive.c 1696 2007-10-21 11:07:54Z bruno $
3
4subroutines to handle the archiving of files
5
6
7
807/14
9- moved all ACL, xattr stuff here from libmondo-filelist.c
10
1107/12
12- when trying to find boot loader, look for /boot's /dev, not just /'s dev
13
1407/10
15- better detection of changed files
16- added ACL, xattr support for afio
17
1806/17
19- backup with partimagehack if NTFS device; dd, if non-NTFS device
20
2106/14
22- use mondorescue.iso instead of mindi.iso
23
2404/28
25- cleaned up if/then architecture-specific stuff re: CD-R(W)s
26
2704/03
28- added star support
29
3003/12
31- modified offer_to_write_floppies() to support dual-disk boot/root thing
32
3301/20/2004
34- reformat dvd twice if necessary
35
3612/01/2003
37- added pause_for_N_seconds(5, "Letting DVD drive settle");
38
3911/23
40- added #define DVDRWFORMAT
41
4211/20
43- use --no-emul-boot -b isolinux.bin instead of -b mindi-boot.2880.img
44
4510/23
46- wipe DVD at start, whether or not disk is DVD-RW; this is
47  just a test, to see why dvd+rw-format followed by growiosfs
48  locks up the drive
49- use the singlethreaded make_afioballs_and_images_OLD()
50  instead of the multithreaded make_afioballs_and_images()
51  if backing up to tape
52
5310/21
54- if backing up to dvd, look for relevant tools;
55  abort if missing
56
5710/15
58- UI tweaks
59
6010/10
61- eject/inject DVD after wiping it
62
6309/27
64- pause_and_ask_for_cdr() will now blank DVD if necessary
65
6609/26
67- proper reporting of media type in displayed strings
68  (i.e. DVD if DVD, CD if CD, etc.)
69 
7009/25
71- add DVD support
72
7309/23
74- malloc/free global strings in new subroutines - malloc_libmondo_global_strings()
75  and free_libmondo_global_strings() - which are in libmondo-tools.c
76
7709/15
78- changed a bunch of char[MAX_STR_LEN]'s to char*; malloc; free;
79
8009/14
81- cosmetic bug re: call to 'which dvdrecord'
82
8309/09
84- copy `locate isolinux.bin | tail -n1` to CD before calling mkisfso
85  if file is missing (in which case, bug in Mindi.pl!)
86- reduced noof_threads from 3 to 2
87- fixed cosmetic bug in make_slices_and_images()
88
8909/02
90- fixed cosmetic bug in verify_data()
91
9205/01 - 08/31
93- added partimagehack hooks
94- make twice as many archives at once as before
95- fixed syntax error re: system(xxx,FALSE)
96- unmount CD-ROM before burning (necessary for RH8/9)
97- only ask for new media if sensible
98- fixed mondoarchive -Vi multi-CD verify bug (Tom Mortell)
99- use single-threaded make_afioballs_and_images() if FreeBSD
100- fixed bug on line 476 (Joshua Oreman)
101- re-enabled the pause, for people w/ weird CD-ROM drives
102- added Joshua Oreman's FreeBSD patches
103- don't listen to please_dont_eject_when_restoring
104  ...after all, we're not restoring :)
105
10604/01 - 04/30
107- cleaned up archive_this_fileset()
108- decreased ARCH_THREADS from 3 to 2
109- pause_and_ask_for_cd() --- calls retract_CD_tray_and_defeat_autorun()
110- call assert() and log_OS_error() in various places
111- cleaned up code a bit
112- increased ARCH_THREADS from 2 to 3
113- misc clean-up (Tom Mortell)
114
11503/15/2003
116- fixed problem w/ multi-ISO verify cycle (Tom Mortell)
117
11811/01 - 12/31/2002
119- removed references to make_afioballs_and_images_OLD()
120- added some error-checking to make_afioballs_in_background
121- make_iso_and_go_on() now copies Mondo's autorun file to CD
122- set scratchdir dir to 1744 when burning CD
123- cleaned up code a bit
124- in call_mindi_...(), gracefully handle the user's input
125  if they specify the boot loader but not the boot device
126- offer to abort if GRUB is boot loader and /dev/md* is
127  the boot device (bug in grub-install)
128- if boot loader is R then write RAW as bootloader.name
129- multithreaded make_afioballs_and_images()
130- fixed slice_up_file_etc() for 0-compression users
131- line 1198: added call to is_this_file_compressed() to stop
132  slice_up_file_etc() from compressing files which are
133  already compressed
134- other hackery related to the above enhancement
135- afio no longer forcibly compresses all files (i.e. I dropped
136  the -U following suggestions from users); let's see if
137  it works :)
138
13910/01 - 10/31
140- mondoarchive (with no parameters) wasn't working
141  if user said yes when asked if BurnProof drive; FIXED
142- if manual CD tray and writing to ISO's then prompt
143  for each & every new CD
144- moved a lot of subroutines here
145  from mondo-archive.c and mondo-floppies.c
146
14709/01 - 09/30
148- if CD not burned OK then don't try to verify
149- change 64k to TAPE_BLOCK_SIZE
150- run_program_and_log_output() now takes boolean operator to specify
151  whether it will log its activities in the event of _success_
152- orig_vfy_flag_val added to write_iso_and_go_on, to restore bkpinfo->verify_data's
153  value if altered by verify_cd_image()
154
15508/01 - 08/31
156- use data structure to store the fname, checksum, mods & perms of each bigfile
157  ... biggiestruct :)
158- bigger tmp[]'s in a few places
159- cleaned up the (user-friendly) counting of biggiefiles a bit
160- if media_size[N]<=0 then catch it & abort, unless it's tape,
161  in which case, allow it
162- cleaned up a lot of log_it() calls
163- fixed NULL filename-related bug in can_we_fit_these_files_on_media()
164- deleted can_we_fit.....() subroutine because it was causing problems
165  --- moved its code into the one subroutine which called it
166- created [08/01/2002]
167*/
168
169/**
170 * @file
171 * Functions to handle backing up data.
172 * This is the main file (at least the longest one) in libmondo.
173 */
174
175#include "my-stuff.h"
176#include "mondostructures.h"
177#include "libmondo-string-EXT.h"
178#include "libmondo-stream-EXT.h"
179#include "libmondo-devices-EXT.h"
180#include "libmondo-tools-EXT.h"
181#include "libmondo-gui-EXT.h"
182#include "libmondo-fork-EXT.h"
183#include "libmondo-files-EXT.h"
184#include "libmondo-filelist-EXT.h"
185#include "libmondo-tools-EXT.h"
186#include "libmondo-verify-EXT.h"
187#include "libmondo-archive.h"
188#include "lib-common-externs.h"
189#include <sys/sem.h>
190#include <sys/types.h>
191#include <sys/ipc.h>
192#include <stdarg.h>
193#define DVDRWFORMAT 1
194
195
196
197/** @def DEFAULT_1722MB_DISK The default 1.722M floppy disk to write images to. */
198/** @def BACKUP_1722MB_DISK  The 1.722M floppy disk to try if the default fails. */
199
200#ifdef __FreeBSD__
201#define DEFAULT_1722MB_DISK "/dev/fd0.1722"
202#define BACKUP_1722MB_DISK "/dev/fd0.1722"
203#else
204#define DEFAULT_1722MB_DISK "/dev/fd0u1722"
205#define BACKUP_1722MB_DISK "/dev/fd0H1722"
206#ifndef _SEMUN_H
207#define _SEMUN_H
208
209    /**
210     * The semaphore union, provided only in case the user's system doesn't.
211     */
212union semun {
213    int val;
214    struct semid_ds *buf;
215    unsigned short int *array;
216    struct seminfo *__buf;
217};
218#endif
219#endif                          /* __FreeBSD__ */
220
221/*@unused@*/
222//static char cvsid[] = "$Id: libmondo-archive.c 1696 2007-10-21 11:07:54Z bruno $";
223
224/* *************************** external global vars ******************/
225extern int g_current_media_number;
226extern int g_currentY;
227extern bool g_text_mode;
228extern bool g_exiting;
229extern long g_current_progress;
230extern FILE *g_tape_stream;
231extern long long g_tape_posK;
232extern char *g_mondo_home;
233extern char *g_tmpfs_mountpt;
234extern bool g_cd_recovery;
235extern char *g_serial_string;
236
237extern char *g_getfacl;
238extern char *g_getfattr;
239extern char *MONDO_LOGFILE;
240
241/* Reference to global bkpinfo */
242extern struct s_bkpinfo *bkpinfo;
243
244
245
246/**
247 * @addtogroup globalGroup
248 * @{
249 */
250/**
251 * The current backup media type in use.
252 */
253t_bkptype g_backup_media_type = none;
254
255/**
256 * Incremented by each archival thread when it starts up. After that,
257 * this is the number of threads running.
258 */
259int g_current_thread_no = 0;
260
261/* @} - end of globalGroup */
262
263extern int g_noof_rows;
264
265/* Semaphore-related code */
266
267static int set_semvalue(void);
268static void del_semvalue(void);
269static int semaphore_p(void);
270static int semaphore_v(void);
271
272static int g_sem_id;
273static int g_sem_key;
274
275
276
277
278/**
279 * Initialize the semaphore.
280 * @see del_semvalue
281 * @see semaphore_p
282 * @see semaphore_v
283 * @return 1 for success, 0 for failure.
284 */
285static int set_semvalue(void)   // initializes semaphore
286{
287    union semun sem_union;
288    sem_union.val = 1;
289    if (semctl(g_sem_id, 0, SETVAL, sem_union) == -1) {
290        return (0);
291    }
292    return (1);
293}
294
295/**
296 * Frees (deletes) the semaphore. Failure is indicated by a log
297 * message.
298 * @see set_semvalue
299 */
300static void del_semvalue(void)  // deletes semaphore
301{
302    union semun sem_union;
303
304    if (semctl(g_sem_id, 0, IPC_RMID, sem_union) == -1) {
305        log_msg(3, "Failed to delete semaphore");
306    }
307}
308
309/**
310 * Acquire (increment) the semaphore (change status to P).
311 * @return 1 for success, 0 for failure.
312 * @see semaphore_v
313 */
314static int semaphore_p(void)    // changes status to 'P' (waiting)
315{
316    struct sembuf sem_b;
317
318    sem_b.sem_num = 0;
319    sem_b.sem_op = -1;          // P()
320    sem_b.sem_flg = SEM_UNDO;
321    if (semop(g_sem_id, &sem_b, 1) == -1) {
322        log_msg(3, "semaphore_p failed");
323        return (0);
324    }
325    return (1);
326}
327
328/**
329 * Free (decrement) the semaphore (change status to V).
330 * @return 1 for success, 0 for failure.
331 */
332static int semaphore_v(void)    // changes status to 'V' (free)
333{
334    struct sembuf sem_b;
335
336    sem_b.sem_num = 0;
337    sem_b.sem_op = 1;           // V()
338    sem_b.sem_flg = SEM_UNDO;
339    if (semop(g_sem_id, &sem_b, 1) == -1) {
340        log_msg(3, "semaphore_v failed");
341        return (0);
342    }
343    return (1);
344}
345
346
347//------------------------------------------------------
348
349
350/**
351 * Size in megabytes of the buffer afforded to the executable "buffer".
352 * This figure is used when we calculate how much data we have probably 'lost'
353 * when writing off the end of tape N, so that we can then figure out how much
354 * data we must recreate & write to the start of tape N+1.
355 */
356extern int g_tape_buffer_size_MB;
357
358
359
360
361int
362archive_this_fileset_with_star(char *filelist, char *fname, int setno)
363{
364    int retval = 0;
365    unsigned int res = 0;
366    int tries = 0;
367    char *command;
368    char *zipparams;
369    char *tmp;
370    char *p;
371
372    malloc_string(command);
373    malloc_string(zipparams);
374    malloc_string(tmp);
375
376    if (!does_file_exist(filelist)) {
377        sprintf(tmp, "(archive_this_fileset) - filelist %s does not exist",
378                filelist);
379        log_to_screen(tmp);
380        return (1);
381    }
382
383    sprintf(tmp, "echo hi > %s 2> /dev/null", fname);
384    if (system(tmp)) {
385        fatal_error("Unable to write tarball to scratchdir");
386    }
387
388    sprintf(command, "star H=star list=%s -c " STAR_ACL_SZ " file=%s",
389            filelist, fname);
390    if (bkpinfo->use_lzo) {
391        fatal_error("Can't use lzop");
392    }
393    if (bkpinfo->compression_level > 0) {
394        strcat(command, " -bz");
395    }
396    sprintf(command + strlen(command), " 2>> %s", MONDO_LOGFILE);
397    log_msg(4, "command = '%s'", command);
398
399    for (res = 99, tries = 0; tries < 3 && res != 0; tries++) {
400        log_msg(5, "command='%s'", command);
401        res = system(command);
402        strcpy(tmp, last_line_of_file(MONDO_LOGFILE));
403        log_msg(1, "res=%d; tmp='%s'", res, tmp);
404        if (bkpinfo->use_star && (res == 254 || res == 65024)
405            && strstr(tmp, "star: Processed all possible files")
406            && tries > 0) {
407            log_msg(1, "Star returned nonfatal error");
408            res = 0;
409        }
410        if (res) {
411            log_OS_error(command);
412            p = strstr(command, "-acl ");
413            if (p) {
414                p[0] = p[1] = p[2] = p[3] = ' ';
415                log_msg(1, "new command = '%s'", command);
416            } else {
417                log_msg(3,
418                        "Attempt #%d failed. Pausing 3 seconds and retrying...",
419                        tries + 1);
420                sleep(3);
421            }
422        }
423    }
424    retval += res;
425    if (retval) {
426        log_msg(3, "Failed to write set %d", setno);
427    } else if (tries > 1) {
428        log_msg(3, "Succeeded in writing set %d, on try #%d", setno,
429                tries);
430    }
431
432    paranoid_free(command);
433    paranoid_free(zipparams);
434    paranoid_free(tmp);
435    return (retval);
436}
437
438
439/**
440 * Call @c afio to archive the filelist @c filelist to the file @c fname.
441 *
442 * @param bkpinfo The backup information structure. Fields used:
443 * - @c compression_level
444 * - @c scratchdir (only verifies existence)
445 * - @c tmpdir (only verifies existence)
446 * - @c zip_exe
447 * - @c zip_suffix
448 * @param filelist The path to a file containing a list of files to be archived
449 * in this fileset.
450 * @param fname The output file to archive to.
451 * @param setno This fileset number.
452 * @return The number of errors encountered (0 for success).
453 * @ingroup LLarchiveGroup
454 */
455int
456archive_this_fileset(char *filelist, char *fname, int setno)
457{
458
459    /*@ int *************************************************************** */
460    int retval = 0;
461    int res = 0;
462    int i = 0;
463    int tries = 0;
464    static int free_ramdisk_space = 9999;
465
466    /*@ buffers ************************************************************ */
467    char *command;
468    char *zipparams;
469    char *tmp;
470
471    assert(bkpinfo != NULL);
472    assert_string_is_neither_NULL_nor_zerolength(filelist);
473    assert_string_is_neither_NULL_nor_zerolength(fname);
474
475    if (bkpinfo->compression_level > 0 && bkpinfo->use_star) {
476        return (archive_this_fileset_with_star(filelist, fname, setno));
477    }
478
479    malloc_string(command);
480    malloc_string(zipparams);
481    malloc_string(tmp);
482
483    if (!does_file_exist(filelist)) {
484        sprintf(tmp, "(archive_this_fileset) - filelist %s does not exist",
485                filelist);
486        log_to_screen(tmp);
487        return (1);
488    }
489    sprintf(tmp, "echo hi > %s 2> /dev/null", fname);
490    if (system(tmp)) {
491        fatal_error("Unable to write tarball to scratchdir");
492    }
493
494
495    if (bkpinfo->compression_level > 0) {
496        sprintf(tmp, "%s/do-not-compress-these", g_mondo_home);
497        //       -b %ld, TAPE_BLOCK_SIZE
498        sprintf(zipparams, "-Z -P %s -G %d -T 3k", bkpinfo->zip_exe,
499                bkpinfo->compression_level);
500        if (does_file_exist(tmp)) {
501            strcat(zipparams, " -E ");
502            strcat(zipparams, tmp);
503        } else {
504            log_msg(3, "%s not found. Cannot exclude zipfiles, etc.", tmp);
505        }
506    } else {
507        zipparams[0] = '\0';
508    }
509
510//  make_hole_for_file(fname);
511
512    if (!does_file_exist(bkpinfo->tmpdir)) {
513        log_OS_error("tmpdir not found");
514        fatal_error("tmpdir not found");
515    }
516    if (!does_file_exist(bkpinfo->scratchdir)) {
517        log_OS_error("scratchdir not found");
518        fatal_error("scratchdir not found");
519    }
520    sprintf(command, "rm -f %s %s. %s.gz %s.%s", fname, fname, fname,
521            fname, bkpinfo->zip_suffix);
522    paranoid_system(command);
523
524    sprintf(command, "afio -o -b %ld -M 16m %s %s < %s 2>> %s",
525            TAPE_BLOCK_SIZE, zipparams, fname, filelist, MONDO_LOGFILE);
526
527    sprintf(tmp, "echo hi > %s 2> /dev/null", fname);
528    if (system(tmp)) {
529        fatal_error("Unable to write tarball to scratchdir");
530    }
531
532    for (res = 99, tries = 0; tries < 3 && res != 0; tries++) {
533        log_msg(5, "command='%s'", command);
534        res = system(command);
535        if (res) {
536            log_OS_error(command);
537            log_msg(3,
538                    "Attempt #%d failed. Pausing 3 seconds and retrying...",
539                    tries + 1);
540            sleep(3);
541        }
542    }
543    retval += res;
544    if (retval) {
545        log_msg(3, "Failed to write set %d", setno);
546    } else if (tries > 1) {
547        log_msg(3, "Succeeded in writing set %d, on try #%d", setno,
548                tries);
549    }
550
551    if (g_tmpfs_mountpt[0] != '\0') {
552        i = atoi(call_program_and_get_last_line_of_output
553                 ("df -m -P | grep dev/shm | grep -v none | tr -s ' ' '\t' | cut -f4"));
554        if (i > 0) {
555            if (free_ramdisk_space > i) {
556                free_ramdisk_space = i;
557                log_msg(2, "min(free_ramdisk_space) is now %d",
558                        free_ramdisk_space);
559                if (free_ramdisk_space < 10) {
560                    fatal_error
561                        ("Please increase PPCFG_RAMDISK_SIZE in my-stuff.h to increase size of ramdisk ");
562                }
563            }
564        }
565    }
566    paranoid_free(command);
567    paranoid_free(zipparams);
568    paranoid_free(tmp);
569    return (retval);
570}
571
572
573
574
575
576
577/**
578 * Wrapper function for all the backup commands.
579 * Calls these other functions: @c prepare_filelist(),
580 * @c call_filelist_chopper(), @c copy_mondo_and_mindi_stuff_to_scratchdir(),
581 * @c call_mindi_to_supply_boot_disks(), @c do_that_initial_phase(),
582 * @c make_those_afios_phase(), @c make_those_slices_phase(), and
583 * @c do_that_final_phase(). If anything fails before @c do_that_initial_phase(),
584 * @c fatal_error is called with a suitable message.
585 * @param bkpinfo The backup information structure. Uses most fields.
586 * @return The number of non-fatal errors encountered (0 for success).
587 * @ingroup archiveGroup
588 */
589int backup_data()
590{
591    int retval = 0, res = 0;
592    char *tmp;
593
594    assert(bkpinfo != NULL);
595    set_g_cdrom_and_g_dvd_to_bkpinfo_value();
596    malloc_string(tmp);
597    if (bkpinfo->backup_media_type == dvd) {
598#ifdef DVDRWFORMAT
599        if (!find_home_of_exe("dvd+rw-format")) {
600            fatal_error
601                ("Cannot find dvd+rw-format. Please install it or fix your PATH.");
602        }
603#endif
604        if (!find_home_of_exe("growisofs")) {
605            fatal_error
606                ("Cannot find growisofs. Please install it or fix your PATH.");
607        }
608    }
609
610    if ((res = prepare_filelist())) {   /* generate scratchdir/filelist.full */
611        fatal_error("Failed to generate filelist catalog");
612    }
613    if (call_filelist_chopper()) {
614        fatal_error("Failed to run filelist chopper");
615    }
616
617/*
618      sprintf(tmp, "wc -l %s/archives/filelist.full > %s/archives/filelist.count",bkpinfo->scratchdir, bkpinfo->scratchdir);
619      if (run_program_and_log_output(tmp, 2))
620        { fatal_error("Failed to count filelist.full"); }
621*/
622    sprintf(tmp, "gzip -9 %s/archives/filelist.full", bkpinfo->scratchdir);
623    if (run_program_and_log_output(tmp, 2)) {
624        fatal_error("Failed to gzip filelist.full");
625    }
626    sprintf(tmp, "cp -f %s/archives/*list*.gz %s", bkpinfo->scratchdir,
627            bkpinfo->tmpdir);
628    if (run_program_and_log_output(tmp, 2)) {
629        fatal_error("Failed to copy to tmpdir");
630    }
631
632    copy_mondo_and_mindi_stuff_to_scratchdir(); // payload, too, if it exists
633#if __FreeBSD__ == 5
634    strcpy(bkpinfo->kernel_path, "/boot/kernel/kernel");
635#elif __FreeBSD__ == 4
636    strcpy(bkpinfo->kernel_path, "/kernel");
637#elif linux
638    if (figure_out_kernel_path_interactively_if_necessary
639        (bkpinfo->kernel_path)) {
640        fatal_error
641            ("Kernel not found. Please specify manually with the '-k' switch.");
642    }
643#else
644#error "I don't know about this system!"
645#endif
646    if ((res = call_mindi_to_supply_boot_disks())) {
647        fatal_error("Failed to generate boot+data disks");
648    }
649    retval += do_that_initial_phase();  // prepare
650    sprintf(tmp, "rm -f %s/images/*.iso", bkpinfo->scratchdir);
651    run_program_and_log_output(tmp, 1);
652    retval += make_those_afios_phase(); // backup regular files
653    retval += make_those_slices_phase();    // backup BIG files
654    retval += do_that_final_phase();    // clean up
655    log_msg(1, "Creation of archives... complete.");
656    if (bkpinfo->verify_data) {
657        sleep(2);
658    }
659    paranoid_free(tmp);
660    return (retval);
661}
662
663
664
665
666/**
667 * Call Mindi to generate boot and data disks.
668 * @note This binds correctly to the new Perl version of mindi.
669 * @param bkpinfo The backup information structure. Fields used:
670 * - @c backup_media_type
671 * - @c boot_loader
672 * - @c boot_device
673 * - @c compression_level
674 * - @c differential
675 * - @c exclude_paths
676 * - @c image_devs
677 * - @c kernel_path
678 * - @c make_cd_use_lilo
679 * - @c media_device
680 * - @c media_size
681 * - @c nonbootable_backup
682 * - @c scratchdir
683 * - @c tmpdir
684 * - @c use_lzo
685 *
686 * @return The number of errors encountered (0 for success)
687 * @bug The code to automagically determine the boot drive
688 * is messy and system-dependent. In particular, it breaks
689 * for Linux RAID and LVM users.
690 * @ingroup MLarchiveGroup
691 */
692int call_mindi_to_supply_boot_disks()
693{
694    /*@ buffer ************************************************************ */
695    char *tmp;
696    char *tmp1 = NULL;
697    char *tmp2 = NULL;
698    char *scratchdir;
699    char *command;
700    char *use_lzo_sz;
701    char *use_gzip_sz;
702    char *use_comp_sz;
703    char *use_star_sz;
704    char *bootldr_str;
705    char *tape_device;
706    char *last_filelist_number;
707    char *broken_bios_sz;
708    char *cd_recovery_sz;
709    char *tape_size_sz;
710    char *devs_to_exclude;
711    char *use_lilo_sz;
712    char *value;
713    char *bootdev;
714
715
716
717    /*@ char ************************************************************** */
718    char ch = '\0';
719
720    /*@ long     ********************************************************** */
721    long lines_in_filelist = 0;
722
723    /*@ int     ************************************************************* */
724    int res = 0;
725    long estimated_total_noof_slices = 0;
726
727    assert(bkpinfo != NULL);
728    command = malloc(1200);
729    tmp = malloc(9*MAX_STR_LEN);
730    malloc_string(scratchdir);
731    malloc_string(use_lzo_sz);
732    malloc_string(use_gzip_sz);
733    malloc_string(use_star_sz);
734    malloc_string(use_comp_sz);
735    malloc_string(bootldr_str);
736    malloc_string(tape_device);
737    malloc_string(last_filelist_number);
738    malloc_string(broken_bios_sz);
739    malloc_string(cd_recovery_sz);
740    malloc_string(tape_size_sz);
741    malloc_string(devs_to_exclude);
742    malloc_string(use_lilo_sz); /* BCO: shared between LILO/ELILO */
743    malloc_string(value);
744    malloc_string(bootdev);
745
746    strcpy(scratchdir, bkpinfo->scratchdir);
747    sprintf(tmp,
748            "echo '%s' | tr -s ' ' '\n' | grep -E '^/dev/.*$' | tr -s '\n' ' ' | awk '{print $0\"\\n\";}'",
749            bkpinfo->exclude_paths);
750    strcpy(devs_to_exclude, call_program_and_get_last_line_of_output(tmp));
751    sprintf(tmp, "devs_to_exclude = '%s'", devs_to_exclude);
752    log_msg(2, tmp);
753    mvaddstr_and_log_it(g_currentY, 0,
754                        "Calling MINDI to create boot+data disks");
755    sprintf(tmp, "%s/filelist.full", bkpinfo->tmpdir);
756    if (!does_file_exist(tmp)) {
757        sprintf(tmp, "%s/tmpfs/filelist.full", bkpinfo->tmpdir);
758        if (!does_file_exist(tmp)) {
759            fatal_error
760                ("Cannot find filelist.full, so I cannot count its lines");
761        }
762    }
763    lines_in_filelist = count_lines_in_file(tmp);
764    sprintf(tmp, "%s/LAST-FILELIST-NUMBER", bkpinfo->tmpdir);
765    strcpy(last_filelist_number, last_line_of_file(tmp));
766    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
767        sprintf(tape_size_sz, "%ld", bkpinfo->media_size[1]);
768        strcpy(tape_device, bkpinfo->media_device);
769    } else {
770        tape_size_sz[0] = '\0';
771        tape_device[0] = '\0';
772    }
773    if (bkpinfo->use_lzo) {
774        strcpy(use_lzo_sz, "yes");
775    } else {
776        strcpy(use_lzo_sz, "no");
777    }
778    if (bkpinfo->use_gzip) {
779        strcpy(use_gzip_sz, "yes");
780    } else {
781        strcpy(use_gzip_sz, "no");
782    }
783    if (bkpinfo->use_star) {
784        strcpy(use_star_sz, "yes");
785    } else {
786        strcpy(use_star_sz, "no");
787    }
788
789    if (bkpinfo->compression_level > 0) {
790        strcpy(use_comp_sz, "yes");
791    } else {
792        strcpy(use_comp_sz, "no");
793    }
794
795    strcpy(broken_bios_sz, "yes");  /* assume so */
796    if (g_cd_recovery) {
797        strcpy(cd_recovery_sz, "yes");
798    } else {
799        strcpy(cd_recovery_sz, "no");
800    }
801    if (bkpinfo->make_cd_use_lilo) {
802        strcpy(use_lilo_sz, "yes");
803    } else {
804        strcpy(use_lilo_sz, "no");
805    }
806
807    if (!bkpinfo->nonbootable_backup
808        && (bkpinfo->boot_loader == '\0'
809            || bkpinfo->boot_device[0] == '\0')) {
810
811#ifdef __FreeBSD__
812        strcpy(bootdev, call_program_and_get_last_line_of_output
813               ("mount | grep ' /boot ' | head -1 | cut -d' ' -f1 | sed 's/\\([0-9]\\).*/\\1/'"));
814        if (!bootdev[0]) {
815            strcpy(bootdev, call_program_and_get_last_line_of_output
816                   ("mount | grep ' / ' | head -1 | cut -d' ' -f1 | sed 's/\\([0-9]\\).*/\\1/'"));
817        }
818#else
819        strcpy(bootdev, call_program_and_get_last_line_of_output
820               ("mount | grep ' /boot ' | head -1 | cut -d' ' -f1 | sed 's/[0-9].*//'"));
821        if (strstr(bootdev, "/dev/cciss/")) {
822            strcpy(bootdev, call_program_and_get_last_line_of_output
823                   ("mount | grep ' /boot ' | head -1 | cut -d' ' -f1 | cut -dp -f1"));
824        }
825        if (!bootdev[0]) {
826            strcpy(bootdev, call_program_and_get_last_line_of_output
827                   ("mount | grep ' / ' | head -1 | cut -d' ' -f1 | sed 's/[0-9].*//'"));
828            if (strstr(bootdev, "/dev/cciss/")) {
829                strcpy(bootdev, call_program_and_get_last_line_of_output
830                       ("mount | grep ' / ' | head -1 | cut -d' ' -f1 | cut -dp -f1"));
831            }
832        }
833#endif
834        if (bootdev[0])
835            ch = which_boot_loader(bootdev);
836        else
837            ch = 'U';
838        if (bkpinfo->boot_loader != '\0') {
839            sprintf(tmp, "User specified boot loader. It is '%c'.",
840                    bkpinfo->boot_loader);
841            log_msg(2, tmp);
842        } else {
843            bkpinfo->boot_loader = ch;
844        }
845        if (bkpinfo->boot_device[0] != '\0') {
846            sprintf(tmp, "User specified boot device. It is '%s'.",
847                    bkpinfo->boot_device);
848            log_msg(2, tmp);
849        } else {
850            strcpy(bkpinfo->boot_device, bootdev);
851        }
852    }
853
854    if (
855#ifdef __FreeBSD__
856           bkpinfo->boot_loader != 'B' && bkpinfo->boot_loader != 'D' &&
857#endif
858#ifdef __IA64__
859           bkpinfo->boot_loader != 'E' &&
860#endif
861           bkpinfo->boot_loader != 'L' && bkpinfo->boot_loader != 'G'
862           && bkpinfo->boot_loader != 'R'
863           && !bkpinfo->nonbootable_backup) {
864        fatal_error
865            ("Please specify your boot loader and device, e.g. -l GRUB -f /dev/hda. Type 'man mondoarchive' to read the manual.");
866    }
867    if (bkpinfo->boot_loader == 'L') {
868        strcpy(bootldr_str, "LILO");
869        if (!does_file_exist("/etc/lilo.conf")) {
870            fatal_error
871                ("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?");
872        }
873    } else if (bkpinfo->boot_loader == 'G') {
874        strcpy(bootldr_str, "GRUB");
875        if (!does_file_exist("/etc/grub.conf")
876            && does_file_exist("/boot/grub/grub.conf")) {
877            run_program_and_log_output
878                ("ln -sf /boot/grub/grub.conf /etc/grub.conf", 5);
879        }
880        /* Detect Debian's grub config file */
881        else if (!does_file_exist("/etc/grub.conf")
882                 && does_file_exist("/boot/grub/menu.lst")) {
883            run_program_and_log_output
884                ("ln -s /boot/grub/menu.lst /etc/grub.conf", 5);
885        }
886        if (!does_file_exist("/etc/grub.conf")) {
887            fatal_error
888                ("The de facto standard location for your boot loader's config file is /etc/grub.conf but I cannot find it there. What is wrong with your Linux distribution? Try 'ln -s /boot/grub/menu.lst /etc/grub.conf'...");
889        }
890    } else if (bkpinfo->boot_loader == 'E') {
891        strcpy(bootldr_str, "ELILO");
892        /* BCO: fix it for Debian, Mandrake, ... */
893        if (!does_file_exist("/etc/elilo.conf")
894            && does_file_exist("/boot/efi/efi/redhat/elilo.conf")) {
895            run_program_and_log_output
896                ("ln -sf /boot/efi/efi/redhat/elilo.conf /etc/elilo.conf",
897                 5);
898        }
899        if (!does_file_exist("/etc/elilo.conf")
900            && does_file_exist("/boot/efi/efi/SuSE/elilo.conf")) {
901            run_program_and_log_output
902                ("ln -sf /boot/efi/efi/SuSE/elilo.conf /etc/elilo.conf",
903                 5);
904        }
905        if (!does_file_exist("/etc/elilo.conf")
906            && does_file_exist("/boot/efi/efi/debian/elilo.conf")) {
907            run_program_and_log_output
908                ("ln -sf /boot/efi/efi/debian/elilo.conf /etc/elilo.conf",
909                 5);
910        }
911        if (!does_file_exist("/etc/elilo.conf")
912            && does_file_exist("/boot/efi/debian/elilo.conf")) {
913            run_program_and_log_output
914                ("ln -sf /boot/efi/debian/elilo.conf /etc/elilo.conf",
915                 5);
916        }
917        if (!does_file_exist("/etc/elilo.conf")) {
918            fatal_error
919                ("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'");
920        }
921    } else if (bkpinfo->boot_loader == 'R') {
922        strcpy(bootldr_str, "RAW");
923    }
924#ifdef __FreeBSD__
925    else if (bkpinfo->boot_loader == 'D') {
926        strcpy(bootldr_str, "DD");
927    }
928
929    else if (bkpinfo->boot_loader == 'B') {
930        strcpy(bootldr_str, "BOOT0");
931    }
932#endif
933    else {
934        strcpy(bootldr_str, "unknown");
935    }
936    sprintf(tmp, "Your boot loader is %s and it boots from %s",
937            bootldr_str, bkpinfo->boot_device);
938    log_to_screen(tmp);
939    sprintf(tmp, "%s/BOOTLOADER.DEVICE", bkpinfo->tmpdir);
940    if (write_one_liner_data_file(tmp, bkpinfo->boot_device)) {
941        log_msg(1, "%ld: Unable to write one-liner boot device", __LINE__);
942    }
943    switch (bkpinfo->backup_media_type) {
944    case cdr:
945        strcpy(value, "cdr");
946        break;
947    case cdrw:
948        strcpy(value, "cdrw");
949        break;
950    case cdstream:
951        strcpy(value, "cdstream");
952        break;
953    case tape:
954        strcpy(value, "tape");
955        break;
956    case udev:
957        strcpy(value, "udev");
958        break;
959    case iso:
960        strcpy(value, "iso");
961        break;
962    case nfs:
963        strcpy(value, "nfs");
964        break;
965    case dvd:
966        strcpy(value, "dvd");
967        break;
968    case usb:
969        strcpy(value, "usb");
970        break;
971    default:
972        fatal_error("Unknown backup_media_type");
973    }
974    if (bkpinfo->backup_media_type == usb) {
975        asprintf(&tmp2, "--usb %s", bkpinfo->media_device);
976    } else {
977        asprintf(&tmp2," ");
978    }
979
980    sprintf(tmp, "%s/BACKUP-MEDIA-TYPE", bkpinfo->tmpdir);
981    if (write_one_liner_data_file(tmp, value)) {
982        res++;
983        log_msg(1, "%ld: Unable to write one-liner backup-media-type",
984                __LINE__);
985    }
986    log_to_screen(bkpinfo->tmpdir);
987    sprintf(tmp, "%s/BOOTLOADER.NAME", bkpinfo->tmpdir);
988    if (write_one_liner_data_file(tmp, bootldr_str)) {
989        res++;
990        log_msg(1, "%ld: Unable to write one-liner bootloader.name",
991                __LINE__);
992    }
993    sprintf(tmp, "%s/DIFFERENTIAL", bkpinfo->tmpdir);
994    if (bkpinfo->differential) {
995        res += write_one_liner_data_file(tmp, "1");
996    } else {
997        res += write_one_liner_data_file(tmp, "0");
998    }
999
1000    if (g_getfattr) {
1001        asprintf(&tmp1, "%s/XATTR", bkpinfo->tmpdir);
1002        if (write_one_liner_data_file(tmp1, "TRUE")) {
1003            log_msg(1, "%ld: Unable to write one-liner XATTR",
1004                __LINE__);
1005        }
1006        paranoid_free(tmp1);
1007    }
1008    if (g_getfacl) {
1009        asprintf(&tmp1, "%s/ACL", bkpinfo->tmpdir);
1010        if (write_one_liner_data_file(tmp1, "TRUE")) {
1011            log_msg(1, "%ld: Unable to write one-liner ACL",
1012                __LINE__);
1013        }
1014        paranoid_free(tmp1);
1015    }
1016
1017    estimated_total_noof_slices =
1018        size_of_all_biggiefiles_K(bkpinfo) / bkpinfo->optimal_set_size + 1;
1019/* add nfs stuff here? */
1020    sprintf(command, "mkdir -p %s/images", bkpinfo->scratchdir);
1021    if (system(command)) {
1022        res++;
1023        log_OS_error("Unable to make images directory");
1024    }
1025    sprintf(command, "mkdir -p %s%s", bkpinfo->scratchdir, MNT_FLOPPY);
1026    if (system(command)) {
1027        res++;
1028        log_OS_error("Unable to make mnt floppy directory");
1029    }
1030    sprintf(tmp, "BTW, I'm telling Mindi your kernel is '%s'",
1031            bkpinfo->kernel_path);
1032
1033    log_msg(1, "lines_in_filelist = %ld", lines_in_filelist);
1034
1035    sprintf(command,
1036/*     "mindi --custom 2=%s 3=%s/images 4=\"%s\" 5=\"%s\" \
10376=\"%s\" 7=%ld 8=\"%s\" 9=\"%s\" 10=\"%s\" \
103811=\"%s\" 12=%s 13=%ld 14=\"%s\" 15=\"%s\" 16=\"%s\" 17=\"%s\" 18=%ld 19=%d",*/
1039            "mindi %s --custom %s %s/images '%s' '%s' \
1040'%s' %ld '%s' '%s' '%s' \
1041'%s' %s %ld '%s' '%s' '%s' '%s' %ld %d '%s'", tmp2, bkpinfo->tmpdir,    // parameter #2
1042            bkpinfo->scratchdir,    // parameter #3
1043            bkpinfo->kernel_path,   // parameter #4
1044            tape_device,        // parameter #5
1045            tape_size_sz,       // parameter #6
1046            lines_in_filelist,  // parameter #7 (INT)
1047            use_lzo_sz,         // parameter #8
1048            cd_recovery_sz,     // parameter #9
1049            bkpinfo->image_devs,    // parameter #10
1050            broken_bios_sz,     // parameter #11
1051            last_filelist_number,   // parameter #12 (STRING)
1052            estimated_total_noof_slices,    // parameter #13 (INT)
1053            devs_to_exclude,    // parameter #14
1054            use_comp_sz,        // parameter #15
1055            use_lilo_sz,        // parameter #16
1056            use_star_sz,        // parameter #17
1057            bkpinfo->internal_tape_block_size,  // parameter #18 (LONG)
1058            bkpinfo->differential,  // parameter #19 (INT)
1059            use_gzip_sz);       // parameter #20 (STRING)
1060
1061// Watch it! This next line adds a parameter...
1062    if (bkpinfo->nonbootable_backup) {
1063        strcat(command, " NONBOOTABLE");
1064    }
1065    log_msg(2, command);
1066
1067//  popup_and_OK("Pausing");
1068
1069    res =
1070        run_program_and_log_to_screen(command,
1071                                      "Generating boot+data disks");
1072    if (bkpinfo->nonbootable_backup) {
1073        res = 0;
1074    }                           // hack
1075    if (!res) {
1076        log_to_screen("Boot+data disks were created OK");
1077        sprintf(command, "cp -f %s/images/mindi.iso %s/mondorescue.iso",
1078                bkpinfo->scratchdir, MINDI_CACHE);
1079        log_msg(2, command);
1080        run_program_and_log_output(command, FALSE);
1081        if (bkpinfo->nonbootable_backup) {
1082            sprintf(command, "cp -f %s/all.tar.gz %s/images",
1083                    bkpinfo->tmpdir, bkpinfo->scratchdir);
1084            if (system(command)) {
1085                fatal_error("Unable to create temporary all tarball");
1086            }
1087        }
1088        /* For USB we already have everything on the key */
1089        if (bkpinfo->backup_media_type == usb) {
1090            sprintf(command, "rm -rf %s/images", bkpinfo->scratchdir);
1091            run_program_and_log_output(command, FALSE);
1092        } else {
1093            sprintf(command, "cp -f %s/mindi-*oot*.img %s/images",
1094                bkpinfo->tmpdir, bkpinfo->scratchdir);
1095            if (system(command)) {
1096                log_msg(2, "Unable to copy mindi images");
1097            }
1098            sprintf(tmp, "cp -f %s/images/all.tar.gz %s", bkpinfo->scratchdir,
1099                bkpinfo->tmpdir);
1100            if (system(tmp)) {
1101                fatal_error("Cannot find all.tar.gz in tmpdir");
1102            }
1103        }
1104        if (res) {
1105            mvaddstr_and_log_it(g_currentY++, 74, "Errors.");
1106        } else {
1107            mvaddstr_and_log_it(g_currentY++, 74, "Done.");
1108        }
1109    } else {
1110        log_to_screen("Mindi failed to create your boot+data disks.");
1111        strcpy(command, "grep 'Fatal error' /var/log/mindi.log");
1112        strcpy(tmp, call_program_and_get_last_line_of_output(command));
1113        if (strlen(tmp) > 1) {
1114            popup_and_OK(tmp);
1115        }
1116    }
1117    paranoid_free(tmp);
1118    paranoid_free(use_lzo_sz);
1119    paranoid_free(use_gzip_sz);
1120    paranoid_free(scratchdir);
1121    paranoid_free(use_comp_sz);
1122    paranoid_free(bootldr_str);
1123    paranoid_free(tape_device);
1124    paranoid_free(last_filelist_number);
1125    paranoid_free(broken_bios_sz);
1126    paranoid_free(cd_recovery_sz);
1127    paranoid_free(tape_size_sz);
1128    paranoid_free(devs_to_exclude);
1129    paranoid_free(use_lilo_sz);
1130    paranoid_free(value);
1131    paranoid_free(bootdev);
1132    paranoid_free(command);
1133    paranoid_free(use_star_sz);
1134    return (res);
1135}
1136
1137
1138
1139/**
1140 * Maximum number of filesets allowed in this function.
1141 */
1142#define MAX_NOOF_SETS_HERE 32767
1143
1144/**
1145 * Offset of the bkpinfo pointer (in bytes) from the
1146 * buffer passed to create_afio_files_in_background.
1147 */
1148#define BKPINFO_LOC_OFFSET (16+MAX_NOOF_SETS_HERE/8+16)
1149
1150/**
1151 * Main function for each @c afio thread.
1152 * @param inbuf A transfer block containing:
1153 * - @c p_last_set_archived: [offset 0] pointer to an @c int
1154 *   containing the last set archived.
1155 * - @c p_archival_threads_running: [offset 4] pointer to an @c int
1156 *   containing the number of archival threads currently running.
1157 * - @c p_next_set_to_archive: [offset 8] pointer to an @c int containing
1158 *   the next set that should be archived.
1159 * - @c p_list_of_fileset_flags: [offset 12] @c char pointer pointing to a
1160 *   bit array, where each bit corresponds to a filelist (1=needs
1161 *   to be archived, 0=archived).
1162 * - @c bkpinfo: [offset BKPINFO_LOC_OFFSET] pointer to backup information
1163 *   structure. Fields used:
1164 *   - @c tmpdir
1165 *   - @c zip_suffix
1166 *
1167 * Any of the above may be modified by the caller at any time.
1168 *
1169 * @bug Assumes @c int pointers are 4 bytes.
1170 * @see archive_this_fileset
1171 * @see make_afioballs_and_images
1172 * @return NULL, always.
1173 * @ingroup LLarchiveGroup
1174 */
1175void *create_afio_files_in_background(void *inbuf)
1176{
1177    long int archiving_set_no;
1178    char *archiving_filelist_fname;
1179    char *archiving_afioball_fname;
1180    char *curr_xattr_list_fname = NULL;
1181    char *curr_acl_list_fname;
1182
1183    struct s_bkpinfo *bkpinfo_bis;
1184    char *tmp;
1185    int res = 0, retval = 0;
1186    int *p_archival_threads_running;
1187    int *p_last_set_archived;
1188    int *p_next_set_to_archive;
1189    char *p_list_of_fileset_flags;
1190    int this_thread_no = g_current_thread_no++;
1191
1192    malloc_string(curr_xattr_list_fname);
1193    malloc_string(curr_acl_list_fname);
1194    malloc_string(archiving_filelist_fname);
1195    malloc_string(archiving_afioball_fname);
1196    malloc_string(tmp);
1197    p_last_set_archived = (int *) inbuf;
1198    p_archival_threads_running = (int *) (inbuf + 4);
1199    p_next_set_to_archive = (int *) (inbuf + 8);
1200    p_list_of_fileset_flags = (char *) (inbuf + 12);
1201    bkpinfo_bis = (struct s_bkpinfo *) (inbuf + BKPINFO_LOC_OFFSET);
1202
1203    sprintf(archiving_filelist_fname, FILELIST_FNAME_RAW_SZ,
1204            bkpinfo->tmpdir, 0L);
1205    for (archiving_set_no = 0; does_file_exist(archiving_filelist_fname);
1206         sprintf(archiving_filelist_fname, FILELIST_FNAME_RAW_SZ,
1207                 bkpinfo->tmpdir, archiving_set_no)) {
1208        if (g_exiting) {
1209            fatal_error("Execution run aborted (pthread)");
1210        }
1211        if (archiving_set_no >= MAX_NOOF_SETS_HERE) {
1212            fatal_error
1213                ("Maximum number of filesets exceeded. Adjust MAX_NOOF_SETS_HERE, please.");
1214        }
1215        if (!semaphore_p()) {
1216            log_msg(3, "P sem failed (pid=%d)", (int) getpid());
1217            fatal_error("Cannot get semaphore P");
1218        }
1219        if (archiving_set_no < *p_next_set_to_archive) {
1220            archiving_set_no = *p_next_set_to_archive;
1221        }
1222        *p_next_set_to_archive = *p_next_set_to_archive + 1;
1223        if (!semaphore_v()) {
1224            fatal_error("Cannot get semaphore V");
1225        }
1226
1227        /* backup this set of files */
1228        sprintf(archiving_afioball_fname, AFIOBALL_FNAME_RAW_SZ,
1229                bkpinfo->tmpdir, archiving_set_no, bkpinfo->zip_suffix);
1230        sprintf(archiving_filelist_fname, FILELIST_FNAME_RAW_SZ,
1231                bkpinfo->tmpdir, archiving_set_no);
1232        if (!does_file_exist(archiving_filelist_fname)) {
1233            log_msg(3,
1234                    "%s[%d:%d] - well, I would archive %d, except that it doesn't exist. I'll stop now.",
1235                    FORTY_SPACES, getpid(), this_thread_no,
1236                    archiving_set_no);
1237            break;
1238        }
1239
1240        sprintf(tmp, AFIOBALL_FNAME_RAW_SZ, bkpinfo->tmpdir,
1241                archiving_set_no - ARCH_BUFFER_NUM, bkpinfo->zip_suffix);
1242        if (does_file_exist(tmp)) {
1243            log_msg(4, "%s[%d:%d] - waiting for storer", FORTY_SPACES,
1244                    getpid(), this_thread_no);
1245            while (does_file_exist(tmp)) {
1246                sleep(1);
1247            }
1248            log_msg(4, "[%d] - continuing", getpid());
1249        }
1250
1251        log_msg(4, "%s[%d:%d] - EXATing %d...", FORTY_SPACES, getpid(),
1252                this_thread_no, archiving_set_no);
1253        if (g_getfattr) {
1254            sprintf(curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ,
1255                bkpinfo->tmpdir, archiving_set_no);
1256            get_fattr_list(archiving_filelist_fname, curr_xattr_list_fname);
1257        }
1258        if (g_getfacl) {
1259            sprintf(curr_acl_list_fname, ACL_LIST_FNAME_RAW_SZ,
1260                bkpinfo->tmpdir, archiving_set_no);
1261            get_acl_list(archiving_filelist_fname, curr_acl_list_fname);
1262        }
1263
1264        log_msg(4, "%s[%d:%d] - archiving %d...", FORTY_SPACES, getpid(),
1265                this_thread_no, archiving_set_no);
1266        res =
1267            archive_this_fileset(archiving_filelist_fname,
1268                                 archiving_afioball_fname,
1269                                 archiving_set_no);
1270        retval += res;
1271
1272        if (res) {
1273            sprintf(tmp,
1274                    "Errors occurred while archiving set %ld. Please review logs.",
1275                    archiving_set_no);
1276            log_to_screen(tmp);
1277        }
1278        if (!semaphore_p()) {
1279            fatal_error("Cannot get semaphore P");
1280        }
1281
1282        set_bit_N_of_array(p_list_of_fileset_flags, archiving_set_no, 5);
1283
1284        if (*p_last_set_archived < archiving_set_no) {
1285            *p_last_set_archived = archiving_set_no;
1286        }                       // finished archiving this one
1287
1288        if (!semaphore_v()) {
1289            fatal_error("Cannot get semaphore V");
1290        }
1291        log_msg(4, "%s[%d:%d] - archived %d OK", FORTY_SPACES, getpid(),
1292                this_thread_no, archiving_set_no);
1293        archiving_set_no++;
1294    }
1295    if (!semaphore_p()) {
1296        fatal_error("Cannot get semaphore P");
1297    }
1298    (*p_archival_threads_running)--;
1299    if (!semaphore_v()) {
1300        fatal_error("Cannot get semaphore V");
1301    }
1302    log_msg(3, "%s[%d:%d] - exiting", FORTY_SPACES, getpid(),
1303            this_thread_no);
1304    paranoid_free(archiving_filelist_fname);
1305    paranoid_free(archiving_afioball_fname);
1306    paranoid_free(curr_xattr_list_fname);
1307    paranoid_free(curr_acl_list_fname);
1308    paranoid_free(tmp);
1309    pthread_exit(NULL);
1310}
1311
1312
1313
1314
1315
1316/**
1317 * Finalize the backup.
1318 * For streaming backups, this writes the closing block
1319 * to the stream. For CD-based backups, this creates
1320 * the final ISO image.
1321 * @param bkpinfo The backup information structure, used only
1322 * for the @c backup_media_type.
1323 * @ingroup MLarchiveGroup
1324 */
1325int do_that_final_phase()
1326{
1327
1328    /*@ int ************************************** */
1329    int res = 0;
1330    int retval = 0;
1331
1332    /*@ buffers ********************************** */
1333
1334    assert(bkpinfo != NULL);
1335    mvaddstr_and_log_it(g_currentY, 0,
1336                        "Writing any remaining data to media         ");
1337
1338    log_msg(1, "Closing tape/CD ... ");
1339    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type))
1340        /* write tape/cdstream */
1341    {
1342        closeout_tape();
1343    } else
1344        /* write final ISO/USB */
1345    {
1346        res = write_final_iso_if_necessary();
1347        retval += res;
1348        if (res) {
1349            log_msg(1, "write_final_iso_if_necessary returned an error");
1350        }
1351    }
1352    log_msg(2, "Fork is exiting ... ");
1353
1354    mvaddstr_and_log_it(g_currentY++, 74, "Done.");
1355
1356    /* final stuff */
1357    if (retval) {
1358        mvaddstr_and_log_it(g_currentY++, 74, "Errors.");
1359    } else {
1360        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
1361    }
1362
1363    return (retval);
1364}
1365
1366
1367/**
1368 * Initialize the backup.
1369 * Does the following:
1370 * - Sets up the serial number.
1371 * - For streaming backups, opens the tape stream and writes the data disks
1372 *   and backup headers.
1373 * - For CD-based backups, wipes the ISOs in the target directory.
1374 *
1375 * @param bkpinfo The backup information structure. Fields used:
1376 * - @c backup_media_type
1377 * - @c cdrw_speed
1378 * - @c prefix
1379 * - @c isodir
1380 * - @c media_device
1381 * - @c scratchdir
1382 * - @c tmpdir
1383 * @return The number of errors encountered (0 for success).
1384 * @ingroup MLarchiveGroup
1385 */
1386int do_that_initial_phase()
1387{
1388    /*@ int *************************************** */
1389    int retval = 0;
1390
1391    /*@ buffers *********************************** */
1392    char *command, *tmpfile, *data_disks_file;
1393
1394    assert(bkpinfo != NULL);
1395    malloc_string(command);
1396    malloc_string(tmpfile);
1397    malloc_string(data_disks_file);
1398    sprintf(data_disks_file, "%s/all.tar.gz", bkpinfo->tmpdir);
1399
1400    snprintf(g_serial_string, MAX_STR_LEN - 1,
1401             call_program_and_get_last_line_of_output("dd \
1402if=/dev/urandom bs=16 count=1 2> /dev/null | \
1403hexdump | tr -s ' ' '0' | head -n1"));
1404    strip_spaces(g_serial_string);
1405    strcat(g_serial_string, "...word.");
1406    log_msg(2, "g_serial_string = '%s'", g_serial_string);
1407    assert(strlen(g_serial_string) < MAX_STR_LEN);
1408
1409    sprintf(tmpfile, "%s/archives/SERIAL-STRING", bkpinfo->scratchdir);
1410    if (write_one_liner_data_file(tmpfile, g_serial_string)) {
1411        log_msg(1, "%ld: Failed to write serial string", __LINE__);
1412    }
1413
1414    mvaddstr_and_log_it(g_currentY, 0, "Preparing to archive your data");
1415    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
1416        if (bkpinfo->backup_media_type == cdstream) {
1417            openout_cdstream(bkpinfo->media_device, bkpinfo->cdrw_speed);
1418        } else {
1419            openout_tape(bkpinfo->media_device, bkpinfo->internal_tape_block_size); /* sets g_tape_stream */
1420        }
1421        if (!g_tape_stream) {
1422            fatal_error("Cannot open backup (streaming) device");
1423        }
1424        log_msg(1, "Backup (stream) opened OK");
1425        write_data_disks_to_stream(data_disks_file);
1426    } else {
1427        log_msg(1, "Backing up to CD's");
1428    }
1429
1430    sprintf(command, "rm -f %s/%s/%s-[1-9]*.iso", bkpinfo->isodir,
1431            bkpinfo->nfs_remote_dir, bkpinfo->prefix);
1432    paranoid_system(command);
1433    wipe_archives(bkpinfo->scratchdir);
1434    mvaddstr_and_log_it(g_currentY++, 74, "Done.");
1435    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
1436        write_header_block_to_stream((off_t)0, "start-of-tape",
1437                                     BLK_START_OF_TAPE);
1438        write_header_block_to_stream((off_t)0, "start-of-backup",
1439                                     BLK_START_OF_BACKUP);
1440    }
1441    paranoid_free(command);
1442    paranoid_free(tmpfile);
1443    paranoid_free(data_disks_file);
1444    return (retval);
1445}
1446
1447
1448/**
1449 * Calls floppy-formatting @c cmd and tracks its progress if possible.
1450 *
1451 * @param cmd The command to run (e.g. @c fdformat @c /dev/fd0).
1452 * @param title The human-friendly description of the floppy you are writing.
1453 * This will be used as the title in the progress bar window. Example:
1454 * "Formatting disk /dev/fd0".
1455 * @see format_disk
1456 * @return The exit code of fdformat/superformat.
1457 */
1458int format_disk_SUB(char *cmd, char *title)
1459{
1460
1461    /*@ int *************************************************************** */
1462    int res = 0;
1463    int percentage = 0;
1464    int maxtracks = 0;
1465    int trackno = 0;
1466    int last_trkno = 0;
1467
1468    /*@ buffers *********************************************************** */
1469    char *command;
1470    char *tempfile;
1471
1472    /*@ pointers ********************************************************** */
1473    FILE *pin;
1474
1475    assert_string_is_neither_NULL_nor_zerolength(cmd);
1476    assert_string_is_neither_NULL_nor_zerolength(title);
1477
1478    malloc_string(command);
1479    malloc_string(tempfile);
1480#ifdef __FreeBSD__
1481/* Ugh. FreeBSD fdformat prints out this pretty progress indicator that's
1482   impossible to parse. It looks like
1483   VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVF-------------------
1484   where V means verified, E means error, F means formatted, and - means
1485   not done yet.
1486*/
1487    return (run_program_and_log_to_screen(cmd, title));
1488#endif
1489
1490/* if Debian then do bog-standard superformat; don't be pretty */
1491    if (strstr(cmd, "superformat")) {
1492        return (run_program_and_log_to_screen(cmd, title));
1493    }
1494/* if not Debian then go ahead & use fdformat */
1495    sprintf(tempfile, "%s/mondo.floppy.log", bkpinfo->tmpdir);
1496    sprintf(command, "%s >> %s 2>> %s; rm -f %s", cmd, tempfile, tempfile,
1497            tempfile);
1498    log_msg(3, command);
1499    open_evalcall_form(title);
1500    if (!(pin = popen(command, "r"))) {
1501        log_OS_error("fmt err");
1502        return (1);
1503    }
1504    if (strstr(command, "1722")) {
1505        maxtracks = 82;
1506    } else {
1507        maxtracks = 80;
1508    }
1509    for (sleep(1); does_file_exist(tempfile); sleep(1)) {
1510        trackno = get_trackno_from_logfile(tempfile);
1511        if (trackno < 0 || trackno > 80) {
1512            log_msg(1, "Weird track#");
1513            continue;
1514        }
1515        percentage = trackno * 100 / maxtracks;
1516        if (trackno <= 5 && last_trkno > 40) {
1517            close_evalcall_form();
1518            strcpy(title, "Verifying format");
1519            open_evalcall_form(title);
1520        }
1521        last_trkno = trackno;
1522        update_evalcall_form(percentage);
1523    }
1524    close_evalcall_form();
1525    if (pclose(pin)) {
1526        res++;
1527        log_OS_error("Unable to pclose");
1528    }
1529    unlink(tempfile);
1530    paranoid_free(command);
1531    paranoid_free(tempfile);
1532    return (res);
1533}
1534
1535/**
1536 * Wrapper around @c format_disk_SUB().
1537 * This function calls @c format_disk_SUB() with a @c device of its @c device
1538 * parameter and a @c title of Formatting disk @c device. If the format
1539 * fails, the user will be given the option of retrying.
1540 *
1541 * @param device The floppy drive to write to.
1542 * @see format_disk_SUB
1543 * @return The exit code of fdformat/superformat.
1544 * @ingroup deviceGroup
1545 */
1546int format_disk(char *device)
1547{
1548
1549    /*@ int ************************************************************** */
1550    int res = 0;
1551
1552    /*@ buffer *********************************************************** */
1553    char *command;
1554    char *title;
1555
1556
1557    assert_string_is_neither_NULL_nor_zerolength(device);
1558    malloc_string(title);
1559    command = malloc(1000);
1560    if (!system("which superformat > /dev/null 2> /dev/null")) {
1561        sprintf(command, "superformat %s", device);
1562    } else {
1563#ifdef __FreeBSD__
1564        sprintf(command, "fdformat -y %s", device);
1565#else
1566        sprintf(command, "fdformat %s", device);
1567#endif
1568    }
1569    sprintf(title, "Formatting disk %s", device);
1570    while ((res = format_disk_SUB(command, title))) {
1571        if (!ask_me_yes_or_no("Failed to format disk. Retry?")) {
1572            return (res);
1573        }
1574    }
1575    paranoid_free(title);
1576    paranoid_free(command);
1577    return (res);
1578}
1579
1580/**
1581 * Get the <tt>N</tt>th bit of @c array.
1582 * @param array The bit-array (as a @c char pointer).
1583 * @param N The number of the bit you want.
1584 * @return TRUE (bit is set) or FALSE (bit is not set).
1585 * @see set_bit_N_of_array
1586 * @ingroup utilityGroup
1587 */
1588bool get_bit_N_of_array(char *array, int N)
1589{
1590    int element_number;
1591    int bit_number;
1592    int mask;
1593
1594    element_number = N / 8;
1595    bit_number = N % 8;
1596    mask = 1 << bit_number;
1597    if (array[element_number] & mask) {
1598        return (TRUE);
1599    } else {
1600        return (FALSE);
1601    }
1602}
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612/**
1613 * @addtogroup LLarchiveGroup
1614 * @{
1615 */
1616/**
1617 * Start up threads to archive your files.
1618 *
1619 * This function starts @c ARCH_THREADS threads,
1620 * each starting execution in @c create_afio_files_in_background().
1621 * Each thread will archive individual filesets, based on the
1622 * pointers passed to it and continually updated, until all files
1623 * have been backed up. This function coordinates the threads
1624 * and copies their output to the @c scratchdir.
1625 *
1626 * @param bkpinfo The backup information structure. Fields used:
1627 * - @c backup_media_type
1628 * - @c scratchdir
1629 * - @c tmpdir
1630 * - @c zip_suffix
1631 *
1632 * @return The number of errors encountered (0 for success)
1633 */
1634int make_afioballs_and_images()
1635{
1636
1637    /*@ int ************************************************** */
1638    int retval = 0;
1639    long int storing_set_no = 0;
1640    int res = 0;
1641    bool done_storing = FALSE;
1642    char *result_str;
1643    char *transfer_block;
1644    void *vp;
1645    void **pvp;
1646
1647    /*@ buffers ********************************************** */
1648    char *storing_filelist_fname;
1649    char *storing_afioball_fname;
1650    char *tmp;
1651    char *media_usage_comment;
1652    pthread_t archival_thread[ARCH_THREADS];
1653    char *p_list_of_fileset_flags;
1654    int *p_archival_threads_running;
1655    int *p_last_set_archived;
1656    int *p_next_set_to_archive;
1657    int noof_threads;
1658    int i;
1659    char *curr_xattr_list_fname = NULL;
1660    char *curr_acl_list_fname;
1661    int misc_counter_that_is_not_important = 0;
1662
1663    log_msg(8, "here");
1664    assert(bkpinfo != NULL);
1665    tmp = malloc(MAX_STR_LEN * 2);
1666    malloc_string(result_str);
1667    malloc_string(curr_xattr_list_fname);
1668    malloc_string(curr_acl_list_fname);
1669    malloc_string(storing_filelist_fname);
1670    malloc_string(media_usage_comment);
1671    malloc_string(storing_afioball_fname);
1672    transfer_block =
1673        malloc(sizeof(struct s_bkpinfo) + BKPINFO_LOC_OFFSET + 64);
1674    memset((void *) transfer_block, 0,
1675           sizeof(struct s_bkpinfo) + BKPINFO_LOC_OFFSET + 64);
1676    p_last_set_archived = (int *) transfer_block;
1677    p_archival_threads_running = (int *) (transfer_block + 4);
1678    p_next_set_to_archive = (int *) (transfer_block + 8);
1679    p_list_of_fileset_flags = (char *) (transfer_block + 12);
1680    memcpy((void *) (transfer_block + BKPINFO_LOC_OFFSET),
1681           (void *) bkpinfo, sizeof(struct s_bkpinfo));
1682    pvp = &vp;
1683    vp = (void *) result_str;
1684    *p_archival_threads_running = 0;
1685    *p_last_set_archived = -1;
1686    *p_next_set_to_archive = 0;
1687    sprintf(tmp, "%s/archives/filelist.full", bkpinfo->scratchdir);
1688    log_to_screen("Archiving regular files");
1689    log_msg(5, "Go, Shorty. It's your birthday.");
1690    open_progress_form("Backing up filesystem",
1691                       "I am backing up your live filesystem now.",
1692                       "Please wait. This may take a couple of hours.",
1693                       "Working...",
1694                       get_last_filelist_number() + 1);
1695
1696    log_msg(5, "We're gonna party like it's your birthday.");
1697
1698    srand((unsigned int) getpid());
1699    g_sem_key = 1234 + random() % 30000;
1700    if ((g_sem_id =
1701         semget((key_t) g_sem_key, 1,
1702                IPC_CREAT | S_IREAD | S_IWRITE)) == -1) {
1703        fatal_error("MABAI - unable to semget");
1704    }
1705    if (!set_semvalue()) {
1706        fatal_error("Unable to init semaphore");
1707    }                           // initialize semaphore
1708    for (noof_threads = 0; noof_threads < ARCH_THREADS; noof_threads++) {
1709        log_msg(8, "Creating thread #%d", noof_threads);
1710        (*p_archival_threads_running)++;
1711        if ((res =
1712             pthread_create(&archival_thread[noof_threads], NULL,
1713                            create_afio_files_in_background,
1714                            (void *) transfer_block))) {
1715            fatal_error("Unable to create an archival thread");
1716        }
1717    }
1718
1719    log_msg(8, "About to enter while() loop");
1720    while (!done_storing) {
1721        if (g_exiting) {
1722            fatal_error("Execution run aborted (main loop)");
1723        }
1724        if (*p_archival_threads_running == 0
1725            && *p_last_set_archived == storing_set_no - 1) {
1726            log_msg(2,
1727                    "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... :-)",
1728                    *p_last_set_archived, storing_set_no);
1729            done_storing = TRUE;
1730        } else
1731            if (!get_bit_N_of_array
1732                (p_list_of_fileset_flags, storing_set_no)) {
1733            misc_counter_that_is_not_important =
1734                (misc_counter_that_is_not_important + 1) % 5;
1735            if (!misc_counter_that_is_not_important) {
1736                update_progress_form(media_usage_comment);
1737            }
1738            sleep(1);
1739        } else
1740            // store set N
1741        {
1742            sprintf(storing_filelist_fname, FILELIST_FNAME_RAW_SZ,
1743                    bkpinfo->tmpdir, storing_set_no);
1744            sprintf(storing_afioball_fname, AFIOBALL_FNAME_RAW_SZ,
1745                    bkpinfo->tmpdir, storing_set_no, bkpinfo->zip_suffix);
1746            if (g_getfattr) {
1747                sprintf(curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ,
1748                    bkpinfo->tmpdir, storing_set_no);
1749            }
1750            if (g_getfacl) {
1751                sprintf(curr_acl_list_fname, ACL_LIST_FNAME_RAW_SZ,
1752                    bkpinfo->tmpdir, storing_set_no);
1753            }
1754
1755            log_msg(2, "Storing set %d", storing_set_no);
1756            while (!does_file_exist(storing_filelist_fname)
1757                   || !does_file_exist(storing_afioball_fname)) {
1758                log_msg(2,
1759                        "Warning - either %s or %s doesn't exist yet. I'll pause 5 secs.",
1760                        storing_filelist_fname, storing_afioball_fname);
1761                sleep(5);
1762            }
1763            strcpy(media_usage_comment, percent_media_full_comment());
1764            /* copy to CD (scratchdir) ... and an actual CD-R if necessary */
1765            if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
1766                register_in_tape_catalog(fileset, storing_set_no, -1,
1767                                         storing_afioball_fname);
1768                maintain_collection_of_recent_archives(bkpinfo->tmpdir,
1769                                                       storing_afioball_fname);
1770                iamhere("Writing EXAT files");
1771                res +=
1772                    write_EXAT_files_to_tape(curr_xattr_list_fname,
1773                                             curr_acl_list_fname);
1774// archives themselves
1775                res +=
1776                    move_files_to_stream(storing_afioball_fname,
1777                                         NULL);
1778            } else {
1779                if (g_getfacl) {
1780                    if (g_getfattr) {
1781                        res = move_files_to_cd(storing_filelist_fname,
1782                                     curr_xattr_list_fname,
1783                                     curr_acl_list_fname,
1784                                     storing_afioball_fname, NULL);
1785                    } else {
1786                        res = move_files_to_cd(storing_filelist_fname,
1787                                    curr_acl_list_fname,
1788                                    storing_afioball_fname, NULL);
1789                    }
1790                } else {
1791                    if (g_getfattr) {
1792                            res = move_files_to_cd(storing_filelist_fname,
1793                                    curr_xattr_list_fname,
1794                                    storing_afioball_fname, NULL);
1795                    } else {
1796                            res = move_files_to_cd(storing_filelist_fname,
1797                                    storing_afioball_fname, NULL);
1798                    }
1799                }
1800            }
1801            retval += res;
1802            g_current_progress++;
1803            update_progress_form(media_usage_comment);
1804            if (res) {
1805                sprintf(tmp,
1806                        "Failed to add archive %ld's files to CD dir\n",
1807                        storing_set_no);
1808                log_to_screen(tmp);
1809                fatal_error
1810                    ("Is your hard disk full? If not, please send the author the logfile.");
1811            }
1812            storing_set_no++;
1813            //      sleep(2);
1814        }
1815    }
1816    close_progress_form();
1817
1818    sprintf(tmp, "Your regular files have been archived ");
1819    log_msg(2, "Joining background threads to foreground thread");
1820    for (i = 0; i < noof_threads; i++) {
1821        pthread_join(archival_thread[i], pvp);
1822        log_msg(3, "Thread %d of %d: closed OK", i + 1, noof_threads);
1823    }
1824    del_semvalue();
1825    log_msg(2, "Done.");
1826    if (retval) {
1827        strcat(tmp, "(with errors).");
1828    } else {
1829        strcat(tmp, "successfully.");
1830    }
1831    log_to_screen(tmp);
1832    paranoid_free(transfer_block);
1833    paranoid_free(result_str);
1834    paranoid_free(storing_filelist_fname);
1835    paranoid_free(media_usage_comment);
1836    paranoid_free(storing_afioball_fname);
1837    paranoid_free(curr_xattr_list_fname);
1838    paranoid_free(curr_acl_list_fname);
1839    return (retval);
1840}
1841
1842
1843void pause_for_N_seconds(int how_long, char *msg)
1844{
1845    int i;
1846    open_evalcall_form(msg);
1847    for (i = 0; i < how_long; i++) {
1848        update_evalcall_form((int) ((100.0 / (float) (how_long) * i)));
1849        sleep(1);
1850    }
1851    close_evalcall_form();
1852}
1853
1854
1855
1856
1857/**
1858 * Create a USB image in @c destfile, from files in @c bkpinfo->scratchdir.
1859 *
1860 * @param bkpinfo The backup information structure. Fields used:
1861 * - @c backup_media_type
1862 * - @c nonbootable_backup
1863 * - @c scratchdir
1864 *
1865 * @param destfile Where to put the generated USB image.
1866 * @return The number of errors encountered (0 for success)
1867 */
1868int make_usb_fs()
1869{
1870    /*@ int ********************************************** */
1871    int retval = 0;
1872    int res;
1873
1874    /*@ buffers ****************************************** */
1875    char *tmp = NULL;
1876    char *tmp1 = NULL;
1877    char *result_sz = NULL;
1878    char *message_to_screen = NULL;
1879    char *old_pwd;
1880
1881    malloc_string(old_pwd);
1882    assert(bkpinfo != NULL);
1883
1884    log_msg(2, "make_usb_fs --- scratchdir=%s", bkpinfo->scratchdir);
1885    (void) getcwd(old_pwd, MAX_STR_LEN - 1);
1886    asprintf(&tmp, "chmod 755 %s", bkpinfo->scratchdir);
1887    run_program_and_log_output(tmp, FALSE);
1888    paranoid_free(tmp);
1889    chdir(bkpinfo->scratchdir);
1890
1891    asprintf(&message_to_screen, "Copying data to make %s #%d",
1892                media_descriptor_string(bkpinfo->backup_media_type),
1893                g_current_media_number);
1894    log_msg(1, message_to_screen);
1895
1896    if (is_this_device_mounted(bkpinfo->media_device)) {
1897        log_msg(1, "USB device mounted. Remounting it at the right place");
1898        asprintf(&tmp, "umount %s", bkpinfo->media_device);
1899        run_program_and_log_output(tmp, FALSE);
1900        paranoid_free(tmp);
1901    }
1902    log_msg(1, "Mounting USB device.");
1903    asprintf(&tmp1, "%s/usb", bkpinfo->tmpdir);
1904    asprintf(&tmp, "mkdir -p %s", tmp1);
1905    run_program_and_log_output(tmp, FALSE);
1906    paranoid_free(tmp);
1907    /* Mindi always create one single parition on the USB dev */
1908    asprintf(&tmp, "mount %s1 %s", bkpinfo->media_device, tmp1);
1909    run_program_and_log_output(tmp, FALSE);
1910    paranoid_free(tmp);
1911
1912    if (bkpinfo->nonbootable_backup) {
1913        log_msg(1, "Making nonbootable USB backup not implemented yet");
1914    } else {
1915        log_msg(1, "Making bootable backup");
1916
1917        /* Command to execute */
1918        asprintf(&tmp,"mv %s/* %s", bkpinfo->scratchdir, tmp1); 
1919        res = eval_call_to_make_USB(tmp, message_to_screen);
1920        if (res) {
1921            asprintf(&result_sz, "%s ...failed",tmp);
1922        } else {
1923            asprintf(&result_sz, "%s ...OK",tmp);
1924        }
1925        log_to_screen(result_sz);
1926        paranoid_free(result_sz);
1927        paranoid_free(tmp);
1928        retval += res;
1929    }
1930    paranoid_free(message_to_screen);
1931    paranoid_free(tmp1);
1932
1933    if (is_this_device_mounted(bkpinfo->media_device)) {
1934        asprintf(&tmp, "umount %s1", bkpinfo->media_device);
1935        run_program_and_log_output(tmp, FALSE);
1936        paranoid_free(tmp);
1937    }
1938
1939    chdir(old_pwd);
1940    if (retval) {
1941        log_msg(1, "WARNING - make_usb_fs returned an error");
1942    }
1943    paranoid_free(old_pwd);
1944    return (retval);
1945}
1946
1947
1948/**
1949 * Create an ISO image in @c destfile, from files in @c bkpinfo->scratchdir.
1950 *
1951 * @param bkpinfo The backup information structure. Fields used:
1952 * - @c backup_media_type
1953 * - @c call_after_iso
1954 * - @c call_before_iso
1955 * - @c call_burn_iso
1956 * - @c call_make_iso
1957 * - @c make_cd_use_lilo
1958 * - @c manual_cd_tray
1959 * - @c nonbootable_backup
1960 * - @c scratchdir
1961 *
1962 * @param destfile Where to put the generated ISO image.
1963 * @return The number of errors encountered (0 for success)
1964 */
1965int make_iso_fs(char *destfile)
1966{
1967    /*@ int ********************************************** */
1968    int retval = 0;
1969    int res;
1970
1971    /*@ buffers ****************************************** */
1972    char *tmp;
1973    char *old_pwd;
1974    char *result_sz;
1975    char *message_to_screen;
1976    char *sz_blank_disk;
1977    char *fnam;
1978    char *tmp2;
1979    char *tmp3;
1980    bool cd_is_mountable;
1981
1982    malloc_string(old_pwd);
1983    malloc_string(result_sz);
1984    malloc_string(message_to_screen);
1985    malloc_string(sz_blank_disk);
1986    malloc_string(fnam);
1987    tmp = malloc(1200);
1988    tmp2 = malloc(1200);
1989    tmp3 = malloc(1200);
1990    assert(bkpinfo != NULL);
1991    assert_string_is_neither_NULL_nor_zerolength(destfile);
1992
1993    sprintf(tmp, "%s/isolinux.bin", bkpinfo->scratchdir);
1994    sprintf(tmp2, "%s/isolinux.bin", bkpinfo->tmpdir);
1995    if (does_file_exist(tmp)) {
1996        sprintf(tmp3, "cp -f %s %s", tmp, tmp2);
1997        paranoid_system(tmp3);
1998    }
1999    if (!does_file_exist(tmp) && does_file_exist(tmp2)) {
2000        sprintf(tmp3, "cp -f %s %s", tmp2, tmp);
2001        paranoid_system(tmp3);
2002    }
2003    /*
2004       if (!does_file_exist(tmp))
2005       {
2006       log_msg (2, "Silly bug in Mindi.pl; workaround in progress...");
2007       strcpy(fnam, call_program_and_get_last_line_of_output("locate isolinux.bin | tail -n1"));
2008       if (strlen(fnam)>0 && does_file_exist(fnam))
2009       {
2010       sprintf(tmp, "cp -f %s %s", fnam, bkpinfo->scratchdir);
2011       res = run_program_and_log_output(tmp, FALSE);
2012       }
2013       else
2014       {
2015       res = 1;
2016       }
2017       if (res)
2018       {
2019       log_msg (2, "Could not work around silly bug in Mindi.pl - sorry! Isolinux.bin missing");
2020       }
2021       }
2022     */
2023    free(tmp2);
2024    free(tmp3);
2025    tmp2 = NULL;
2026    tmp3 = NULL;
2027    if (bkpinfo->backup_media_type == iso && bkpinfo->manual_cd_tray) {
2028        popup_and_OK("Please insert new media and press Enter.");
2029    }
2030
2031    log_msg(2, "make_iso_fs --- scratchdir=%s --- destfile=%s",
2032            bkpinfo->scratchdir, destfile);
2033    (void) getcwd(old_pwd, MAX_STR_LEN - 1);
2034    sprintf(tmp, "chmod 744 %s", bkpinfo->scratchdir);
2035    run_program_and_log_output(tmp, FALSE);
2036    chdir(bkpinfo->scratchdir);
2037
2038    if (bkpinfo->call_before_iso[0] != '\0') {
2039        sprintf(message_to_screen, "Running pre-ISO call for CD#%d",
2040                g_current_media_number);
2041        res =
2042            eval_call_to_make_ISO(bkpinfo->call_before_iso,
2043                                  destfile, g_current_media_number,
2044                                  MONDO_LOGFILE, message_to_screen);
2045        if (res) {
2046            strcat(message_to_screen, "...failed");
2047        } else {
2048            strcat(message_to_screen, "...OK");
2049        }
2050        log_to_screen(message_to_screen);
2051        retval += res;
2052    }
2053
2054    if (bkpinfo->call_make_iso[0] != '\0') {
2055        log_msg(2, "bkpinfo->call_make_iso = %s", bkpinfo->call_make_iso);
2056        sprintf(tmp, "%s/archives/NOT-THE-LAST", bkpinfo->scratchdir);
2057        sprintf(message_to_screen, "Making an ISO (%s #%d)",
2058                media_descriptor_string(bkpinfo->backup_media_type),
2059                g_current_media_number);
2060
2061        pause_and_ask_for_cdr(2, &cd_is_mountable); /* if g_current_media_number >= 2 then pause & ask */
2062        if (retval) {
2063            log_to_screen
2064                ("Serious error(s) occurred already. I shan't try to write to media.");
2065        } else {
2066            res =
2067                eval_call_to_make_ISO(bkpinfo->call_make_iso,
2068                                      bkpinfo->scratchdir,
2069                                      g_current_media_number,
2070                                      MONDO_LOGFILE, message_to_screen);
2071            if (res) {
2072                log_to_screen("%s...failed to write", message_to_screen);
2073            } else {
2074                log_to_screen("%s...OK", message_to_screen);
2075                sprintf(tmp, "tail -n10 %s | grep -F ':-('", MONDO_LOGFILE);
2076                if (!run_program_and_log_output(tmp, 1)) {
2077                    log_to_screen
2078                        ("Despite nonfatal errors, growisofs confirms the write was successful.");
2079                }
2080            }
2081            retval += res;
2082#ifdef DVDRWFORMAT
2083            sprintf(tmp,
2084                    "tail -n8 %s | grep 'blank=full.*dvd-compat.*DAO'",
2085                    MONDO_LOGFILE);
2086            if (g_backup_media_type == dvd
2087                && (res || !run_program_and_log_output(tmp, 1))) {
2088                log_to_screen
2089                    ("Failed to write to disk. I shall blank it and then try again.");
2090                sleep(5);
2091                system("sync");
2092                pause_for_N_seconds(5, "Letting DVD drive settle");
2093
2094// dvd+rw-format --- OPTION 2
2095                if (!bkpinfo->please_dont_eject) {
2096                    log_to_screen("Ejecting media to clear drive status.");
2097                    eject_device(bkpinfo->media_device);
2098                    inject_device(bkpinfo->media_device);
2099                }
2100                pause_for_N_seconds(5, "Letting DVD drive settle");
2101                sprintf(sz_blank_disk, "dvd+rw-format -force %s",
2102                        bkpinfo->media_device);
2103                log_msg(3, "sz_blank_disk = '%s'", sz_blank_disk);
2104                res =
2105                    run_external_binary_with_percentage_indicator_NEW
2106                    ("Blanking DVD disk", sz_blank_disk);
2107                if (res) {
2108                    log_to_screen
2109                        ("Warning - format failed. (Was it a DVD-R?) Sleeping for 5 seconds to take a breath...");
2110                    pause_for_N_seconds(5,
2111                                        "Letting DVD drive settle... and trying again.");
2112                    res =
2113                        run_external_binary_with_percentage_indicator_NEW
2114                        ("Blanking DVD disk", sz_blank_disk);
2115                    if (res) {
2116                        log_to_screen("Format failed a second time.");
2117                    }
2118                } else {
2119                    log_to_screen
2120                        ("Format succeeded. Sleeping for 5 seconds to take a breath...");
2121                }
2122                pause_for_N_seconds(5, "Letting DVD drive settle");
2123                if (!bkpinfo->please_dont_eject) {
2124                    log_to_screen("Ejecting media to clear drive status.");
2125                    eject_device(bkpinfo->media_device);
2126                    inject_device(bkpinfo->media_device);
2127                }
2128                pause_for_N_seconds(5, "Letting DVD drive settle");
2129                res =
2130                    eval_call_to_make_ISO(bkpinfo->call_make_iso,
2131                                          bkpinfo->scratchdir,
2132                                          g_current_media_number,
2133                                          MONDO_LOGFILE,
2134                                          message_to_screen);
2135                retval += res;
2136                if (!bkpinfo->please_dont_eject) {
2137                    log_to_screen("Ejecting media.");
2138                    eject_device(bkpinfo->media_device);
2139                }
2140                if (res) {
2141                    log_to_screen("Dagnabbit. It still failed.");
2142                } else {
2143                    log_to_screen
2144                        ("OK, this time I successfully backed up to DVD.");
2145                }
2146            }
2147#endif
2148            if (g_backup_media_type == dvd && !bkpinfo->please_dont_eject) {
2149                eject_device(bkpinfo->media_device);
2150            }
2151        }
2152    } else {
2153        sprintf(message_to_screen, "Running mkisofs to make %s #%d",
2154                media_descriptor_string(bkpinfo->backup_media_type),
2155                g_current_media_number);
2156        log_msg(1, message_to_screen);
2157        sprintf(result_sz, "Call to mkisofs to make ISO (%s #%d) ",
2158                media_descriptor_string(bkpinfo->backup_media_type),
2159                g_current_media_number);
2160        if (bkpinfo->nonbootable_backup) {
2161            log_msg(1, "Making nonbootable backup");
2162// FIXME --- change mkisofs string to MONDO_MKISOFS_NONBOOTABLE and add ' .' at end
2163            res =
2164                eval_call_to_make_ISO("mkisofs -o '_ISO_' -r -p MondoRescue -publisher www.mondorescue.org -A MondoRescue_GPL -V _CD#_ .",
2165                                      destfile, g_current_media_number,
2166                                      MONDO_LOGFILE, message_to_screen);
2167        } else {
2168            log_msg(1, "Making bootable backup");
2169
2170#ifdef __FreeBSD__
2171            bkpinfo->make_cd_use_lilo = TRUE;
2172#endif
2173
2174
2175            log_msg(1, "make_cd_use_lilo is actually %d",
2176                    bkpinfo->make_cd_use_lilo);
2177            if (bkpinfo->make_cd_use_lilo) {
2178                log_msg(1, "make_cd_use_lilo = TRUE");
2179// FIXME --- change mkisofs string to MONDO_MKISOFS_REGULAR_SYSLINUX/LILO depending on bkpinfo->make_cd_usE_lilo
2180// and add ' .' at end
2181#ifdef __IA64__
2182                log_msg(1, "IA64 --> elilo");
2183                res = eval_call_to_make_ISO("mkisofs -no-emul-boot -b images/mindi-bootroot."
2184                                            IA64_BOOT_SIZE
2185                                            ".img -c boot.cat -o '_ISO_' -J -r -p MondoRescue -publisher www.mondorescue.org -A Mondo_Rescue_GPL -V _CD#_ .",
2186                                            destfile,
2187                                            g_current_media_number,
2188                                            MONDO_LOGFILE,
2189                                            message_to_screen);
2190#else
2191// FIXME --- change mkisofs string to MONDO_MKISOFS_REGULAR_SYSLINUX/LILO depending on bkpinfo->make_cd_usE_lilo
2192// and add ' .' at end
2193                log_msg(1, "Non-ia64 --> lilo");
2194                res =
2195                    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#_ .",
2196                                          destfile, g_current_media_number,
2197                                          MONDO_LOGFILE,
2198                                          message_to_screen);
2199#endif
2200            } else {
2201                log_msg(1, "make_cd_use_lilo = FALSE");
2202                log_msg(1, "Isolinux");
2203                res =
2204                    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#_ .",
2205                                          destfile, g_current_media_number,
2206                                          MONDO_LOGFILE,
2207                                          message_to_screen);
2208            }
2209        }
2210        if (res) {
2211            strcat(result_sz, "...failed");
2212        } else {
2213            strcat(result_sz, "...OK");
2214        }
2215        log_to_screen(result_sz);
2216        retval += res;
2217    }
2218
2219    if (bkpinfo->backup_media_type == cdr
2220        || bkpinfo->backup_media_type == cdrw) {
2221        if (is_this_device_mounted(bkpinfo->media_device)) {
2222            log_msg(2,
2223                    "Warning - %s mounted. I'm unmounting it before I burn to it.",
2224                    bkpinfo->media_device);
2225            sprintf(tmp, "umount %s", bkpinfo->media_device);
2226            run_program_and_log_output(tmp, FALSE);
2227        }
2228    }
2229
2230    if (bkpinfo->call_burn_iso[0] != '\0') {
2231        log_msg(2, "bkpinfo->call_burn_iso = %s", bkpinfo->call_burn_iso);
2232        sprintf(message_to_screen, "Burning %s #%d",
2233                media_descriptor_string(bkpinfo->backup_media_type),
2234                g_current_media_number);
2235        pause_and_ask_for_cdr(2, &cd_is_mountable);
2236        res =
2237            eval_call_to_make_ISO(bkpinfo->call_burn_iso,
2238                                  destfile, g_current_media_number,
2239                                  MONDO_LOGFILE, message_to_screen);
2240        if (res) {
2241            strcat(message_to_screen, "...failed");
2242        } else {
2243            strcat(message_to_screen, "...OK");
2244        }
2245        log_to_screen(message_to_screen);
2246        retval += res;
2247    }
2248
2249    if (bkpinfo->call_after_iso[0] != '\0') {
2250        sprintf(message_to_screen, "Running post-ISO call (%s #%d)",
2251                media_descriptor_string(bkpinfo->backup_media_type),
2252                g_current_media_number);
2253        res =
2254            eval_call_to_make_ISO(bkpinfo->call_after_iso,
2255                                  destfile, g_current_media_number,
2256                                  MONDO_LOGFILE, message_to_screen);
2257        if (res) {
2258            strcat(message_to_screen, "...failed");
2259        } else {
2260            strcat(message_to_screen, "...OK");
2261        }
2262        log_to_screen(message_to_screen);
2263        retval += res;
2264    }
2265
2266    chdir(old_pwd);
2267    if (retval) {
2268        log_msg(1, "WARNING - make_iso_fs returned an error");
2269    }
2270    paranoid_free(old_pwd);
2271    paranoid_free(result_sz);
2272    paranoid_free(message_to_screen);
2273    paranoid_free(sz_blank_disk);
2274    paranoid_free(fnam);
2275    paranoid_free(tmp);
2276    return (retval);
2277}
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287bool is_dev_an_NTFS_dev(char *bigfile_fname)
2288{
2289    char *tmp;
2290    char *command;
2291    malloc_string(tmp);
2292    malloc_string(command);
2293    sprintf(command,
2294            "dd if=%s bs=512 count=1 2> /dev/null | strings | head -n1",
2295            bigfile_fname);
2296    log_msg(1, "command = '%s'", command);
2297    strcpy(tmp, call_program_and_get_last_line_of_output(command));
2298    log_msg(1, "--> tmp = '%s'", tmp);
2299    if (strstr(tmp, "NTFS")) {
2300        iamhere("TRUE");
2301        return (TRUE);
2302    } else {
2303        iamhere("FALSE");
2304        return (FALSE);
2305    }
2306}
2307
2308
2309/**
2310 * Back up big files by chopping them up.
2311 * This function backs up all "big" files (where "big" depends
2312 * on your backup media) in "chunks" (whose size again depends
2313 * on your media).
2314 *
2315 * @param bkpinfo The backup information structure. Fields used:
2316 * - @c backup_media_type
2317 * - @c optimal_set_size
2318 * @param biggielist_fname The path to a file containing a list of
2319 * all "big" files.
2320 * @return The number of errors encountered (0 for success)
2321 * @see slice_up_file_etc
2322 */
2323int
2324make_slices_and_images(char *biggielist_fname)
2325{
2326
2327    /*@ pointers ******************************************* */
2328    FILE *fin;
2329    char *p;
2330
2331    /*@ buffers ******************************************** */
2332    char *tmp;
2333    char *bigfile_fname;
2334    char *sz_devfile;
2335    char *ntfsprog_fifo = NULL;
2336    /*@ long *********************************************** */
2337    long biggie_file_number = 0;
2338    long noof_biggie_files = 0;
2339    long estimated_total_noof_slices = 0;
2340
2341    /*@ int ************************************************ */
2342    int retval = 0;
2343    int res = 0;
2344    pid_t pid;
2345    FILE *ftmp = NULL;
2346    bool delete_when_done;
2347    bool use_ntfsprog;
2348    off_t biggie_fsize;
2349
2350    assert(bkpinfo != NULL);
2351    assert_string_is_neither_NULL_nor_zerolength(biggielist_fname);
2352
2353    malloc_string(tmp);
2354    malloc_string(bigfile_fname);
2355    malloc_string(sz_devfile);
2356    estimated_total_noof_slices =
2357        size_of_all_biggiefiles_K() / bkpinfo->optimal_set_size + 1;
2358
2359    log_msg(1, "size of all biggiefiles = %ld",
2360            size_of_all_biggiefiles_K());
2361    log_msg(1, "estimated_total_noof_slices = %ld KB / %ld KB = %ld",
2362            size_of_all_biggiefiles_K(), bkpinfo->optimal_set_size,
2363            estimated_total_noof_slices);
2364
2365    if (length_of_file(biggielist_fname) < 6) {
2366        log_msg(1, "No biggiefiles; fair enough...");
2367        return (0);
2368    }
2369    sprintf(tmp, "I am now backing up all large files.");
2370    log_to_screen(tmp);
2371    noof_biggie_files = count_lines_in_file(biggielist_fname);
2372    open_progress_form("Backing up big files", tmp,
2373                       "Please wait. This may take some time.", "",
2374                       estimated_total_noof_slices);
2375    if (!(fin = fopen(biggielist_fname, "r"))) {
2376        log_OS_error("Unable to openin biggielist");
2377        return (1);
2378    }
2379    for (fgets(bigfile_fname, MAX_STR_LEN, fin); !feof(fin);
2380         fgets(bigfile_fname, MAX_STR_LEN, fin), biggie_file_number++) {
2381        use_ntfsprog = FALSE;
2382        if (bigfile_fname[strlen(bigfile_fname) - 1] < 32) {
2383            bigfile_fname[strlen(bigfile_fname) - 1] = '\0';
2384        }
2385        biggie_fsize = length_of_file(bigfile_fname);
2386        delete_when_done = FALSE;
2387
2388        if (!does_file_exist(bigfile_fname)) {
2389            ftmp = fopen(bigfile_fname, "w");
2390            if (ftmp == NULL) {
2391                log_msg(3, "Unable to write to %s", bigfile_fname);
2392                // So skip it as it doesn't exist
2393                continue;
2394            } else {
2395                paranoid_fclose(ftmp);
2396            }
2397            delete_when_done = TRUE;
2398        } else {
2399            // Call ntfsclone (formerly partimagehack) if it's a /dev entry
2400            // (i.e. a partition to be imaged)
2401            log_msg(2, "bigfile_fname = %s", bigfile_fname);
2402            use_ntfsprog = FALSE;
2403            if (!strncmp(bigfile_fname, "/dev/", 5)
2404                && is_dev_an_NTFS_dev(bigfile_fname)) {
2405                use_ntfsprog = TRUE;
2406                log_msg(2,
2407                        "Calling ntfsclone in background because %s is an NTFS partition",
2408                        bigfile_fname);
2409                sprintf(sz_devfile, "%s/%d.%d.000",
2410                        bkpinfo->tmpdir,
2411                        (int) (random() % 32768),
2412                        (int) (random() % 32768));
2413                mkfifo(sz_devfile, 0x770);
2414                ntfsprog_fifo = sz_devfile;
2415                switch (pid = fork()) {
2416                case -1:
2417                    fatal_error("Fork failure");
2418                case 0:
2419                    log_msg(2,
2420                            "CHILD - fip - calling feed_into_ntfsprog(%s, %s)",
2421                            bigfile_fname, sz_devfile);
2422                    res = feed_into_ntfsprog(bigfile_fname, sz_devfile);
2423                    exit(res);
2424                    break;
2425                default:
2426                    log_msg(2,
2427                            "feed_into_ntfsprog() called in background --- pid=%ld",
2428                            (long int) (pid));
2429                }
2430            }
2431// Otherwise, use good old 'dd' and 'bzip2'
2432            else {
2433                sz_devfile[0] = '\0';
2434                ntfsprog_fifo = NULL;
2435            }
2436
2437// Whether partition or biggiefile, just do your thang :-)
2438            sprintf(tmp, "Bigfile #%ld is '%s' (%ld KB)",
2439                    biggie_file_number + 1, bigfile_fname,
2440                    (long) biggie_fsize >> 10);
2441            if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
2442                write_header_block_to_stream(biggie_fsize, bigfile_fname,
2443                                             use_ntfsprog ?
2444                                             BLK_START_A_PIHBIGGIE :
2445                                             BLK_START_A_NORMBIGGIE);
2446            }
2447            res =
2448                slice_up_file_etc(bigfile_fname,
2449                                  ntfsprog_fifo, biggie_file_number,
2450                                  noof_biggie_files, use_ntfsprog);
2451            if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
2452                write_header_block_to_stream((off_t)0,
2453                                             calc_checksum_of_file
2454                                             (bigfile_fname),
2455                                             BLK_STOP_A_BIGGIE);
2456            }
2457            retval += res;
2458            p = strrchr(bigfile_fname, '/');
2459            if (p) {
2460                p++;
2461            } else {
2462                p = bigfile_fname;
2463            }
2464            sprintf(tmp, "Archiving %s ... ", bigfile_fname);
2465            if (res) {
2466                strcat(tmp, "Failed!");
2467            } else {
2468                strcat(tmp, "OK");
2469            }
2470            if (delete_when_done) {
2471                unlink(bigfile_fname);
2472                delete_when_done = FALSE;
2473            }
2474        }
2475#ifndef _XWIN
2476        if (!g_text_mode) {
2477            newtDrawRootText(0, g_noof_rows - 2, tmp);
2478            newtRefresh();
2479        }
2480#endif
2481    }
2482    log_msg(1, "Finished backing up bigfiles");
2483    log_msg(1, "estimated slices = %ld; actual slices = %ld",
2484            estimated_total_noof_slices, g_current_progress);
2485    close_progress_form();
2486    paranoid_fclose(fin);
2487    paranoid_free(tmp);
2488    paranoid_free(bigfile_fname);
2489    paranoid_free(sz_devfile);
2490    return (retval);
2491}
2492
2493
2494
2495
2496/**
2497 * Single-threaded version of @c make_afioballs_and_images().
2498 * @see make_afioballs_and_images
2499 */
2500int make_afioballs_and_images_OLD()
2501{
2502
2503    /*@ int ************************************************** */
2504    int retval = 0;
2505    long int curr_set_no = 0;
2506    int res = 0;
2507
2508    /*@ buffers ********************************************** */
2509    char *curr_filelist_fname;
2510    char *curr_afioball_fname;
2511    char *curr_xattr_list_fname;
2512    char *curr_acl_list_fname;
2513    char *tmp;
2514    char *media_usage_comment;
2515
2516    malloc_string(curr_afioball_fname);
2517    malloc_string(media_usage_comment);
2518    malloc_string(curr_filelist_fname);
2519    malloc_string(curr_xattr_list_fname);
2520    malloc_string(curr_acl_list_fname);
2521
2522    tmp = malloc(MAX_STR_LEN * 2);
2523
2524    sprintf(tmp, "%s/archives/filelist.full", bkpinfo->scratchdir);
2525
2526    log_to_screen("Archiving regular files");
2527
2528    open_progress_form("Backing up filesystem",
2529                       "I am backing up your live filesystem now.",
2530                       "Please wait. This may take a couple of hours.",
2531                       "Working...",
2532                       get_last_filelist_number() + 1);
2533
2534    sprintf(curr_filelist_fname, FILELIST_FNAME_RAW_SZ, bkpinfo->tmpdir,
2535            0L);
2536
2537    for (curr_set_no = 0; does_file_exist(curr_filelist_fname);
2538         sprintf(curr_filelist_fname, FILELIST_FNAME_RAW_SZ,
2539                 bkpinfo->tmpdir, ++curr_set_no)) {
2540        /* backup this set of files */
2541        sprintf(curr_filelist_fname, FILELIST_FNAME_RAW_SZ,
2542                bkpinfo->tmpdir, curr_set_no);
2543        sprintf(curr_afioball_fname, AFIOBALL_FNAME_RAW_SZ,
2544                bkpinfo->tmpdir, curr_set_no, bkpinfo->zip_suffix);
2545
2546        log_msg(1, "EXAT'g set %ld", curr_set_no);
2547        if (g_getfattr) {
2548            sprintf(curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ,
2549                bkpinfo->tmpdir, curr_set_no);
2550            get_fattr_list(curr_filelist_fname, curr_xattr_list_fname);
2551        }
2552        if (g_getfacl) {
2553            sprintf(curr_acl_list_fname, ACL_LIST_FNAME_RAW_SZ,
2554                bkpinfo->tmpdir, curr_set_no);
2555            get_acl_list(curr_filelist_fname, curr_acl_list_fname);
2556        }
2557
2558        log_msg(1, "Archiving set %ld", curr_set_no);
2559        res =
2560            archive_this_fileset(curr_filelist_fname,
2561                                 curr_afioball_fname, curr_set_no);
2562        retval += res;
2563        if (res) {
2564            sprintf(tmp,
2565                    "Errors occurred while archiving set %ld. Perhaps your live filesystem changed?",
2566                    curr_set_no);
2567            log_to_screen(tmp);
2568        }
2569
2570        strcpy(media_usage_comment, percent_media_full_comment());
2571
2572        /* copy to CD (scratchdir) ... and an actual CD-R if necessary */
2573        if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
2574            register_in_tape_catalog(fileset, curr_set_no, -1,
2575                                     curr_afioball_fname);
2576            maintain_collection_of_recent_archives(bkpinfo->tmpdir,
2577                                                   curr_afioball_fname);
2578            iamhere("Writing EXAT files");
2579            res +=
2580                write_EXAT_files_to_tape(curr_xattr_list_fname,
2581                                         curr_acl_list_fname);
2582// archives themselves
2583            res = move_files_to_stream(curr_afioball_fname, NULL);
2584        } else {
2585                if (g_getfacl) {
2586                    if (g_getfattr) {
2587                        res = move_files_to_cd(curr_filelist_fname,
2588                                     curr_xattr_list_fname,
2589                                     curr_acl_list_fname,
2590                                     curr_afioball_fname, NULL);
2591                    } else {
2592                        res = move_files_to_cd(curr_filelist_fname,
2593                                    curr_acl_list_fname,
2594                                    curr_afioball_fname, NULL);
2595                    }
2596                } else {
2597                    if (g_getfattr) {
2598                            res = move_files_to_cd(curr_filelist_fname,
2599                                    curr_xattr_list_fname,
2600                                    curr_afioball_fname, NULL);
2601                    } else {
2602                            res = move_files_to_cd(curr_filelist_fname,
2603                                    curr_afioball_fname, NULL);
2604                    }
2605                }
2606        }
2607        retval += res;
2608        g_current_progress++;
2609        update_progress_form(media_usage_comment);
2610
2611        if (res) {
2612            sprintf(tmp, "Failed to add archive %ld's files to CD dir\n",
2613                    curr_set_no);
2614            log_to_screen(tmp);
2615            fatal_error
2616                ("Is your hard disk is full? If not, please send the author the logfile.");
2617        }
2618    }
2619    close_progress_form();
2620    sprintf(tmp, "Your regular files have been archived ");
2621    if (retval) {
2622        strcat(tmp, "(with errors).");
2623    } else {
2624        strcat(tmp, "successfully.");
2625    }
2626    log_to_screen(tmp);
2627    paranoid_free(tmp);
2628    paranoid_free(curr_filelist_fname);
2629    paranoid_free(curr_afioball_fname);
2630    paranoid_free(media_usage_comment);
2631    paranoid_free(curr_xattr_list_fname);
2632    paranoid_free(curr_acl_list_fname);
2633    return (retval);
2634}
2635
2636/* @} - end of LLarchiveGroup */
2637
2638
2639/**
2640 * Wrapper around @c make_afioballs_and_images().
2641 * @param bkpinfo the backup information structure. Only the
2642 * @c backup_media_type field is used within this function.
2643 * @return return code of make_afioballs_and_images
2644 * @see make_afioballs_and_images
2645 * @ingroup MLarchiveGroup
2646 */
2647int make_those_afios_phase()
2648{
2649    /*@ int ******************************************* */
2650    int res = 0;
2651    int retval = 0;
2652
2653    assert(bkpinfo != NULL);
2654
2655    mvaddstr_and_log_it(g_currentY, 0,
2656                        "Archiving regular files to media          ");
2657
2658    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
2659        write_header_block_to_stream((off_t)0, "start-of-afioballs",
2660                                     BLK_START_AFIOBALLS);
2661#if __FreeBSD__ == 5
2662        log_msg(1,
2663                "Using single-threaded make_afioballs_and_images() to suit b0rken FreeBSD 5.0");
2664        res = make_afioballs_and_images_OLD();
2665#else
2666        res = make_afioballs_and_images_OLD();
2667#endif
2668        write_header_block_to_stream((off_t)0, "stop-afioballs",
2669                                     BLK_STOP_AFIOBALLS);
2670    } else {
2671        res = make_afioballs_and_images();
2672    }
2673
2674    retval += res;
2675    if (res) {
2676        mvaddstr_and_log_it(g_currentY++, 74, "Errors.");
2677        log_msg(1, "make_afioballs_and_images returned an error");
2678    } else {
2679        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
2680    }
2681    return (retval);
2682}
2683
2684/**
2685 * Wrapper around @c make_slices_and_images().
2686 * @param bkpinfo The backup information structure. Fields used:
2687 * - @c backup_media_type
2688 * - @c scratchdir
2689 * - @c tmpdir
2690 * @return The number of errors encountered (0 for success)
2691 * @ingroup MLarchiveGroup
2692 */
2693int make_those_slices_phase()
2694{
2695
2696    /*@ int ***************************************************** */
2697    int res = 0;
2698    int retval = 0;
2699
2700    /*@ buffers ************************************************** */
2701    char *biggielist;
2702    char *command;
2703    char *blah;
2704    char *xattr_fname;
2705    char *acl_fname;
2706
2707    assert(bkpinfo != NULL);
2708    /* slice big files */
2709    malloc_string(biggielist);
2710    malloc_string(xattr_fname);
2711    malloc_string(acl_fname);
2712    mvaddstr_and_log_it(g_currentY, 0,
2713                        "Archiving large files to media           ");
2714    sprintf(biggielist, "%s/archives/biggielist.txt", bkpinfo->scratchdir);
2715    if (g_getfattr) {
2716        sprintf(xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
2717    }
2718    if (g_getfacl) {
2719        sprintf(acl_fname, ACL_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
2720    }
2721
2722    asprintf(&command, "cp %s/biggielist.txt %s", bkpinfo->tmpdir,
2723            biggielist);
2724    paranoid_system(command);
2725    paranoid_free(command);
2726
2727    asprintf(&blah, "biggielist = %s", biggielist);
2728    log_msg(2, blah);
2729    paranoid_free(blah);
2730
2731    if (!does_file_exist(biggielist)) {
2732        log_msg(1, "BTW, the biggielist does not exist");
2733    }
2734
2735    if (g_getfattr) {
2736        get_fattr_list(biggielist, xattr_fname);
2737        asprintf(&command, "cp %s %s/archives/", xattr_fname,
2738            bkpinfo->scratchdir);
2739        paranoid_system(command);
2740        paranoid_free(command);
2741    }
2742    if (g_getfacl) {
2743        get_acl_list(biggielist, acl_fname);
2744        asprintf(&command, "cp %s %s/archives/", acl_fname,
2745             bkpinfo->scratchdir);
2746        paranoid_system(command);
2747        paranoid_free(command);
2748    }
2749
2750    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
2751        res += write_EXAT_files_to_tape(xattr_fname, acl_fname);
2752        asprintf(&blah, "%ld", count_lines_in_file(biggielist));
2753        write_header_block_to_stream((off_t)0, blah, BLK_START_BIGGIEFILES);
2754        paranoid_free(blah);
2755    }
2756    res = make_slices_and_images(biggielist);
2757    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
2758        write_header_block_to_stream((off_t)0, "end-of-biggiefiles",
2759                                     BLK_STOP_BIGGIEFILES);
2760    }
2761    retval += res;
2762    if (res) {
2763        log_msg(1, "make_slices_and_images returned an error");
2764        mvaddstr_and_log_it(g_currentY++, 74, "Errors.");
2765    } else {
2766        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
2767    }
2768    paranoid_free(blah);
2769    paranoid_free(biggielist);
2770    paranoid_free(command);
2771    paranoid_free(xattr_fname);
2772    paranoid_free(acl_fname);
2773    return (retval);
2774}
2775
2776
2777/**
2778 * @addtogroup LLarchiveGroup
2779 * @{
2780 */
2781/**
2782 * Function pointer to an appropriate @c move_files_to_cd routine.
2783 * You can set this to your own function (for example, one to
2784 * transfer files over the network) or leave it as is.
2785 */
2786int (*move_files_to_cd) (char *, ...) =
2787    _move_files_to_cd;
2788
2789/**
2790 * Move some files to the ISO scratch directory.
2791 * This function moves files specified as parameters, into the directory
2792 * @c bkpinfo->scratchdir, where the files that will be stored on the next
2793 * CD are waiting.
2794 *
2795 * @param bkpinfo The backup information structure. Fields used:
2796 * - @c media_size
2797 * - @c scratchdir
2798 * @param files_to_add The files to add to the scratchdir.
2799 * @warning The list of @c files_to_add must be terminated with @c NULL.
2800 * @note If and when the space occupied by the scratchdir would exceed
2801 * the capacity of the current CD,
2802 * <tt>write_iso_and_go_on(bkpinfo, FALSE)</tt> is called and the
2803 * scratchdir is emptied.
2804 *
2805 * @return The number of errors encountered (0 for success)
2806 */
2807int _move_files_to_cd(char *files_to_add, ...)
2808{
2809
2810    /*@ int ************************************************************ */
2811    int retval = 0;
2812    int res = 0;
2813
2814    /*@ buffers ******************************************************** */
2815    char *tmp, *curr_file, *cf;
2816
2817    /*@ long ************************************************************ */
2818    va_list ap;
2819    long long would_occupy;
2820
2821    assert(bkpinfo != NULL);
2822    malloc_string(curr_file);
2823    tmp = malloc(1200);
2824    would_occupy = space_occupied_by_cd(bkpinfo->scratchdir);
2825    va_start(ap, files_to_add); // initialize the variable arguments
2826    for (cf = files_to_add; cf != NULL; cf = va_arg(ap, char *)) {
2827        if (!cf) {
2828            continue;
2829        }
2830        strcpy(curr_file, cf);
2831        if (!does_file_exist(curr_file)) {
2832            log_msg(1,
2833                    "Warning - you're trying to add a non-existent file - '%s' to the CD",
2834                    curr_file);
2835        } else {
2836            log_msg(8, "Trying to add file %s to CD", curr_file);
2837            would_occupy += length_of_file(curr_file) / 1024;
2838        }
2839    }
2840    va_end(ap);
2841
2842    if (bkpinfo->media_size[g_current_media_number] <= 0) {
2843        fatal_error("move_files_to_cd() - unknown media size");
2844    }
2845    if (would_occupy / 1024 > bkpinfo->media_size[g_current_media_number]) {
2846        res = write_iso_and_go_on(FALSE);   /* FALSE because this is not the last CD we'll write */
2847        retval += res;
2848        if (res) {
2849            log_msg(1, "WARNING - write_iso_and_go_on returned an error");
2850        }
2851    }
2852
2853    va_start(ap, files_to_add); // initialize the variable arguments
2854    for (cf = files_to_add; cf != NULL; cf = va_arg(ap, char *)) {
2855        if (!cf) {
2856            continue;
2857        }
2858        strcpy(curr_file, cf);
2859
2860        sprintf(tmp, "mv -f %s %s/archives/", curr_file,
2861                bkpinfo->scratchdir);
2862        res = run_program_and_log_output(tmp, 5);
2863        retval += res;
2864        if (res) {
2865            log_msg(1, "(move_files_to_cd) '%s' failed", tmp);
2866        } else {
2867            log_msg(8, "Moved %s to CD OK", tmp);
2868        }
2869        //      unlink (curr_file);
2870    }
2871    va_end(ap);
2872
2873    if (retval) {
2874        log_msg(1,
2875                "Warning - errors occurred while I was adding files to CD dir");
2876    }
2877    paranoid_free(tmp);
2878    paranoid_free(curr_file);
2879    return (retval);
2880}
2881
2882/* @} - end of LLarchiveGroup */
2883
2884
2885
2886
2887
2888
2889
2890
2891/**
2892 * Offer to write boot and data disk images to 3.5" floppy disks.
2893 * @param bkpinfo The backup information structure. Only the
2894 * @c backup_media_type field is used in this function.
2895 * @param imagesdir The directory containing the floppy images (usually
2896 * /root/images/mindi).
2897 *
2898 * @return The number of errors encountered (0 for success)
2899 * @see write_image_to_floppy
2900 * @see format_disk
2901 * @ingroup MLarchiveGroup
2902 */
2903int offer_to_write_floppies(char *imagesdir)
2904{
2905    /*@ buffer ************************************************************ */
2906    char *tmp;
2907    char *comment;
2908    char *bootdisk_dev;
2909    char *datadisk_dev;
2910    char *bootdisk_file;
2911    char *rootdisk_file;
2912
2913    /*@ int *************************************************************** */
2914    int i = 0;
2915    int res = 0;
2916
2917    /*@ bool ************************************************************** */
2918    bool format_first;
2919    bool root_disk_exists = FALSE;
2920
2921    malloc_string(tmp);
2922    malloc_string(comment);
2923    malloc_string(bootdisk_dev);
2924    malloc_string(datadisk_dev);
2925    malloc_string(rootdisk_file);
2926    malloc_string(bootdisk_file);
2927    assert(bkpinfo != NULL);
2928    assert_string_is_neither_NULL_nor_zerolength(imagesdir);
2929
2930
2931    if (!ask_me_yes_or_no
2932        ("Write boot and data disk images to 3.5\" floppy disks?")) {
2933        return (0);
2934    }
2935    if (does_device_exist(DEFAULT_1722MB_DISK)) {
2936#ifdef __FreeBSD__
2937        // tell the system that this is a 1.72m floppy
2938        system("/usr/sbin/fdcontrol -F 1722 /dev/fd0.1722");
2939#endif
2940        strcpy(bootdisk_dev, DEFAULT_1722MB_DISK);
2941    } else if (does_device_exist(BACKUP_1722MB_DISK)) {
2942        sprintf(bootdisk_dev, "/dev/fd0H1722");
2943    } else {
2944        log_msg(1, "Warning - can't find a 1.72MB floppy device *sigh*");
2945        strcpy(bootdisk_dev, DEFAULT_1722MB_DISK);
2946//      return (1);
2947    }
2948    strcpy(datadisk_dev, "/dev/fd0");
2949    if (!does_device_exist(datadisk_dev)) {
2950        log_msg(1, "Warning - can't find a 1.44MB floppy device *sigh*");
2951        strcpy(datadisk_dev, "/dev/fd0");
2952//      return (1);
2953    }
2954    format_first =
2955        ask_me_yes_or_no
2956        ("Do you want me to format the disks before I write to them?");
2957
2958/* boot disk */
2959    if (ask_me_OK_or_cancel("About to write boot disk")) {
2960        log_to_screen("Writing boot floppy");
2961#ifdef __FreeBSD__
2962        sprintf(tmp, "%s/mindi-kern.1722.img", imagesdir);
2963        if (format_first) {
2964            format_disk(bootdisk_dev);
2965        }
2966        res += write_image_to_floppy(bootdisk_dev, tmp);
2967        if (ask_me_OK_or_cancel("About to write 1.44MB mfsroot disk")) {
2968            log_to_screen("Writing mfsroot floppy");
2969            if (format_first) {
2970                format_disk(datadisk_dev);
2971            }
2972            sprintf(tmp, "%s/mindi-mfsroot.1440.img", imagesdir);
2973            write_image_to_floppy(datadisk_dev, tmp);
2974        }
2975#else
2976        sprintf(bootdisk_file, "%s/mindi-bootroot.1722.img", imagesdir);
2977        if (does_file_exist(bootdisk_file)) {
2978            if (format_first) {
2979                format_disk(bootdisk_dev);
2980            }
2981            res += write_image_to_floppy(bootdisk_dev, bootdisk_file);
2982        } else {
2983            sprintf(bootdisk_file, "%s/mindi-boot.1440.img", imagesdir);
2984            sprintf(rootdisk_file, "%s/mindi-root.1440.img", imagesdir);
2985            root_disk_exists = TRUE;
2986            if (!does_file_exist(rootdisk_file)
2987                || !does_file_exist(bootdisk_file)) {
2988                popup_and_OK
2989                    ("Cannot write boot/root floppies. Files not found.");
2990                log_to_screen
2991                    ("Failed to find boot/root floppy images. Oh dear.");
2992                return (1);
2993            }
2994            if (format_first) {
2995                format_disk(datadisk_dev);
2996            }
2997            /*
2998               sprintf(tmp, "cat %s > %s", bootdisk_file, datadisk_dev);
2999               res += run_external_binary_with_percentage_indicator_NEW("Writing boot floppy", tmp);
3000             */
3001            res += write_image_to_floppy(datadisk_dev, bootdisk_file);
3002            if (ask_me_OK_or_cancel("About to write root disk")) {
3003                log_to_screen("Writing root floppy");
3004                if (format_first) {
3005                    format_disk(datadisk_dev);
3006                }
3007                sprintf(tmp, "cat %s > %s", rootdisk_file, datadisk_dev);
3008                log_msg(1, "tmp = '%s'", tmp);
3009                res +=
3010                    run_external_binary_with_percentage_indicator_NEW
3011                    ("Writing root floppy", tmp);
3012//              res += write_image_to_floppy (datadisk_dev, rootdisk_file);
3013            }
3014        }
3015#endif
3016    }
3017    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
3018        log_to_screen
3019            ("FYI, the data disks are stored on tape/CD for your convenience.");
3020        return (0);
3021    }
3022    for (i = 1; i < 99; i++) {
3023        sprintf(tmp, "%s/mindi-data-%d.img", imagesdir, i);
3024        log_msg(3, tmp);
3025        if (!does_file_exist(tmp)) {
3026            log_msg(3, "...not found");
3027            break;
3028        }
3029        sprintf(comment, "About to write data disk #%d", i);
3030        if (ask_me_OK_or_cancel(comment)) {
3031            sprintf(comment, "Writing data disk #%3d", i);
3032            log_to_screen(comment);
3033            if (format_first) {
3034                res += format_disk(datadisk_dev);
3035            }
3036            res += write_image_to_floppy(datadisk_dev, tmp);
3037        }
3038    }
3039    paranoid_free(tmp);
3040    paranoid_free(comment);
3041    paranoid_free(bootdisk_dev);
3042    paranoid_free(datadisk_dev);
3043    return (res);
3044}
3045
3046
3047
3048
3049
3050
3051
3052
3053/**
3054 * Wrapper around @c offer_to_write_floppies().
3055 * @param bkpinfo The backup information structure. Used only
3056 * in the call to @c offer_to_write_floppies().
3057 * @return 0 if the boot floppies were found (not necessarily written OK),
3058 * 1 otherwise.
3059 * @see offer_to_write_floppies
3060 * @ingroup MLarchiveGroup
3061 */
3062
3063int offer_to_write_boot_floppies_to_physical_disks()
3064{
3065    int res = 0;
3066
3067    assert(bkpinfo != NULL);
3068
3069    mvaddstr_and_log_it(g_currentY, 0,
3070                        "Writing boot+data floppy images to disk");
3071
3072    if (!bkpinfo->nonbootable_backup) {
3073#ifdef __FreeBSD__
3074        if (!does_file_exist(MINDI_CACHE"/mindi-kern.1722.img"))
3075#else
3076        if (!does_file_exist(MINDI_CACHE"/mindi-bootroot.1722.img") && !does_file_exist(MINDI_CACHE"/mindi-boot.1440.img"))
3077#endif
3078        {
3079            mvaddstr_and_log_it(g_currentY++, 74, "No Imgs");
3080            if (does_file_exist(MINDI_CACHE"/mondorescue.iso")) {
3081                popup_and_OK
3082                    ("No regular Boot+data floppies were created due of space constraints. However, you can burn "MINDI_CACHE"/mondorescue.iso to a CD and boot from that.");
3083                res++;
3084            }
3085        } else {
3086            offer_to_write_floppies(MINDI_CACHE);
3087            mvaddstr_and_log_it(g_currentY++, 74, "Done.");
3088        }
3089    } else {
3090        popup_and_OK
3091            ("Since you opted for a nonbootable backup, no boot floppies were created.");
3092    }
3093
3094    return (res);
3095}
3096
3097
3098
3099
3100/**
3101 * @addtogroup LLarchiveGroup
3102 * @{
3103 */
3104/**
3105 * Function pointer to an appropriate @c move_files_to_stream routine.
3106 * You can set this to your own function (for example, one to
3107 * transfer files over the network) or leave it as is.
3108 */
3109int (*move_files_to_stream) (char *, ...) =
3110    _move_files_to_stream;
3111
3112/**
3113 * Copy some files to tape.
3114 * This function copies the files specified as parameters into the tape stream.
3115 *
3116 * @param bkpinfo The backup information structure. Used only in the call to
3117 * @c write_file_to_stream_from_file().
3118 *
3119 * @param files_to_add The files to copy to the tape stream.
3120 * @warning The list of @c files_to_add must be terminated with @c NULL.
3121 * @note Files may be split across multiple tapes if necessary.
3122 *
3123 * @return The number of errors encountered (0 for success)
3124 */
3125int
3126_move_files_to_stream(char *files_to_add, ...)
3127{
3128
3129    /*@ int ************************************************************ */
3130    int retval = 0;
3131    int res = 0;
3132    /*@ buffers ******************************************************** */
3133
3134    /*@ char *********************************************************** */
3135    char start_chr;
3136    char stop_chr;
3137    char *curr_file, *cf;
3138    /*@ long long ****************************************************** */
3139    off_t length_of_incoming_file = (off_t)0;
3140    t_archtype type;
3141    va_list ap;
3142
3143    assert(bkpinfo != NULL);
3144    malloc_string(curr_file);
3145    va_start(ap, files_to_add);
3146    for (cf = files_to_add; cf != NULL; cf = va_arg(ap, char *)) {
3147        if (!cf) {
3148            continue;
3149        }
3150        strcpy(curr_file, cf);
3151        if (!does_file_exist(curr_file)) {
3152            log_msg(1,
3153                    "Warning - you're trying to add a non-existent file - '%s' to the tape",
3154                    curr_file);
3155        }
3156/* create header chars */
3157        start_chr = BLK_START_AN_AFIO_OR_SLICE;
3158        stop_chr = BLK_STOP_AN_AFIO_OR_SLICE;
3159/* ask for new tape if necessary */
3160        length_of_incoming_file = length_of_file(curr_file);
3161        write_header_block_to_stream(length_of_incoming_file, curr_file,
3162                                     start_chr);
3163        if (strstr(curr_file, ".afio.") || strstr(curr_file, ".star.")) {
3164            type = fileset;
3165        } else if (strstr(curr_file, "slice")) {
3166            type = biggieslice;
3167        } else {
3168            type = other;
3169        }
3170        res = write_file_to_stream_from_file(curr_file);
3171        retval += res;
3172        unlink(curr_file);
3173/* write closing header */
3174        write_header_block_to_stream((off_t)0, "finished-writing-file", stop_chr);
3175    }
3176    va_end(ap);
3177
3178    if (retval) {
3179        log_msg(1,
3180                "Warning - errors occurred while I was adding file to tape");
3181    }
3182    paranoid_free(curr_file);
3183    return (retval);
3184}
3185
3186/* @} - end of LLarchiveGroup */
3187
3188
3189
3190/**
3191 * @addtogroup utilityGroup
3192 * @{
3193 */
3194/**
3195 * Make sure the user has a valid CD-R(W) in the CD drive.
3196 * @param cdrw_dev Set to the CD-R(W) device checked.
3197 * @param keep_looping If TRUE, keep pestering user until they insist
3198 * or insert a correct CD; if FALSE, only check once.
3199 * @return 0 (there was an OK CD in the drive) or 1 (there wasn't).
3200 */
3201int interrogate_disk_currently_in_cdrw_drive(char *cdrw_dev,
3202                                             bool keep_looping)
3203{
3204    char *tmp;
3205    int res = 0;
3206    char *bkp;
3207    char *cdrecord;
3208
3209    malloc_string(tmp);
3210    malloc_string(bkp);
3211    malloc_string(cdrecord);
3212    strcpy(bkp, cdrw_dev);
3213    if (find_cdrw_device(cdrw_dev)) {
3214        strcpy(cdrw_dev, bkp);
3215    } else {
3216        if (!system("which cdrecord > /dev/null 2> /dev/null")) {
3217            sprintf(cdrecord, "cdrecord dev=%s -atip", cdrw_dev);
3218        } else if (!system("which dvdrecord > /dev/null 2> /dev/null")) {
3219            sprintf(cdrecord, "cdrecord dev=%s -atip", cdrw_dev);
3220        } else {
3221            cdrecord[0] = '\0';
3222            log_msg(2, "Oh well. I guess I'll just pray then.");
3223        }
3224        if (cdrecord[0]) {
3225            if (!keep_looping) {
3226                retract_CD_tray_and_defeat_autorun();
3227                res = run_program_and_log_output(cdrecord, 5);
3228            } else {
3229                while ((res = run_program_and_log_output(cdrecord, 5))) {
3230                    retract_CD_tray_and_defeat_autorun();
3231                    if (ask_me_yes_or_no
3232                        ("Unable to examine CD. Are you sure this is a valid CD-R(W) CD?"))
3233                    {
3234                        log_msg(1, "Well, he insisted...");
3235                        break;
3236                    }
3237                }
3238            }
3239        }
3240    }
3241//  retract_CD_tray_and_defeat_autorun();
3242    paranoid_free(tmp);
3243    paranoid_free(cdrecord);
3244    paranoid_free(bkp);
3245    return (res);
3246}
3247
3248
3249
3250
3251
3252
3253
3254
3255
3256/**
3257 * Asks the user to put a CD-R(W) in the drive.
3258 * @param ask_for_one_if_more_than_this (unused)
3259 * @param pmountable If non-NULL, pointed-to value is set to TRUE if the CD is mountable, FALSE otherwise.
3260 */
3261void
3262pause_and_ask_for_cdr(int ask_for_one_if_more_than_this, bool * pmountable)
3263{
3264
3265    /*@ buffers ********************************************* */
3266    char *tmp;
3267    char *szmsg;
3268    char *cdrom_dev;
3269    char *cdrw_dev;
3270    char *our_serial_str;
3271    bool ok_go_ahead_burn_it;
3272    int cd_number = -1;
3273    int attempt_to_mount_returned_this = 999;
3274    char *mtpt;
3275    char *szcdno;
3276    char *szserfname;
3277    char *szunmount;
3278
3279    malloc_string(tmp);
3280    malloc_string(szmsg);
3281    malloc_string(cdrom_dev);
3282    malloc_string(cdrw_dev);
3283    malloc_string(mtpt);
3284    malloc_string(szcdno);
3285    malloc_string(szserfname);
3286    malloc_string(our_serial_str);
3287    malloc_string(szunmount);
3288
3289    sprintf(szmsg, "I am about to burn %s #%d",
3290            media_descriptor_string(g_backup_media_type),
3291            g_current_media_number);
3292    log_to_screen(szmsg);
3293    if (g_current_media_number < ask_for_one_if_more_than_this) {
3294        return;
3295    }
3296    log_to_screen("Scanning CD-ROM drive...");
3297    sprintf(mtpt, "%s/cd.mtpt", bkpinfo->tmpdir);
3298    make_hole_for_dir(mtpt);
3299
3300  gotos_make_me_puke:
3301    ok_go_ahead_burn_it = TRUE;
3302    if (!find_cdrom_device(cdrom_dev, FALSE)) {
3303/* When enabled, it made CD eject-and-retract when wrong CD inserted.. Weird
3304      log_msg(2, "paafcd: Retracting CD-ROM drive if possible" );
3305      retract_CD_tray_and_defeat_autorun();
3306*/
3307        sprintf(tmp, "umount %s", cdrom_dev);
3308        run_program_and_log_output(tmp, 1);
3309        sprintf(szcdno, "%s/archives/THIS-CD-NUMBER", mtpt);
3310        sprintf(szserfname, "%s/archives/SERIAL-STRING", mtpt);
3311        sprintf(szunmount, "umount %s", mtpt);
3312        cd_number = -1;
3313        our_serial_str[0] = '\0';
3314        sprintf(tmp, "mount %s %s", cdrom_dev, mtpt);
3315        if ((attempt_to_mount_returned_this =
3316             run_program_and_log_output(tmp, 1))) {
3317            log_msg(4, "Failed to mount %s at %s", cdrom_dev, mtpt);
3318            log_to_screen("If there's a CD/DVD in the drive, it's blank.");
3319            /*
3320               if (interrogate_disk_currently_in_cdrw_drive(cdrw_dev, FALSE))
3321               {
3322               ok_go_ahead_burn_it = FALSE;
3323               log_to_screen("There isn't a writable CD/DVD in the drive.");
3324               }
3325               else
3326               {
3327               log_to_screen("Confirmed. There is a blank CD/DVD in the drive.");
3328               }
3329             */
3330        } else if (!does_file_exist(szcdno)
3331                   || !does_file_exist(szserfname)) {
3332            log_to_screen
3333                ("%s has data on it but it's probably not a Mondo CD.",
3334                 media_descriptor_string(g_backup_media_type));
3335        } else {
3336            log_to_screen("%s found in drive. It's a Mondo disk.",
3337                          media_descriptor_string(g_backup_media_type));
3338            cd_number = atoi(last_line_of_file(szcdno));
3339            sprintf(tmp, "cat %s 2> /dev/null", szserfname);
3340            strcpy(our_serial_str,
3341                   call_program_and_get_last_line_of_output(tmp));
3342            // FIXME - should be able to use last_line_of_file(), surely?
3343        }
3344        run_program_and_log_output(szunmount, 1);
3345        log_msg(2, "paafcd: cd_number = %d", cd_number);
3346        log_msg(2, "our serial str = %s; g_serial_string = %s",
3347                our_serial_str, g_serial_string);
3348        if (cd_number > 0 && !strcmp(our_serial_str, g_serial_string)) {
3349            log_msg(2, "This %s is part of this backup set!",
3350                    media_descriptor_string(g_backup_media_type));
3351            ok_go_ahead_burn_it = FALSE;
3352            if (cd_number == g_current_media_number - 1) {
3353                log_to_screen
3354                    ("I think you've left the previous %s in the drive.",
3355                     media_descriptor_string(g_backup_media_type));
3356            } else {
3357                log_to_screen
3358                    ("Please remove this %s. It is part of the backup set you're making now.",
3359                     media_descriptor_string(g_backup_media_type));
3360            }
3361        } else {
3362            log_to_screen("...but not part of _our_ backup set.");
3363        }
3364    } else {
3365        log_msg(2,
3366                "paafcd: Can't find CD-ROM drive. Perhaps it has a blank %s in it?",
3367                media_descriptor_string(g_backup_media_type));
3368        if (interrogate_disk_currently_in_cdrw_drive(cdrw_dev, FALSE)) {
3369            ok_go_ahead_burn_it = FALSE;
3370            log_to_screen("There isn't a writable %s in the drive.",
3371                          media_descriptor_string(g_backup_media_type));
3372        }
3373    }
3374
3375/*
3376  if (g_current_media_number > ask_for_one_if_more_than_this)
3377    {
3378      ok_go_ahead_burn_it = FALSE;
3379      log_it("paafcd: %d > %d, so I'll definitely pause.", g_current_media_number > ask_for_one_if_more_than_this);
3380    }
3381*/
3382
3383    if (!ok_go_ahead_burn_it) {
3384        eject_device(cdrom_dev);
3385        sprintf(tmp,
3386                "I am about to burn %s #%d of the backup set. Please insert %s and press Enter.",
3387                media_descriptor_string(g_backup_media_type),
3388                g_current_media_number,
3389                media_descriptor_string(g_backup_media_type));
3390        popup_and_OK(tmp);
3391        goto gotos_make_me_puke;
3392    } else {
3393        log_msg(2, "paafcd: OK, going ahead and burning it.");
3394    }
3395
3396    log_msg(2,
3397            "paafcd: OK, I assume I have a blank/reusable %s in the drive...",
3398            media_descriptor_string(g_backup_media_type));
3399
3400    //  if (ask_for_one_if_more_than_this>1) { popup_and_OK(szmsg); }
3401
3402    log_to_screen("Proceeding w/ %s in drive.",
3403                  media_descriptor_string(g_backup_media_type));
3404    paranoid_free(tmp);
3405    paranoid_free(szmsg);
3406    paranoid_free(cdrom_dev);
3407    paranoid_free(cdrw_dev);
3408    paranoid_free(mtpt);
3409    paranoid_free(szcdno);
3410    paranoid_free(szserfname);
3411    paranoid_free(our_serial_str);
3412    paranoid_free(szunmount);
3413    if (pmountable) {
3414        if (attempt_to_mount_returned_this) {
3415            *pmountable = FALSE;
3416        } else {
3417            *pmountable = TRUE;
3418        }
3419    }
3420
3421}
3422
3423
3424
3425
3426
3427
3428
3429
3430/**
3431 * Set the <tt>N</tt>th bit of @c array to @c true_or_false.
3432 * @param array The bit array (as a @c char pointer).
3433 * @param N The bit number to set or reset.
3434 * @param true_or_false If TRUE then set bit @c N, if FALSE then reset bit @c N.
3435 * @see get_bit_N_of_array
3436 */
3437void set_bit_N_of_array(char *array, int N, bool true_or_false)
3438{
3439    int bit_number;
3440    int mask, orig_val, to_add;
3441    int element_number;
3442
3443    assert(array != NULL);
3444
3445    element_number = N / 8;
3446    bit_number = N % 8;
3447    to_add = (1 << bit_number);
3448    mask = 255 - to_add;
3449    orig_val = array[element_number] & mask;
3450    //  log_it("array[%d]=%02x; %02x&%02x = %02x", element_number, array[element_number], mask, orig_val);
3451    if (true_or_false) {
3452        array[element_number] = orig_val | to_add;
3453    }
3454}
3455
3456/* @} - end of utilityGroup */
3457
3458
3459
3460
3461
3462
3463
3464
3465/**
3466 * Chop up @c filename.
3467 * @param bkpinfo The backup information structure. Fields used:
3468 * - @c backup_media_type
3469 * - @c compression_level
3470 * - @c optimal_set_size
3471 * - @c tmpdir
3472 * - @c use_lzo
3473 * - @c zip_exe
3474 * - @c zip_suffix
3475 *
3476 * @param biggie_filename The file to chop up.
3477 * @param ntfsprog_fifo The FIFO to ntfsclone if this is an imagedev, NULL otherwise.
3478 * @param biggie_file_number The sequence number of this biggie file (starting from 0).
3479 * @param noof_biggie_files The number of biggie files there are total.
3480 * @return The number of errors encountered (0 for success)
3481 * @see make_slices_and_images
3482 * @ingroup LLarchiveGroup
3483 */
3484int
3485slice_up_file_etc(char *biggie_filename,
3486                  char *ntfsprog_fifo, long biggie_file_number,
3487                  long noof_biggie_files, bool use_ntfsprog)
3488{
3489
3490    /*@ buffers ************************************************** */
3491    char *tmp, *checksum_line, *command;
3492    char *tempblock;
3493    char *curr_slice_fname_uncompressed;
3494    char *curr_slice_fname_compressed;
3495    char *file_to_archive;
3496    char *file_to_openin;
3497    /*@ pointers ************************************************** */
3498    char *pB;
3499    FILE *fin = NULL, *fout = NULL;
3500
3501    /*@ bool ****************************************************** */
3502    bool finished = FALSE;
3503
3504    /*@ long ****************************************************** */
3505    size_t blksize = 0;
3506    long slice_num = 0;
3507    long i;
3508    long optimal_set_size;
3509    bool should_I_compress_slices;
3510    char *suffix;               // for compressed slices
3511
3512    /*@ long long ************************************************** */
3513    off_t totalread = (off_t)0;
3514    off_t totallength = (off_t)0;
3515    off_t length;
3516
3517    /*@ int ******************************************************** */
3518    int retval = 0;
3519    int res = 0;
3520
3521    /*@ structures ************************************************** */
3522    struct s_filename_and_lstat_info biggiestruct;
3523//  struct stat statbuf;
3524
3525    assert(bkpinfo != NULL);
3526    assert_string_is_neither_NULL_nor_zerolength(biggie_filename);
3527    malloc_string(tmp);
3528    malloc_string(checksum_line);
3529    malloc_string(curr_slice_fname_uncompressed);
3530    malloc_string(curr_slice_fname_compressed);
3531    malloc_string(file_to_archive);
3532    malloc_string(suffix);
3533    command = malloc(MAX_STR_LEN * 8);
3534
3535    biggiestruct.for_backward_compatibility = '\n';
3536    biggiestruct.use_ntfsprog = use_ntfsprog;
3537    if (!(tempblock = (char *) malloc(256 * 1024))) {
3538        fatal_error("malloc error 256*1024");
3539    }
3540    optimal_set_size = bkpinfo->optimal_set_size;
3541    if (is_this_file_compressed(biggie_filename)
3542        || bkpinfo->compression_level == 0) {
3543        suffix[0] = '\0';
3544        //      log_it("%s is indeed compressed :-)", filename);
3545        should_I_compress_slices = FALSE;
3546    } else {
3547        strcpy(suffix, bkpinfo->zip_suffix);
3548        should_I_compress_slices = TRUE;
3549    }
3550
3551    if (optimal_set_size < 999) {
3552        fatal_error("bkpinfo->optimal_set_size is insanely small");
3553    }
3554    if (ntfsprog_fifo) {
3555        file_to_openin = ntfsprog_fifo;
3556        strcpy(checksum_line, "IGNORE");
3557        log_msg(2,
3558                "Not calculating checksum for %s: it would take too long",
3559                biggie_filename);
3560        if ( !find_home_of_exe("ntfsresize")) {
3561            fatal_error("ntfsresize not found");
3562        }
3563        sprintf(command, "ntfsresize --force --info %s|grep '^You might resize at '|cut -d' ' -f5", biggie_filename);
3564        log_it("command = %s", command);
3565        strcpy (tmp, call_program_and_get_last_line_of_output(command));
3566        log_it("res of it = %s", tmp); 
3567        totallength = (off_t)atoll(tmp);
3568    } else {
3569        file_to_openin = biggie_filename;
3570        if (strchr(biggie_filename,'\'') != NULL) {
3571            sprintf(command, "md5sum \"%s\"", biggie_filename);
3572        } else {
3573            sprintf(command, "md5sum '%s'", biggie_filename);
3574        }
3575        if (!(fin = popen(command, "r"))) {
3576            log_OS_error("Unable to popen-in command");
3577            return (1);
3578        }
3579        (void) fgets(checksum_line, MAX_STR_LEN, fin);
3580        pclose(fin);
3581        totallength = length_of_file (biggie_filename);
3582    }
3583    lstat(biggie_filename, &biggiestruct.properties);
3584    strcpy(biggiestruct.filename, biggie_filename);
3585    pB = strchr(checksum_line, ' ');
3586    if (!pB) {
3587        pB = strchr(checksum_line, '\t');
3588    }
3589    if (pB) {
3590        *pB = '\0';
3591    }
3592    strcpy(biggiestruct.checksum, checksum_line);
3593
3594    strcpy(tmp, slice_fname(biggie_file_number, 0, bkpinfo->tmpdir, ""));
3595    fout = fopen(tmp, "w");
3596    if (fout == NULL) {
3597        log_msg(1, "Unable to open and write to %s\n", tmp);
3598        paranoid_free(tmp);
3599        paranoid_free(suffix);
3600        return (1);
3601    }
3602
3603    (void) fwrite((void *) &biggiestruct, 1, sizeof(biggiestruct), fout);
3604    paranoid_fclose(fout);
3605    length = totallength / optimal_set_size / 1024;
3606    log_msg(1, "Opening in %s; slicing it and writing to CD/tape",
3607            file_to_openin);
3608    if (!(fin = fopen(file_to_openin, "r"))) {
3609        log_OS_error("Unable to openin biggie_filename");
3610        sprintf(tmp, "Cannot archive bigfile '%s': not found",
3611                biggie_filename);
3612        log_to_screen(tmp);
3613        paranoid_free(tempblock);
3614        paranoid_free(tmp);
3615        paranoid_free(checksum_line);
3616        paranoid_free(command);
3617        return (1);
3618    }
3619    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
3620        res =
3621            move_files_to_stream(slice_fname(biggie_file_number, 0,
3622                                             bkpinfo->tmpdir, ""), NULL);
3623    } else {
3624        res =
3625            move_files_to_cd(slice_fname(biggie_file_number, 0,
3626                                         bkpinfo->tmpdir, ""), NULL);
3627    }
3628    i = bkpinfo->optimal_set_size / 256;
3629    for (slice_num = 1; !finished; slice_num++) {
3630        strcpy(curr_slice_fname_uncompressed,
3631               slice_fname(biggie_file_number, slice_num, bkpinfo->tmpdir,
3632                           ""));
3633        strcpy(curr_slice_fname_compressed,
3634               slice_fname(biggie_file_number, slice_num, bkpinfo->tmpdir,
3635                           suffix));
3636
3637        strcpy(tmp, percent_media_full_comment());
3638        update_progress_form(tmp);
3639        if (!(fout = fopen(curr_slice_fname_uncompressed, "w"))) {
3640            log_OS_error(curr_slice_fname_uncompressed);
3641            return (1);
3642        }
3643        if ((i == bkpinfo->optimal_set_size / 256)
3644            && (totalread < 1.1 * totallength)) {
3645            for (i = 0; i < bkpinfo->optimal_set_size / 256; i++) {
3646                blksize = fread(tempblock, 1, 256 * 1024, fin);
3647                if (blksize > 0) {
3648                    totalread = totalread + blksize;
3649                    (void) fwrite(tempblock, 1, blksize, fout);
3650                } else {
3651                    break;
3652                }
3653            }
3654        } else {
3655            i = 0;
3656        }
3657        paranoid_fclose(fout);
3658        if (i > 0)              // length_of_file (curr_slice_fname_uncompressed)
3659        {
3660            if (!does_file_exist(curr_slice_fname_uncompressed)) {
3661                log_msg(2,
3662                        "Warning - '%s' doesn't exist. How can I compress slice?",
3663                        curr_slice_fname_uncompressed);
3664            }
3665            if (should_I_compress_slices && bkpinfo->compression_level > 0) {
3666                sprintf(command, "%s -%d %s", bkpinfo->zip_exe,
3667                        bkpinfo->compression_level,
3668                        curr_slice_fname_uncompressed);
3669                log_msg(2, command);
3670                if ((res = system(command))) {
3671                    log_OS_error(command);
3672                }
3673                //          did_I_compress_slice = TRUE;
3674            } else {
3675                sprintf(command, "mv %s %s 2>> %s",
3676                        curr_slice_fname_uncompressed,
3677                        curr_slice_fname_compressed, MONDO_LOGFILE);
3678                res = 0;        // don't do it :)
3679                //          did_I_compress_slice = FALSE;
3680            }
3681            retval += res;
3682            if (res) {
3683                log_msg(2, "Failed to compress the slice");
3684            }
3685            if (bkpinfo->use_lzo
3686                && strcmp(curr_slice_fname_compressed,
3687                          curr_slice_fname_uncompressed)) {
3688                unlink(curr_slice_fname_uncompressed);
3689            }
3690            if (res) {
3691                sprintf(tmp, "Problem with slice # %ld", slice_num);
3692            } else {
3693                sprintf(tmp,
3694                        "%s - Bigfile #%ld, slice #%ld compressed OK          ",
3695                        biggie_filename, biggie_file_number + 1,
3696                        slice_num);
3697            }
3698#ifndef _XWIN
3699            if (!g_text_mode) {
3700                newtDrawRootText(0, g_noof_rows - 2, tmp);
3701                newtRefresh();
3702            } else {
3703                log_msg(2, tmp);
3704            }
3705#else
3706            log_msg(2, tmp);
3707#endif
3708            strcpy(file_to_archive, curr_slice_fname_compressed);
3709            g_current_progress++;
3710        } else {                /* if i==0 then ... */
3711
3712            finished = TRUE;
3713            strcpy(file_to_archive, curr_slice_fname_uncompressed);
3714            if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
3715                break;
3716            }
3717        }
3718
3719        if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
3720            register_in_tape_catalog(biggieslice, biggie_file_number,
3721                                     slice_num, file_to_archive);
3722            maintain_collection_of_recent_archives(bkpinfo->tmpdir,
3723                                                   file_to_archive);
3724            res = move_files_to_stream(file_to_archive, NULL);
3725        } else {
3726            res = move_files_to_cd(file_to_archive, NULL);
3727        }
3728        retval += res;
3729        if (res) {
3730            sprintf(tmp,
3731                    "Failed to add slice %ld of bigfile %ld to scratchdir",
3732                    slice_num, biggie_file_number + 1);
3733            log_to_screen(tmp);
3734            fatal_error
3735                ("Hard disk full. You should have bought a bigger one.");
3736        }
3737    }
3738    paranoid_fclose(fin);
3739    sprintf(tmp, "Sliced bigfile #%ld", biggie_file_number + 1);
3740    if (retval) {
3741        strcat(tmp, "...FAILED");
3742    } else {
3743        strcat(tmp, "...OK!");
3744    }
3745    log_msg(1, tmp);
3746    paranoid_free(tempblock);
3747    paranoid_free(tmp);
3748    paranoid_free(checksum_line);
3749    paranoid_free(command);
3750    paranoid_free(curr_slice_fname_uncompressed);
3751    paranoid_free(curr_slice_fname_compressed);
3752    paranoid_free(file_to_archive);
3753    paranoid_free(suffix);
3754    return (retval);
3755}
3756
3757
3758
3759
3760
3761
3762/**
3763 * Remove the archives in @c d.
3764 * This could possibly include any of:
3765 * - all afioballs (compressed and not)
3766 * - all filelists
3767 * - all slices
3768 * - all checksums
3769 * - a zero filler file
3770 *
3771 * @param d The directory to wipe the archives from.
3772 * @ingroup utilityGroup
3773 */
3774void wipe_archives(char *d)
3775{
3776    /*@ buffers ********************************************* */
3777    char *tmp;
3778    char *dir;
3779
3780    malloc_string(tmp);
3781    malloc_string(dir);
3782    assert_string_is_neither_NULL_nor_zerolength(d);
3783
3784    sprintf(dir, "%s/archives", d);
3785    sprintf(tmp, "find %s -name '*.afio*' -exec rm -f '{}' \\;", dir);
3786    run_program_and_log_output(tmp, FALSE);
3787    sprintf(tmp, "find %s -name '*list.[0-9]*' -exec rm -f '{}' \\;", dir);
3788    run_program_and_log_output(tmp, FALSE);
3789    sprintf(tmp, "find %s -name 'slice*' -exec rm -f '{}' \\;", dir);
3790    run_program_and_log_output(tmp, FALSE);
3791    sprintf(tmp, "rm -f %s/cklist*", dir);
3792    run_program_and_log_output(tmp, FALSE);
3793    sprintf(tmp, "rm -f %s/zero", dir);
3794    run_program_and_log_output(tmp, FALSE);
3795    log_msg(1, "Wiped %s's archives", dir);
3796    sprintf(tmp, "ls -l %s", dir);
3797    run_program_and_log_output(tmp, FALSE);
3798    paranoid_free(tmp);
3799    paranoid_free(dir);
3800}
3801
3802
3803
3804/**
3805 * @addtogroup LLarchiveGroup
3806 * @{
3807 */
3808/**
3809 * Write the final ISO image.
3810 * @param bkpinfo The backup information structure. Used only
3811 * in the call to @c write_iso_and_go_on().
3812 * @return The number of errors encountered (0 for success)
3813 * @see write_iso_and_go_on
3814 * @see make_iso_fs
3815 * @bug The final ISO is written even if there are no files on it. In practice,
3816 * however, this occurs rarely.
3817 */
3818int write_final_iso_if_necessary()
3819{
3820    /*@ int ***************************************************** */
3821    int res;
3822
3823    /*@ buffers ************************************************** */
3824    char *tmp;
3825
3826    malloc_string(tmp);
3827    assert(bkpinfo != NULL);
3828
3829// 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
3830
3831    sprintf(tmp, "Writing the final ISO");
3832    log_msg(2, tmp);
3833    center_string(tmp, 80);
3834#ifndef _XWIN
3835    if (!g_text_mode) {
3836        newtPushHelpLine(tmp);
3837    }
3838#endif
3839    res = write_iso_and_go_on(TRUE);
3840#ifndef _XWIN
3841    if (!g_text_mode) {
3842        newtPopHelpLine();
3843    }
3844#endif
3845    log_msg(2, "Returning from writing final ISO (res=%d)", res);
3846    paranoid_free(tmp);
3847    return (res);
3848}
3849
3850
3851/**
3852 * Write an ISO image to <tt>[bkpinfo->isodir]/bkpinfo->prefix-[g_current_media_number].iso</tt>.
3853 * @param bkpinfo The backup information structure. Fields used:
3854 * - @c backup_media_type
3855 * - @c prefix
3856 * - @c isodir
3857 * - @c manual_cd_tray
3858 * - @c media_size
3859 * - @c nfs_mount
3860 * - @c nfs_remote_dir
3861 * - @c scratchdir
3862 * - @c verify_data
3863 *
3864 * @param last_cd If TRUE, this is the last CD to write; if FALSE, it's not.
3865 * @return The number of errors encountered (0 for success)
3866 * @see make_iso_fs
3867 */
3868int write_iso_and_go_on(bool last_cd)
3869{
3870    /*@ pointers **************************************************** */
3871    FILE *fout;
3872
3873    /*@ buffers ***************************************************** */
3874    char *tmp;
3875    char *cdno_fname;
3876    char *lastcd_fname;
3877    char *isofile;
3878
3879    /*@ bool ******************************************************** */
3880    bool that_one_was_ok;
3881    bool using_nfs;
3882    bool orig_vfy_flag_val;
3883
3884    /*@ int *********************************************************** */
3885    int res = 0;
3886
3887    malloc_string(tmp);
3888    malloc_string(cdno_fname);
3889    malloc_string(lastcd_fname);
3890    malloc_string(isofile);
3891
3892    assert(bkpinfo != NULL);
3893    orig_vfy_flag_val = bkpinfo->verify_data;
3894    if (bkpinfo->media_size[g_current_media_number] <= 0) {
3895        fatal_error("write_iso_and_go_on() - unknown media size");
3896    }
3897
3898    if (strlen(bkpinfo->nfs_mount) > 1) {
3899        using_nfs = TRUE;
3900    } else {
3901        using_nfs = FALSE;
3902    }
3903    log_msg(1, "OK, time to make %s #%d",
3904            media_descriptor_string(bkpinfo->backup_media_type),
3905            g_current_media_number);
3906
3907    /* label the ISO with its number */
3908
3909    sprintf(cdno_fname, "%s/archives/THIS-CD-NUMBER", bkpinfo->scratchdir);
3910    fout = fopen(cdno_fname, "w");
3911    fprintf(fout, "%d", g_current_media_number);
3912    paranoid_fclose(fout);
3913
3914    sprintf(tmp, "cp -f %s/autorun %s/", g_mondo_home,
3915            bkpinfo->scratchdir);
3916    if (run_program_and_log_output(tmp, FALSE)) {
3917        log_msg(2, "Warning - unable to copy autorun to scratchdir");
3918    }
3919
3920    /* last CD or not? Label accordingly */
3921    sprintf(lastcd_fname, "%s/archives/NOT-THE-LAST", bkpinfo->scratchdir);
3922    if (last_cd) {
3923        unlink(lastcd_fname);
3924        log_msg(2,
3925                "OK, you're telling me this is the last CD. Fair enough.");
3926    } else {
3927        fout = fopen(lastcd_fname, "w");
3928        fprintf(fout,
3929                "You're listening to 90.3 WPLN, Nashville Public Radio.\n");
3930        paranoid_fclose(fout);
3931    }
3932    if (space_occupied_by_cd(bkpinfo->scratchdir) / 1024 >
3933        bkpinfo->media_size[g_current_media_number]) {
3934        sprintf(tmp,
3935                "Warning! CD is too big. It occupies %ld KB, which is more than the %ld KB allowed.",
3936                (long) space_occupied_by_cd(bkpinfo->scratchdir),
3937                (long) bkpinfo->media_size[g_current_media_number]);
3938        log_to_screen(tmp);
3939    }
3940    sprintf(isofile, "%s/%s/%s-%d.iso", bkpinfo->isodir,
3941            bkpinfo->nfs_remote_dir, bkpinfo->prefix,
3942            g_current_media_number);
3943    for (that_one_was_ok = FALSE; !that_one_was_ok;) {
3944        if (bkpinfo->backup_media_type != usb) {
3945            res = make_iso_fs(isofile);
3946        } else {
3947            res = make_usb_fs();
3948        }
3949        if (g_current_media_number == 1 && !res
3950            && (bkpinfo->backup_media_type == cdr
3951                || bkpinfo->backup_media_type == cdrw)) {
3952            if (find_cdrom_device(tmp, FALSE))  // make sure find_cdrom_device() finds, records CD-R's loc
3953            {
3954                log_msg(3, "*Sigh* Mike, I hate your computer.");
3955                bkpinfo->manual_cd_tray = TRUE;
3956            }                   // if it can't be found then force pausing
3957            else {
3958                log_msg(3, "Great. Found Mike's CD-ROM drive.");
3959            }
3960        }
3961        if (bkpinfo->verify_data && !res) {
3962            log_to_screen
3963                ("Please reboot from the 1st %s in Compare Mode, as a precaution.",
3964                 media_descriptor_string(g_backup_media_type));
3965            chdir("/");
3966            iamhere("Before calling verify_cd_image()");
3967            res += verify_cd_image();
3968            iamhere("After calling verify_cd_image()");
3969        }
3970        if (!res) {
3971            that_one_was_ok = TRUE;
3972        } else {
3973            sprintf(tmp, "Failed to burn %s #%d. Retry?",
3974                    media_descriptor_string(bkpinfo->backup_media_type),
3975                    g_current_media_number);
3976            res = ask_me_yes_or_no(tmp);
3977            if (!res) {
3978                if (ask_me_yes_or_no("Abort the backup?")) {
3979                    fatal_error("FAILED TO BACKUP");
3980                } else {
3981                    break;
3982                }
3983            } else {
3984                log_msg(2, "Retrying, at user's request...");
3985                res = 0;
3986            }
3987        }
3988    }
3989/*
3990  if (using_nfs)
3991    {
3992      sprintf(tmp,"mv -f %s %s/%s/", isofile, bkpinfo->isodir, bkpinfo->nfs_remote_dir);
3993      if (run_program_and_log_output(tmp, FALSE))
3994        { log_to_screen("Unable to move ISO to NFS dir"); }
3995    }
3996*/
3997    g_current_media_number++;
3998    if (g_current_media_number > MAX_NOOF_MEDIA) {
3999        fatal_error("Too many CD-R(W)'s. Use tape or net.");
4000    }
4001    wipe_archives(bkpinfo->scratchdir);
4002    sprintf(tmp, "rm -Rf %s/images/*gz %s/images/*data*img",
4003            bkpinfo->scratchdir, bkpinfo->scratchdir);
4004    if (system(tmp)) {
4005        log_msg
4006            (2,
4007             "Error occurred when I tried to delete the redundant IMGs and GZs");
4008    }
4009
4010    if (last_cd) {
4011        log_msg(2, "This was your last CD.");
4012    } else {
4013        log_msg(2, "Continuing to backup your data...");
4014    }
4015
4016    bkpinfo->verify_data = orig_vfy_flag_val;
4017    paranoid_free(tmp);
4018    paranoid_free(cdno_fname);
4019    paranoid_free(lastcd_fname);
4020    paranoid_free(isofile);
4021    return (0);
4022}
4023
4024/* @} - end of LLarchiveGroup */
4025
4026
4027
4028
4029/**
4030 * Verify the user's data.
4031 * @param bkpinfo The backup information structure. Fields used:
4032 * - @c backup_data
4033 * - @c backup_media_type
4034 * - @c media_device
4035 * - @c verify_data
4036 *
4037 * @return The number of errors encountered (0 for success)
4038 * @ingroup verifyGroup
4039 */
4040int verify_data()
4041{
4042    int res = 0, retval = 0, cdno = 0;
4043    char *tmp;
4044    long diffs = 0;
4045
4046    malloc_string(tmp);
4047    assert(bkpinfo != NULL);
4048    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
4049        chdir("/");
4050        mvaddstr_and_log_it(g_currentY, 0,
4051                            "Verifying archives against live filesystem");
4052        if (bkpinfo->backup_media_type == cdstream) {
4053            strcpy(bkpinfo->media_device, "/dev/cdrom");
4054        }
4055        verify_tape_backups();
4056        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
4057    } else if (bkpinfo->backup_data)
4058        //bkpinfo->backup_media_type == cdrw || bkpinfo->backup_media_type == cdr))
4059    {
4060        log_msg(2,
4061                "Not verifying again. Per-CD/ISO verification already carried out.");
4062        sprintf(tmp, "cat %s/changed.files > %s/changed.files 2> /dev/null",bkpinfo->tmpdir, MINDI_CACHE);
4063        paranoid_system(tmp);
4064    } else {
4065        g_current_media_number = cdno;
4066        if (bkpinfo->backup_media_type != iso) {
4067            find_cdrom_device(bkpinfo->media_device, FALSE);    // replace 0,0,0 with /dev/cdrom
4068        }
4069        chdir("/");
4070        for (cdno = 1; cdno < 99 && bkpinfo->verify_data; cdno++) {
4071            if (cdno != g_current_media_number) {
4072                log_msg(2,
4073                        "Warning - had to change g_current_media_number from %d to %d",
4074                        g_current_media_number, cdno);
4075                g_current_media_number = cdno;
4076            }
4077            if (bkpinfo->backup_media_type != iso) {
4078                insist_on_this_cd_number(cdno);
4079            }
4080            res = verify_cd_image();    // sets verify_data to FALSE if it's time to stop verifying
4081            retval += res;
4082            if (res) {
4083                sprintf(tmp,
4084                        "Warnings/errors were reported while checking %s #%d",
4085                        media_descriptor_string(bkpinfo->backup_media_type),
4086                        g_current_media_number);
4087                log_to_screen(tmp);
4088
4089            }
4090        }
4091/*
4092      sprintf (tmp,
4093           "cat %s | grep \"afio: \" | cut -d'\"' -f2 | sort -u | awk '{print \"/\"$0;};' | tr -s '/' '/' | grep -vx \"/afio:.*\" > /tmp/changed.files",
4094           MONDO_LOGFILE);
4095      system (tmp);
4096*/
4097        sprintf(tmp,
4098                "grep 'afio: ' %s | sed 's/afio: //' | grep -vE '^/dev/.*$' >> %s/changed.files",
4099                MONDO_LOGFILE, MINDI_CACHE);
4100        system(tmp);
4101
4102        sprintf(tmp,
4103                "grep 'star: ' %s | sed 's/star: //' | grep -vE '^/dev/.*$' >> %s/changed.files",
4104                MONDO_LOGFILE, MINDI_CACHE);
4105        system(tmp);
4106        run_program_and_log_output("umount " MNT_CDROM, FALSE);
4107//    if (bkpinfo->backup_media_type != iso && !bkpinfo->please_dont_eject_when_restoring)
4108//{
4109        eject_device(bkpinfo->media_device);
4110//}
4111    }
4112    sprintf(tmp, "%s/changed.files", MINDI_CACHE);
4113    diffs = count_lines_in_file(tmp);
4114
4115    if (diffs > 0) {
4116        if (retval == 0) {
4117            retval = (int) (-diffs);
4118        }
4119    }
4120    paranoid_free(tmp);
4121    return (retval);
4122}
4123
4124
4125
4126
4127
4128/**
4129 * @addtogroup utilityGroup
4130 * @{
4131 */
4132/**
4133 * Write an image to a real 3.5" floppy disk.
4134 * @param device The device to write to (e.g. @c /dev/fd0)
4135 * @param datafile The image to write to @p device.
4136 * @return The number of errors encountered (0 for success)
4137 * @see write_image_to_floppy
4138 */
4139int write_image_to_floppy_SUB(char *device, char *datafile)
4140{
4141    /*@ int *************************************************************** */
4142    int res = 0;
4143    int percentage = 0;
4144    int blockno = 0;
4145    int maxblocks = 0;
4146
4147    /*@ buffers************************************************************ */
4148    char *tmp;
4149    char blk[1024];
4150    char *title;
4151
4152    /*@ pointers ********************************************************** */
4153    char *p;
4154    FILE *fout, *fin;
4155
4156
4157    malloc_string(tmp);
4158    malloc_string(title);
4159    /* pretty stuff */
4160    if (!(p = strrchr(datafile, '/'))) {
4161        p = datafile;
4162    } else {
4163        p++;
4164    }
4165    sprintf(title, "Writing %s to floppy", p);
4166    open_evalcall_form(title);
4167    /* functional stuff */
4168    for (p = device + strlen(device); p != device && isdigit(*(p - 1));
4169         p--);
4170    maxblocks = atoi(p);
4171    if (!maxblocks) {
4172        maxblocks = 1440;
4173    }
4174    sprintf(tmp, "maxblocks = %d; p=%s", maxblocks, p);
4175    log_msg(2, tmp);
4176    /* copy data from image to floppy */
4177    if (!(fin = fopen(datafile, "r"))) {
4178        log_OS_error("Cannot open img");
4179        return (1);
4180    }
4181    if (!(fout = fopen(device, "w"))) {
4182        log_OS_error("Cannot open fdd");
4183        return (1);
4184    }
4185    for (blockno = 0; blockno < maxblocks; blockno++) {
4186        percentage = blockno * 100 / maxblocks;
4187        if (fread(blk, 1, 1024, fin) != 1024) {
4188            if (feof(fin)) {
4189                log_msg(1,
4190                        "img read err - img ended prematurely - non-fatal error");
4191                sleep(3);
4192                return (res);
4193            }
4194            res++;
4195            log_to_screen("img read err");
4196        }
4197        if (fwrite(blk, 1, 1024, fout) != 1024) {
4198            res++;
4199            log_to_screen("fdd write err");
4200        }
4201        if (((blockno + 1) % 128) == 0) {
4202            paranoid_system("sync");    /* fflush doesn't work; dunno why */
4203            update_evalcall_form(percentage);
4204        }
4205    }
4206    paranoid_fclose(fin);
4207    paranoid_fclose(fout);
4208    paranoid_free(tmp);
4209    paranoid_free(title);
4210    close_evalcall_form();
4211    return (res);
4212}
4213
4214
4215
4216
4217
4218
4219
4220
4221
4222/**
4223 * Wrapper around @c write_image_to_floppy_SUB().
4224 * This function, unlike @c write_image_to_floppy_SUB(),
4225 * gives the user the opportunity to retry if the write fails.
4226 * @see write_image_to_floppy_SUB
4227 */
4228int write_image_to_floppy(char *device, char *datafile)
4229{
4230    /*@ int ************************************************************** */
4231    int res = 0;
4232
4233    assert_string_is_neither_NULL_nor_zerolength(device);
4234    assert_string_is_neither_NULL_nor_zerolength(datafile);
4235
4236    while ((res = write_image_to_floppy_SUB(device, datafile))) {
4237        if (!ask_me_yes_or_no("Failed to write image to floppy. Retry?")) {
4238            return (res);
4239        }
4240    }
4241    return (res);
4242}
4243
4244/* @} - end of utilityGroup */
4245
4246void setenv_mondo_share(void) {
4247
4248setenv("MONDO_SHARE", MONDO_SHARE, 1);
4249}
Note: See TracBrowser for help on using the repository browser.