Changeset 532


Ignore:
Timestamp:
May 12, 2006, 1:21:13 AM (13 years ago)
Author:
bcornec
Message:

Fix a bug in rpm generation
Adds mondo conf file
Remove useless mondo-makefilelist
Rudimentary Script for the test env.
Preparation of the separation of log_msg function in a standalone file
Pass sysconfdir variable from configure system to mondoarchive to find conf file

Location:
branches/stable
Files:
1 deleted
5 edited
2 copied

Legend:

Unmodified
Added
Removed
  • branches/stable/mondo/distributions/conf/mondo.conf

    r449 r532  
    3030#
    3131#  ISO Burning CLI command options
    32 iso_burning_options="-eject dev=%s speed=%d fs=24m"
     32iso_burning_options="-eject dev=%s speed=%d fs=24m driveropts=burnfree"
    3333
    3434#
    35 # ISO Burning Speed
     35# ISO Burning Speed (optional)
    3636#
    37 iso_burning_speed=1
     37#iso_burning_speed=1
    3838
    3939#
     
    6262
    6363#
    64 # prefix for ISO names
     64# default prefix for ISO names
    6565#
    6666prefix=mondorescue
    67 
    68 #
    69 # Size of the boot image for ia64
    70 #
    71 ia64_boot_size=8192
    7267
    7368#
     
    141136
    142137#
     138# Paths to include onto the backup
     139# (white space separated list of paths)
     140#
     141include_files=""
     142
     143#
    143144# Activate semi-graphical mode by default (yes|no)
    144145#
     
    147148#
    148149# Activate automatic restore (Use with caution) (yes|no)
     150# (look at -H option in man page)
    149151#
    150152automatic_restore=no
     
    165167# Images creation dir
    166168#
    167 images_dir="/root/images/mindi"
     169images_dir="/var/cache/mondo"
  • branches/stable/mondo/distributions/rpm/mondo-doc.spec

    r531 r532  
    33#
    44
    5 %define name    mondo
     5%define name    mondo-doc
    66%define version VVV
    77%define mrel    RRR
     
    1010%define src     SSS
    1111%define grp     GRP
    12 %define addreqb mindi >= 1.0.7, bzip2 >= 0.9, afio, mkisofs, binutils, newt >= 0.50, slang >= 1.4.1
    1312%define addreq  DDD
    1413%define rel     %{mrel}
    1514
    16 Summary:    A program which a Linux user can utilize to create a rescue/restore CD/tape
    17 Summary(fr):    Un programme pour les utilisateurs de Linux pour créer un CD/tape de sauvegarde/restauration
    18 Summary(it):    Un programma per utenti Linux per creare un CD/tape di rescue
    19 Summary(sp):    Un programa para los usuarios de Linux por crear una CD/cinta de restoracion/rescate
     15Summary:    Documentation for Mondo Rescue
     16Summary(fr):    Documentation pour Mondo Rescue
    2017
    2118Name:       %{name}
     
    2724Source:     %{src}
    2825BuildRoot:  %{_tmppath}/%{name}-%{version}-%{release}-root-%(id -u -n)
    29 BuildRequires:  newt-devel >= 0.50, slang-devel >= 1.4.1, gcc
     26BuildRequires:  docbook-utils
    3027Epoch:      %(echo EEE | cut -d- -f1 | sed "s~M~~")
    3128OBS
    32 %ifarch ia64
    33 Requires:   %{addreq}, elilo, parted
    34 %else
    35 Requires:   %{addreq}, syslinux >= 1.52
    36 %endif
    3729
    3830%description
    39 Mondo is a GPL disaster recovery solution to create backup media
    40 (CD, DVD, tape, network images) that can be used to redeploy the
    41 damaged system, as well as deploy similar or less similar systems.
     31Documentation for Mondo Rescue
    4232
    4333%description -l fr
    44 Objectif
    45 """"""""
    46 Mondo est une solution GPL de sauvegarde en cas de désastre pour
    47 créer des médias (CD, DVD, bande, images réseau) qui peuvent être
    48 utilisés pour redéployer le système endomangé, aussi bien que des
    49 systèmes similaires, ou moins similaires.
    50 
    51 %description -l it
    52 Scopo
    53 """""
    54 Mondo e' un programma che permette a qualsiasi utente Linux
    55 di creare un cd di rescue/restore (o piu' cd qualora l'installazione
    56 dovesse occupare piu' di 2Gb circa). Funziona con gli azionamenti di
    57 nastro, ed il NFS, anche.
    58 
    59 %description -l sp
    60 Objectivo
    61 """""""""
    62 Mondo es un programa que permite cualquier usuario de Linux a crear una CD
    63 de restoracion/rescate (o CDs, si su instalacion es >2GO aprox.).  Funciona
    64 con cintas y NFS, tambien.
     34Documentation pour Mondo Rescue
    6535
    6636%prep
     
    6838
    6939%build
    70 %configure --program-prefix=%{?_program_prefix}
    7140%{__make} VERSION=%{version}
    7241
    7342%install
    7443%{__rm} -rf $RPM_BUILD_ROOT
    75 %makeinstall
     44%make -f Makefile.man install INSTALLDIR=$RPM_BUILDROOT/$RPM_DOC_DIR/%name-%{version}
     45%make -f Makefile.howto install INSTALLDIR=$RPM_BUILDROOT/$RPM_DOC_DIR/%name-%{version}
    7646
    7747%clean
     
    8050%files
    8151%defattr(644,root,root,755)
    82 %doc ChangeLog svn.log
    83 %doc INSTALL COPYING README TODO AUTHORS NEWS
    84 %doc docs/en/mondorescue-howto.html docs/en/mondorescue-howto.pdf
    85 
    86 %attr(755,root,root) %{_sbindir}/*
    87 %attr(755,root,root) %{_datadir}/%{name}/restore-scripts/%{name}/*
    88 %attr(755,root,root) %{_datadir}/%{name}/autorun
    89 %attr(755,root,root) %{_datadir}/%{name}/post-nuke.sample/usr/bin/post-nuke
    90 %{_datadir}/locale/*/LC_MESSAGES/mondo.mo
    91 %{_datadir}/%{name}/*
    92 %{_mandir}/man8/*
     52%doc svn.log
     53%doc
    9354
    9455%changelog
  • branches/stable/mondo/mondo/common/libmondo-conf.c

    r531 r532  
    4848/*setting flags*/
    4949#define MRCONF_FLAG_VERBOSE         0x1
    50 #define MRCONF_FLAG_ERROR_EXIT      0x2
    5150
    5251/*All strings of the library are here*/
     
    391390        }
    392391    }
    393 
    394     /* if the flag is set to ERROR_EXIT then any error leads to halt */
    395     if (mrconf_flags & MRCONF_FLAG_ERROR_EXIT) {
    396         if (mrconf_check_int_flag(MRCONF_INTFLAG_OPEN))
    397             mrconf_close();
    398         log_msg(4, "%s\n", MRCONF_STR_HALT);
    399         exit(error_code);
    400     }
    401 }
    402 
    403 
     392}
  • branches/stable/mondo/mondo/common/libmondo-msg.c

    r530 r532  
    1 /* libmondo-tools.c                                  misc tools
    2    $Id$
    3 .
    4 
    5 
    6 06/28
    7 - abort if RAID partitions found but /etc/raidtab not found
    8 
    9 06/25
    10 - don't insist on ms-sys; recommend it
    11 - don't fatal_error if can't open log file
    12 
    13 06/14
    14 - call mindi -V before calling mindi --makemountlist
    15 
    16 04/09
    17 - lots of malloc'd char*'s instead of char[]'s in post_param_config'n
    18 
    19 04/02
    20 - better sanity-checking, re: /etc/modules.conf
    21 
    22 02/15
    23 - abort if Windows dir but no ms-sys or parted
    24 
    25 02/08
    26 - missing ramdisk/initrd support is nonfatal now (but stupid)
    27 
    28 01/16
    29 - added g_kernel_version and get_kernel_version()
    30 
    31 01/08/2004
    32 - fixed /boot mounter thingy
    33 
    34 11/14/2003
    35 - if <50MB free in /root, softlink /root/images/mindi to
    36   /home/root/images/mindi as a workaround
    37 
    38 10/23
    39 - streaming backups now generate 4MB sets; CDs, 8MB sets
    40 
    41 10/21
    42 - better at finding your /boot in order to mount it, if nec.
    43 - link /etc/modules.conf to /etc/conf.modules if former
    44   is missing but latter is not
    45 - changed "/mnt/cdrom" to MNT_CDROM
    46 - changed "/mnt/floppy" to MNT_FLOPPY
    47 
    48 10/13
    49 - added stop_magicdev_if_necessary()
    50 - added restart_magicdev_if_necessary()
    51 
    52 10/02
    53 - don't eject if bkpinfo->please_dont_eject is TRUE
    54 
    55 09/28
    56 - fixed segfault in mount_..._necessary
    57 
    58 09/26
    59 - ask for cmp (or create workaround if possible)
    60 
    61 09/25
    62 - add DVD support
    63 
    64 09/24
    65 - don't overwrite existing media-dev value in bkpinfo IF it's
    66   a tape device AND it's already populated by /dev/{something}
    67   ...This helps w/ weird tape drives
    68 
    69 09/23
    70 - malloc/free global strings in new subroutines - malloc_libmondo_global_strings()
    71   and free_libmondo_global_strings() - which are in libmondo-tools.c
    72 
    73 09/18
    74 - added stop_autofs_if_necessary() and restart_autofs_if_necessary()
    75 
    76 09/13
    77 - added log_debug_msg()
    78 - turned log_it() into a macro
    79 
    80 09/10
    81 - reduced PPCFG_RAMDISK to 150m (was 200m)
    82 - max set size is now 8MB (was 6)
    83 - added 'buffer' to requisite tools
    84 
    85 08/29
    86 - typical set size is now 5MB
    87    
    88 07/22
    89 - increased PPCFG* to 200m
    90 
    91 05/07
    92 - changed grep -m1 to grep | head -n1 for Debian users
    93 - pre_param_...() also mkdir -p /mnt/cdrom, just in case
    94 
    95 05/05
    96 - cleaner logging of call to dd if=<tape> of=/dev/null
    97 - added Joshua Oreman's FreeBSD patches
    98 
    99 05/04
    100 - added Herman Kuster's multi-level bkp patch
    101 
    102 05/02
    103 - log_it() --- "Message repeated N times" (if it was)
    104 
    105 04/24
    106 - added lots of assert()'s and log_OS_error()'s
    107 - reset_bkpinfop() --- reset all media_size[] array
    108 - increased tmpfs ramdisk to size=100m
    109 
    110 04/22
    111 - post_param_configuration() --- store iso-dev and isodir
    112 
    113 04/05
    114 - re-enable tmpfs ramdisk/mountpt _but_ make sure size=80m
    115 - in post_param_configuration(), use cdrecord in preference
    116   to dvdrecord now
    117 
    118 03/27
    119 - disabled tmpfs ramdisk/mountpt
    120 
    121 01/02/2003
    122 - bkpinfo->makefilelist = TRUE
    123 
    124 12/10/2002
    125 - added g_loglevel
    126 - fixed minor bug in clean_up_KDE_desktop_if_necessary()
    127 - log versions of newt, slang, ncurses
    128 - isodir defaults to / if disaster recovery
    129 
    130 11/28
    131 - unmount all CD devices at start
    132 - added clean_up_KDE_desktop_if_necessary()
    133 
    134 11/20
    135 - don't use lilo.conf.anaconda; abort instead
    136 - mount/unmount /boot partition for Gentoo 1.2 users
    137 
    138 11/13
    139 - call mindi --makemountlist as part of testing sanity of distro
    140 
    141 11/08
    142 - added a couple of chmod 700's (one for scratchdir, one for tmpdir)
    143   to post_param_configuration()
    144 
    145 10/01 - 10/31
    146 - added checking of / and /root's free space to some_basic_sanity_checks()
    147 - moved some subroutines here from common/libmondo-archive
    148 
    149 09/01 - 09/30
    150 - don't write log_it()'s string to stdout, even if text mode
    151 - tell user the kernel is bad if it has no ramdisk support but allow
    152   it if they want to use the failsafe kernel for booting
    153 - run_program_and_log_output() now takes boolean operator to specify
    154   whether it will log its activities in the event of _success_
    155 - if mkfs.vfat not found but mkfs.msdos found then create a softlink
    156   from the former to the latter
    157 
    158 08/01 - 08/31
    159 - if /etc/lilo.conf not found not /etc/lilo.conf.anaconda found
    160   then create a softlink from the former to the latter, to work
    161   around RH7.3's b0rken LILO support
    162 - handle unknown media size
    163 
    164 07/27
    165 - created
    166 */
    167 
    168 
    169 /**
    170  * @file
    171  * Miscellaneous tools that didn't really fit anywhere else.
     1/*
     2 * Function to handle mondorescue messages
     3 *
     4 * $Id$
     5 *
    1726 */
    1737
    1748#include "my-stuff.h"
    175 #include "mondostructures.h"
    176 #include "libmondo-tools.h"
    177 #include "newt-specific-EXT.h"
    178 #include "libmondo-files-EXT.h"
    179 #include "libmondo-fork-EXT.h"
    180 #include "libmondo-raid-EXT.h"
    181 #include <sys/socket.h>
    182 #include <netdb.h>
    183 #include <netinet/in.h>
    184 #include <arpa/inet.h>
    1859
    186 /*@unused@*/
    187 //static char cvsid[] = "$Id$";
    188 
    189 extern int g_tape_buffer_size_MB;
    190 extern char *g_erase_tmpdir_and_scratchdir;
    191 extern char *g_serial_string;
    192 extern bool g_text_mode;
    193 extern int g_currentY;
    194 extern int g_current_media_number;
    195 
    196 /**
    197  * @addtogroup globalGroup
    198  * @{
    199  */
    200 bool g_remount_cdrom_at_end,    ///< TRUE if we unmounted the CD-ROM and should remount it when done with the backup.
    201  g_remount_floppy_at_end;       ///< TRUE if we unmounted the floppy and should remount it when done with the backup.
    202 bool g_cd_recovery;             ///< TRUE if we're making an "autonuke" backup.
    203 double g_kernel_version;
    204 
    205 /**
    206  * The place where /boot is mounted.
    207  */
    208 char *g_boot_mountpt = NULL;
    209 
    210 /**
    211  * The location of Mondo's home directory.
    212  */
    213 char *g_mondo_home = NULL;
    214 
    215 /**
    216  * The serial string (used to differentiate between backups) of the current backup.
    217  */
    218 char *g_serial_string = NULL;
    219 
    220 /**
    221  * The location where tmpfs is mounted, or "" if it's not mounted.
    222  */
    223 char *g_tmpfs_mountpt = NULL;
    224 char *g_magicdev_command = NULL;
     10extern int g_main_pid;
     11extern int g_buffer_pid;
    22512
    22613/**
     
    22916int g_loglevel = DEFAULT_DEBUG_LEVEL;
    23017
    231 /* @} - end of globalGroup */
    232 
    233 
    234 extern pid_t g_buffer_pid;
    235 extern pid_t g_main_pid;
    236 
    237 extern t_bkptype g_backup_media_type;
    238 
    239 extern bool am_I_in_disaster_recovery_mode(void);
    240 
    241 
    242 /**
    243  * @addtogroup utilityGroup
    244  * @{
    245  */
    246 /**
    247  * Assertion handler. Prints a friendly message to the user,
    248  * offering to ignore all, dump core, break to debugger,
    249  * exit, or ignore. Intended to be used with an assert() macro.
    250  *
    251  * @param file The file in which the assertion triggered.
    252  * @param function The function (@c __FUNCTION__) in which the assertion triggered.
    253  * @param line The line number of the assert() statement.
    254  * @param exp The expression that failed (as a string).
    255  */
    256 void _mondo_assert_fail(const char *file,
    257                         const char *function, int line, const char *exp)
    258 {
    259     static int ignoring_assertions = 0;
    260     bool is_valid = TRUE;
    261 
    262     log_it("ASSERTION FAILED: `%s' at %s:%d in %s", exp, file, line,
    263            function);
    264     if (ignoring_assertions) {
    265         log_it("Well, the user doesn't care...");
    266         return;
    267     }
    268 #ifndef _XWIN
    269     if (!g_text_mode)
    270         newtSuspend();
    271 #endif
    272     printf(_("ASSERTION FAILED: `%s'\n"), exp);
    273     printf(_("\tat %s:%d in %s\n\n"), file, line, function);
    274     printf(_("(I)gnore, ignore (A)ll, (D)ebug, a(B)ort, or (E)xit? "));
    275     do {
    276         is_valid = TRUE;
    277         switch (toupper(getchar())) {
    278         case 'A':               // ignore (A)ll
    279             ignoring_assertions = 1;
    280             break;
    281         case 'B':               // a(B)ort
    282             signal(SIGABRT, SIG_DFL);   /* prevent SIGABRT handler from running */
    283             raise(SIGABRT);
    284             break;              /* "can't get here" */
    285         case 'D':               // (D)ebug, aka asm("int 3")
    286 #ifdef __IA32__
    287             __asm__ __volatile__("int $3"); // break to debugger
    288 #endif
    289             break;
    290         case 'E':               // (E)xit
    291             fatal_error("Failed assertion -- see above for details");
    292             break;              /* "can't get here" */
    293         case 'I':               // (I)gnore
    294             break;
    295             /* These next two work as follows:
    296                the `default' catches the user's invalid choice and says so;
    297                the '\n' catches the newline on the end and prints the prompt again.
    298              */
    299         case '\n':
    300             printf
    301                 (_("(I)gnore, ignore (A)ll, (D)ebug, a(B)ort, or (E)xit? "));
    302             break;
    303         default:
    304             is_valid = FALSE;
    305             printf(_("Invalid choice.\n"));
    306             break;
    307         }
    308     } while (!is_valid);
    309 
    310     if (ignoring_assertions) {
    311         log_it("Ignoring ALL assertions from now on.");
    312     } else {
    313         log_it("Ignoring assertion: %s", exp);
    314     }
    315 
    316     getchar();                  // skip \n
    317 
    318 #ifndef _XWIN
    319     if (!g_text_mode)
    320         newtResume();
    321 #endif
    322 }
    323 
    324 /**
    325  * Clean's up users' KDE desktops.
    326  * @bug Details about this function are unknown.
    327  */
    328 void clean_up_KDE_desktop_if_necessary(void)
    329 {
    330     char *tmp;
    331 
    332     malloc_string(tmp);
    333     strcpy(tmp,
    334            "for i in `find /root /home -type d -name Desktop -maxdepth 2`; do \
    335 file=$i/.directory; if [ -f \"$file\" ] ; then mv -f $file $file.old ; \
    336 awk '{if (index($0, \"rootimagesmindi\")) { while (length($0)>2) { getline;} ; } \
    337 else { print $0;};}' $file.old  > $file ; fi ; done");
    338     run_program_and_log_output(tmp, 5);
    339     paranoid_free(tmp);
    340 }
    341 
    342 
    343 /**
    344  * Locate mondoarchive's home directory. Searches in /usr/local/mondo, /usr/share/mondo,
    345  * /usr/local/share/mondo, /opt, or if all else fails, search /usr.
    346  *
    347  * @param home_sz String to store the home directory ("" if it could not be found).
    348  * @return 0 for success, nonzero for failure.
    349  */
    350 int find_and_store_mondoarchives_home(char *home_sz)
    351 {
    352     assert(home_sz != NULL);
    353     strcpy(home_sz, MONDO_SHARE);
    354     return (0);
    355 }
    356 
    357 
    358 char *get_architecture()
    359 {
    360 #ifdef __IA32__
    361     return ("i386");
    362 #endif
    363 #ifdef __IA64__
    364     return ("ia64");
    365 #endif
    366     return ("unknown");
    367 }
    368 
    369 
    370 
    371 double get_kernel_version()
    372 {
    373     char *p, tmp[200];
    374     double d;
    375 #ifdef __FreeBSD__
    376     // JOSH - FIXME :)
    377     d = 5.2;                    // :-)
    378 #else
    379     strcpy(tmp, call_program_and_get_last_line_of_output("uname -r"));
    380     p = strchr(tmp, '.');
    381     if (p) {
    382         p = strchr(++p, '.');
    383         if (p) {
    384             while (*p) {
    385                 *p = *(p + 1);
    386                 p++;
    387             }
    388         }
    389     }
    390 //  log_msg(1, "tmp = '%s'", tmp);
    391     d = atof(tmp);
    392 #endif
    393     log_msg(1, "g_kernel_version = %f", d);
    394     return (d);
    395 }
    396 
    397 
    398 
    399 
    400 
    401 /**
    402  * Get the current time.
    403  * @return number of seconds since the epoch.
    404  */
    405 long get_time()
    406 {
    407     return (long) time((void *) 0);
    408 }
    409 
    410 
    411 
    412 
    413 
    414 
    415 
    416 /**
    417  * Initialize a RAID volume structure, setting fields to zero. The
    418  * actual hard drive is unaffected.
    419  *
    420  * @param raidrec The RAID volume structure to initialize.
    421  * @note This function is system dependent.
    422  */
    423 #ifdef __FreeBSD__
    424 void initialize_raidrec(struct vinum_volume *raidrec)
    425 {
    426     int i, j;
    427     raidrec->volname[0] = '\0';
    428     raidrec->plexes = 0;
    429     for (i = 0; i < 9; ++i) {
    430         raidrec->plex[i].raidlevel = -1;
    431         raidrec->plex[i].stripesize = 0;
    432         raidrec->plex[i].subdisks = 0;
    433         for (j = 0; j < 9; ++j) {
    434             strcpy(raidrec->plex[i].sd[j].which_device, "");
    435         }
    436     }
    437 }
    438 #else
    439 void initialize_raidrec(struct raid_device_record *raidrec)
    440 {
    441     assert(raidrec != NULL);
    442     raidrec->raid_device[0] = '\0';
    443     raidrec->raid_level = 0;
    444     raidrec->chunk_size = 4;
    445     raidrec->persistent_superblock = 1;
    446     raidrec->data_disks.entries = 0;
    447     raidrec->spare_disks.entries = 0;
    448     raidrec->parity_disks.entries = 0;
    449     raidrec->failed_disks.entries = 0;
    450     raidrec->additional_vars.entries = 0;
    451 }
    452 #endif
    453 
    454 
    455 
    456 
    457 /**
    458  * Insert modules that Mondo requires.
    459  * Currently inserts @c dos, @c fat, @c vfat, and @c osst for Linux;
    460  * @c msdosfs and @c ext2fs for FreeBSD.
    461  */
    462 void insmod_crucial_modules(void)
    463 {
    464 #ifdef __FreeBSD__
    465     system("kldstat | grep msdosfs || kldload msdosfs 2> /dev/null");
    466     system("kldstat | grep ext2fs  || kldload ext2fs 2> /dev/null");
    467 #else
    468     system("modprobe dos &> /dev/null");
    469     system("modprobe fat &> /dev/null");
    470     system("modprobe vfat &> /dev/null");
    471     //  system("modprobe osst &> /dev/null");
    472 #endif
    473 }
    474 
    475 
    476 /**
    477  * Log a trace message to the trace file.
    478  * @bug This function seems orphaned. Please remove.
    479  */
    480 void log_trace(char *o)
    481 {
    482     /*@ pointers **************************************************** */
    483     FILE *fout;
    484 
    485     /*@ buffers ***************************************************** */
    486     char output[MAX_STR_LEN];
    487 
    488     /*@ int    ****************************************************** */
    489     int i;
    490 
    491     /*@ end vars *************************************************** */
    492 
    493     if (o[0] == '\0') {
    494         return;
    495     }
    496     strcpy(output, o);
    497     i = (int) strlen(output);
    498     if (i <= 0) {
    499         return;
    500     }
    501     if (output[i - 1] < 32) {
    502         output[i - 1] = '\0';
    503     }
    504     if (g_text_mode
    505         /* && !strstr(last_line_of_file(MONDO_LOGFILE),output) */ ) {
    506         printf("%s\n", output);
    507     }
    508 
    509     fout = fopen(MONDO_TRACEFILE, "a");
    510     if (fout) {
    511         fprintf(fout, "%s\n", output);
    512         paranoid_fclose(fout);
    513     } else {
    514         log_OS_error("Cannot write to tracefile");
    515     }
    516 }
    517 
    518 
    519 
    520 
    521 
    522 /**
    523  * Finish configuring the backup information structure. Call this function
    524  * to set the parameters that depend on those that can be given on the command
    525  * line.
    526  *
    527  * @param bkpinfo The backup information structure. Fields modified/used:
    528  * - Used: @c bkpinfo->backup_data
    529  * - Used: @c bkpinfo->backup_media_type
    530  * - Used: @c bkpinfo->cdrw_speed
    531  * - Used: @c bkpinfo->compression_level
    532  * - Used: @c bkpinfo->include_paths
    533  * - Used: @c bkpinfo->prefix
    534  * - Used: @c bkpinfo->isodir
    535  * - Used: @c bkpinfo->manual_cd_tray
    536  * - Used: @c bkpinfo->make_cd_use_lilo
    537  * - Used: @c bkpinfo->media_device
    538  * - Used: @c bkpinfo->nfs_mount
    539  * - Used: @c bkpinfo->nonbootable_backup
    540  * - Used: @c bkpinfo->scratchdir
    541  * - Used: @c bkpinfo->tmpdir
    542  * - Used: @c bkpinfo->use_lzo
    543  * - Modified: @c bkpinfo->call_before_iso
    544  * - Modified: @c bkpinfo->call_make_iso
    545  * - Modified: @c bkpinfo->optimal_set_size
    546  * - Modified: @c bkpinfo->zip_exe
    547  * - Modified: @c bkpinfo->zip_suffix
    548  *
    549  * @return number of errors, or 0 for success.
    550  * @note Also creates directories that are specified in the @c bkpinfo structure but
    551  * do not exist.
    552  */
    553 int post_param_configuration(struct s_bkpinfo *bkpinfo)
    554 {
    555     char *extra_cdrom_params;
    556     char *mondo_mkisofs_sz;
    557     char *command;
    558     char *mtpt;
    559     char *hostname, *ip_address;
    560     int retval = 0;
    561     long avm = 0;
    562     char *colon;
    563     char *cdr_exe;
    564     char *tmp;
    565     char call_before_iso_user[MAX_STR_LEN] = "\0";
    566     int rdsiz_MB;
    567     char *iso_dev;
    568     char *iso_mnt;
    569     char *iso_tmp;
    570     char *iso_path;
    571 
    572     assert(bkpinfo != NULL);
    573     malloc_string(extra_cdrom_params);
    574     malloc_string(mondo_mkisofs_sz);
    575     malloc_string(command);
    576     malloc_string(mtpt);
    577     malloc_string(hostname);
    578     malloc_string(ip_address);
    579     malloc_string(cdr_exe);
    580     malloc_string(tmp);
    581     malloc_string(iso_dev);
    582     malloc_string(iso_mnt);
    583     malloc_string(iso_tmp);
    584     malloc_string(iso_path);
    585     bkpinfo->optimal_set_size =
    586         (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type) ? 4 : 8) *
    587         1024;
    588 
    589     log_msg(1, "Foo");
    590     if (bkpinfo->backup_media_type == tape) {
    591         log_msg(1, "Bar");
    592         sprintf(tmp, "mt -f %s status", bkpinfo->media_device);
    593         log_msg(1, "tmp = '%s'", tmp);
    594         if (run_program_and_log_output(tmp, 3)) {
    595             fatal_error
    596                 ("Unable to open tape device. If you haven't specified it with -d, do so. If you already have, check your parameter. I think it's wrong.");
    597         }
    598     }
    599     make_hole_for_dir(bkpinfo->scratchdir);
    600     make_hole_for_dir(bkpinfo->tmpdir);
    601     if (bkpinfo->backup_media_type == iso)
    602         make_hole_for_dir(bkpinfo->isodir);
    603 
    604     run_program_and_log_output("uname -a", 5);
    605     run_program_and_log_output("cat /etc/*issue*", 5);
    606     sprintf(g_tmpfs_mountpt, "%s/tmpfs", bkpinfo->tmpdir);
    607     sprintf(command, "mkdir -p %s", g_tmpfs_mountpt);
    608     paranoid_system(command);
    609     rdsiz_MB = PPCFG_RAMDISK_SIZE + g_tape_buffer_size_MB;
    610 #ifdef __FreeBSD__
    611     strcpy(tmp,
    612            call_program_and_get_last_line_of_output
    613            ("vmstat | tail -1 | tr -s ' ' | cut -d' ' -f6"));
    614     avm += atol(tmp);
    615     strcpy(tmp,
    616            call_program_and_get_last_line_of_output
    617            ("swapinfo | grep -v Device | tr -s ' ' | cut -d' ' -f4 | tr '\n' '+' | sed 's/+$//' | bc"));
    618     avm += atol(tmp);
    619     sprintf(command, "mdmfs -s %d%c md9 %s", rdsiz_MB, 'm',
    620             g_tmpfs_mountpt);
    621 #else
    622     strcpy(tmp,
    623            call_program_and_get_last_line_of_output
    624            ("free | grep \":\" | tr -s ' ' '\t' | cut -f2 | head -n1"));
    625     avm += atol(tmp);
    626     sprintf(command, "mount /dev/shm -t tmpfs %s -o size=%d%c",
    627             g_tmpfs_mountpt, rdsiz_MB, 'm');
    628     run_program_and_log_output("cat /proc/cpuinfo", 5);
    629     run_program_and_log_output
    630         ("rpm -q newt newt-devel slang slang-devel ncurses ncurses-devel gcc",
    631          5);
    632 #endif
    633     if (avm / 1024 > rdsiz_MB * 3) {
    634         if (run_program_and_log_output(command, 5)) {
    635             g_tmpfs_mountpt[0] = '\0';
    636             log_it("Failed to mount tmpfs");
    637         } else {
    638             log_it("Tmpfs mounted OK - %d MB", rdsiz_MB);
    639         }
    640     } else {
    641         g_tmpfs_mountpt[0] = '\0';
    642         log_it("It doesn't seem you have enough swap to use tmpfs. Fine.");
    643     }
    644 
    645     if (bkpinfo->use_lzo) {
    646         strcpy(bkpinfo->zip_exe, "lzop");
    647         strcpy(bkpinfo->zip_suffix, "lzo");
    648     } else if (bkpinfo->compression_level != 0) {
    649         strcpy(bkpinfo->zip_exe, "bzip2");
    650         strcpy(bkpinfo->zip_suffix, "bz2");
    651     } else {
    652         bkpinfo->zip_exe[0] = bkpinfo->zip_suffix[0] = '\0';
    653     }
    654 
    655 // DVD
    656 
    657     if (bkpinfo->backup_media_type == dvd) {
    658         extra_cdrom_params[0] = '\0';
    659         mondo_mkisofs_sz[0] = '\0';
    660         if (find_home_of_exe("growisofs")) {
    661             strcpy(cdr_exe, "growisofs");
    662         }                       // unlikely to be used
    663         else {
    664             fatal_error("Please install growisofs.");
    665         }
    666         if (bkpinfo->nonbootable_backup) {
    667             strcat(mondo_mkisofs_sz, MONDO_GROWISOFS_NONBOOT);
    668         } else if
    669 #ifdef __FreeBSD__
    670             (TRUE)
    671 #else
    672             (bkpinfo->make_cd_use_lilo)
    673 #endif
    674 #ifdef __IA64__
    675     {
    676         strcat(mondo_mkisofs_sz, MONDO_GROWISOFS_REGULAR_ELILO);
    677     }
    678 #else
    679     {
    680         strcat(mondo_mkisofs_sz, MONDO_GROWISOFS_REGULAR_LILO);
    681     }
    682 #endif
    683         else
    684         {
    685             strcat(mondo_mkisofs_sz, MONDO_GROWISOFS_REGULAR_SYSLINUX);
    686         }
    687         if (bkpinfo->manual_cd_tray) {
    688             fatal_error("Manual CD tray + DVD not supported yet.");
    689             // -m isn't supported by growisofs, BTW...
    690         } else {
    691             sprintf(bkpinfo->call_make_iso,
    692                     "%s %s -Z %s . 2>> _ERR_",
    693                     mondo_mkisofs_sz,
    694                     extra_cdrom_params, bkpinfo->media_device);
    695         }
    696         if (getenv ("SUDO_COMMAND")) {
    697             fatal_error("Can't write DVDs as sudo because growisofs doesn't support this - see the growisofs manpage for details.");
    698         }
    699         log_msg(2, "call_make_iso (DVD res) is ... %s",
    700                 bkpinfo->call_make_iso);
    701     }                           // end of DVD code
    702 
    703 // CD-R or CD-RW
    704     if (bkpinfo->backup_media_type == cdrw
    705         || bkpinfo->backup_media_type == cdr) {
    706         extra_cdrom_params[0] = '\0';
    707         if (!bkpinfo->manual_cd_tray) {
    708             strcat(extra_cdrom_params, "-waiti ");
    709         }
    710         if (bkpinfo->backup_media_type == cdrw) {
    711             strcat(extra_cdrom_params, "blank=fast ");
    712         }
    713         if (find_home_of_exe("cdrecord")) {
    714             strcpy(cdr_exe, "cdrecord");
    715         } else if (find_home_of_exe("dvdrecord")) {
    716             strcpy(cdr_exe, "dvdrecord");
    717         } else {
    718             fatal_error("Please install either cdrecord or dvdrecord.");
    719         }
    720         if (bkpinfo->nonbootable_backup) {
    721             strcpy(mondo_mkisofs_sz, MONDO_MKISOFS_NONBOOT);
    722         } else if
    723 #ifdef __FreeBSD__
    724             (TRUE)
    725 #else
    726             (bkpinfo->make_cd_use_lilo)
    727 #endif
    728 #ifdef __IA64__
    729     {
    730         strcat(mondo_mkisofs_sz, MONDO_MKISOFS_REGULAR_ELILO);
    731     }
    732 #else
    733     {
    734         strcpy(mondo_mkisofs_sz, MONDO_MKISOFS_REGULAR_LILO);
    735     }
    736 #endif
    737         else
    738         {
    739             strcpy(mondo_mkisofs_sz, MONDO_MKISOFS_REGULAR_SYSLINUX);
    740         }
    741         if (bkpinfo->manual_cd_tray) {
    742             if (bkpinfo->call_before_iso[0] == '\0') {
    743             sprintf(bkpinfo->call_before_iso,
    744                         "%s -o %s/temporary.iso . 2>> _ERR_",
    745                         mondo_mkisofs_sz, bkpinfo->tmpdir);
    746                 } else {
    747                 strncpy(call_before_iso_user, bkpinfo->call_before_iso, MAX_STR_LEN);
    748                 sprintf (bkpinfo->call_before_iso,
    749                                     "( %s -o %s/temporary.iso . 2>> _ERR_ ; %s )",
    750                         mondo_mkisofs_sz, bkpinfo->tmpdir, call_before_iso_user);
    751             }
    752             log_it("bkpinfo->call_before_iso = %s", bkpinfo->call_before_iso);
    753             sprintf(bkpinfo->call_make_iso,
    754                     "%s %s -v %s fs=4m dev=%s speed=%d %s/temporary.iso",
    755                     cdr_exe, (bkpinfo->please_dont_eject) ? " " : "-eject",
    756                     extra_cdrom_params, bkpinfo->media_device,
    757                     bkpinfo->cdrw_speed, bkpinfo->tmpdir);
    758         } else {
    759             sprintf(bkpinfo->call_make_iso,
    760                     "%s . 2>> _ERR_ | %s %s %s fs=4m dev=%s speed=%d -",
    761                     mondo_mkisofs_sz, cdr_exe,
    762                     (bkpinfo->please_dont_eject) ? " " : "-eject",
    763                     extra_cdrom_params, bkpinfo->media_device,
    764                     bkpinfo->cdrw_speed);
    765         }
    766     }                           // end of CD code
    767 
    768     /*
    769        if (bkpinfo->backup_data && bkpinfo->backup_media_type == tape)
    770        {
    771        sprintf (tmp,
    772        "dd if=/dev/zero of=%s bs=%ld count=32 2> /dev/null",
    773        bkpinfo->media_device, bkpinfo->internal_tape_block_size);
    774        if (system(tmp))
    775        {
    776        retval++;
    777        fprintf (stderr,
    778        "Cannot write to tape device. Is the tape set read-only?\n");
    779        }
    780        } // end of tape code
    781      */
    782 
    783 
    784     if (bkpinfo->backup_media_type == iso) {
    785 
    786 /* Patch by Conor Daly <conor.daly@met.ie>
    787  * 23-june-2004
    788  * Break up isodir into iso_mnt and iso_path
    789  * These will be used along with iso-dev at restore time
    790  * to locate the ISOs where ever they're mounted
    791  */
    792 
    793         log_it("isodir = %s", bkpinfo->isodir);
    794         sprintf(command, "df -P %s | tail -n1 | cut -d' ' -f1",
    795                 bkpinfo->isodir);
    796         log_it("command = %s", command);
    797         log_it("res of it = %s",
    798                call_program_and_get_last_line_of_output(command));
    799         sprintf(iso_dev, "%s",
    800                 call_program_and_get_last_line_of_output(command));
    801         sprintf(tmp, "%s/ISO-DEV", bkpinfo->tmpdir);
    802         write_one_liner_data_file(tmp,
    803                                   call_program_and_get_last_line_of_output
    804                                   (command));
    805 
    806         sprintf(command, "mount | grep -w %s | tail -n1 | cut -d' ' -f3",
    807                 iso_dev);
    808         log_it("command = %s", command);
    809         log_it("res of it = %s",
    810                call_program_and_get_last_line_of_output(command));
    811         sprintf(iso_mnt, "%s",
    812                 call_program_and_get_last_line_of_output(command));
    813         sprintf(tmp, "%s/ISO-MNT", bkpinfo->tmpdir);
    814         write_one_liner_data_file(tmp,
    815                                   call_program_and_get_last_line_of_output
    816                                   (command));
    817         log_it("isomnt: %s, %d", iso_mnt, strlen(iso_mnt));
    818         sprintf(iso_tmp, "%s", bkpinfo->isodir);
    819         if (strlen(iso_tmp) < strlen(iso_mnt)) {
    820             iso_path[0] = '\0';
    821         } else {
    822             sprintf(iso_path, "%s", iso_tmp + strlen(iso_mnt));
    823         }
    824         sprintf(tmp, "%s/ISODIR", bkpinfo->tmpdir);
    825         write_one_liner_data_file(tmp, iso_path);
    826         log_it("isodir: %s", iso_path);
    827         sprintf(tmp, "%s/ISO-PREFIX", bkpinfo->tmpdir);
    828         write_one_liner_data_file(tmp, bkpinfo->prefix);
    829         log_it("iso-prefix: %s",  bkpinfo->prefix);
    830 
    831 /* End patch */
    832     }                           // end of iso code
    833 
    834     if (bkpinfo->backup_media_type == nfs) {
    835         strcpy(hostname, bkpinfo->nfs_mount);
    836         colon = strchr(hostname, ':');
    837         if (!colon) {
    838             log_it("nfs mount doesn't have a colon in it");
    839             retval++;
    840         } else {
    841             struct hostent *hent;
    842 
    843             *colon = '\0';
    844             hent = gethostbyname(hostname);
    845             if (!hent) {
    846                 log_it("Can't resolve NFS mount (%s): %s", hostname,
    847                        hstrerror(h_errno));
    848                 retval++;
    849             } else {
    850                 strcpy(ip_address, inet_ntoa
    851                        ((struct in_addr)
    852                         *((struct in_addr *) hent->h_addr)));
    853                 strcat(ip_address, strchr(bkpinfo->nfs_mount, ':'));
    854                 strcpy(bkpinfo->nfs_mount, ip_address);
    855             }
    856         }
    857         store_nfs_config(bkpinfo);
    858     }
    859 
    860     log_it("Finished processing incoming params");
    861     if (retval) {
    862         fprintf(stderr, "Type 'man mondoarchive' for help.\n");
    863     }
    864     sprintf(tmp, "%s", MONDO_TMPISOS);  /* added #define 22 apr 2002 */
    865     if (does_file_exist(tmp)) {
    866         unlink(tmp);
    867     }
    868     if (strlen(bkpinfo->tmpdir) < 2 || strlen(bkpinfo->scratchdir) < 2) {
    869         log_it("tmpdir or scratchdir are blank/missing");
    870         retval++;
    871     }
    872     if (bkpinfo->include_paths[0] == '\0') {
    873         //      fatal_error ("Why no backup path?");
    874         strcpy(bkpinfo->include_paths, "/");
    875     }
    876     chmod(bkpinfo->scratchdir, 0700);
    877     chmod(bkpinfo->tmpdir, 0700);
    878     g_backup_media_type = bkpinfo->backup_media_type;
    879     paranoid_free(mtpt);
    880     paranoid_free(extra_cdrom_params);
    881     paranoid_free(mondo_mkisofs_sz);
    882     paranoid_free(command);
    883     paranoid_free(hostname);
    884     paranoid_free(ip_address);
    885     paranoid_free(cdr_exe);
    886     paranoid_free(tmp);
    887     paranoid_free(iso_dev);
    888     paranoid_free(iso_mnt);
    889     paranoid_free(iso_tmp);
    890     paranoid_free(iso_path);
    891     return (retval);
    892 }
    893 
    894 
    895 
    896 /**
    897  * Do some miscellaneous setup tasks to be performed before filling @c bkpinfo.
    898  * Seeds the random-number generator, loads important modules, checks the sanity
    899  * of the user's Linux distribution, and deletes logfile.
    900  * @param bkpinfo The backup information structure. Will be initialized.
    901  * @return number of errors (0 for success)
    902  */
    903 int pre_param_configuration(struct s_bkpinfo *bkpinfo)
    904 {
    905     int res = 0;
    906 
    907     make_hole_for_dir(MNT_CDROM);
    908     assert(bkpinfo != NULL);
    909     srandom((unsigned long) (time(NULL)));
    910     insmod_crucial_modules();
    911     reset_bkpinfo(bkpinfo);     // also sets defaults ('/'=backup path, 3=compression level)
    912     if (bkpinfo->disaster_recovery) {
    913         if (!does_nonMS_partition_exist()) {
    914             fatal_error
    915                 ("I am in disaster recovery mode\nPlease don't run mondoarchive.");
    916         }
    917     }
    918 
    919     unlink(MONDO_TRACEFILE);
    920     run_program_and_log_output("rm -Rf /tmp/changed.files*", FALSE);
    921     if (find_and_store_mondoarchives_home(g_mondo_home)) {
    922         fprintf(stderr,
    923                 "Cannot find Mondo's homedir. I think you have >1 'mondo' directory on your hard disk. Please delete the superfluous 'mondo' directories and try again\n");
    924         res++;
    925         return (res);
    926     }
    927     res += some_basic_system_sanity_checks();
    928     if (res) {
    929         log_it("Your distribution did not pass Mondo's sanity test.");
    930     }
    931     g_current_media_number = 1;
    932     bkpinfo->postnuke_tarball[0] = bkpinfo->nfs_mount[0] = '\0';
    933     return (res);
    934 }
    935 
    936 
    937 
    938 
    939 /**
    940  * Reset all fields of the backup information structure to a sensible default.
    941  * @param bkpinfo The @c bkpinfo to reset.
    942  */
    943 void reset_bkpinfo(struct s_bkpinfo *bkpinfo)
    944 {
    945     int i;
    946 
    947     log_msg(1, "Hi");
    948     assert(bkpinfo != NULL);
    949     memset((void *) bkpinfo, 0, sizeof(struct s_bkpinfo));
    950     bkpinfo->manual_cd_tray = FALSE;
    951     bkpinfo->internal_tape_block_size = DEFAULT_INTERNAL_TAPE_BLOCK_SIZE;
    952     bkpinfo->media_device[0] = '\0';
    953     for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
    954         bkpinfo->media_size[i] = -1;
    955     }
    956     bkpinfo->boot_loader = '\0';
    957     bkpinfo->boot_device[0] = '\0';
    958     bkpinfo->zip_exe[0] = '\0';
    959     bkpinfo->zip_suffix[0] = '\0';
    960     bkpinfo->restore_path[0] = '\0';
    961     bkpinfo->use_lzo = FALSE;
    962     bkpinfo->do_not_compress_these[0] = '\0';
    963     bkpinfo->verify_data = FALSE;
    964     bkpinfo->backup_data = FALSE;
    965     bkpinfo->restore_data = FALSE;
    966     bkpinfo->disaster_recovery =
    967         (am_I_in_disaster_recovery_mode()? TRUE : FALSE);
    968     if (bkpinfo->disaster_recovery) {
    969         strcpy(bkpinfo->isodir, "/");
    970     } else {
    971         strcpy(bkpinfo->isodir, "/root/images/mondo");
    972     }
    973     strcpy(bkpinfo->prefix, STD_PREFIX);
    974 
    975     bkpinfo->scratchdir[0] = '\0';
    976     bkpinfo->make_filelist = TRUE;  // unless -J supplied to mondoarchive
    977     sprintf(bkpinfo->tmpdir, "/tmp/tmpfs/mondo.tmp.%d", (int) (random() % 32768));  // for mondorestore
    978     bkpinfo->optimal_set_size = 0;
    979     bkpinfo->backup_media_type = none;
    980     strcpy(bkpinfo->include_paths, "/");
    981     bkpinfo->exclude_paths[0] = '\0';
    982     bkpinfo->call_before_iso[0] = '\0';
    983     bkpinfo->call_make_iso[0] = '\0';
    984     bkpinfo->call_burn_iso[0] = '\0';
    985     bkpinfo->call_after_iso[0] = '\0';
    986     bkpinfo->image_devs[0] = '\0';
    987     bkpinfo->postnuke_tarball[0] = '\0';
    988     bkpinfo->kernel_path[0] = '\0';
    989     bkpinfo->nfs_mount[0] = '\0';
    990     bkpinfo->nfs_remote_dir[0] = '\0';
    991     bkpinfo->wipe_media_first = FALSE;
    992     bkpinfo->differential = FALSE;
    993     bkpinfo->cdrw_speed = 0;
    994 // patch by Herman Kuster 
    995     bkpinfo->differential = 0;
    996 // patch end
    997     bkpinfo->compression_level = 3;
    998 }
    999 
    1000 
    1001 
    1002 
    1003 /**
    1004  * Get the remaining free space (in MB) on @p partition.
    1005  * @param partition The partition to check free space on (either a device or a mountpoint).
    1006  * @return The free space on @p partition, in MB.
    1007  */
    1008 long free_space_on_given_partition(char *partition)
    1009 {
    1010     char command[MAX_STR_LEN], out_sz[MAX_STR_LEN];
    1011     long res;
    1012 
    1013     assert_string_is_neither_NULL_nor_zerolength(partition);
    1014 
    1015     sprintf(command, "df -m -P %s &> /dev/null", partition);
    1016     if (system(command)) {
    1017         return (-1);
    1018     }                           // partition does not exist
    1019     sprintf(command, "df -m -P %s | tail -n1 | tr -s ' ' '\t' | cut -f4",
    1020             partition);
    1021     strcpy(out_sz, call_program_and_get_last_line_of_output(command));
    1022     if (strlen(out_sz) == 0) {
    1023         return (-1);
    1024     }                           // error within df, probably
    1025     res = atol(out_sz);
    1026     return (res);
    1027 }
    1028 
    1029 
    1030 
    1031 /**
    1032  * Check the user's system for sanity. Checks performed:
    1033  * - make sure user has enough RAM (32mb required, 64mb recommended)
    1034  * - make sure user has enough free space in @c /
    1035  * - check kernel for ramdisk support
    1036  * - make sure afio, cdrecord, mkisofs, bzip2, awk, md5sum, strings, mindi, and buffer exist
    1037  * - make sure CD-ROM is unmounted
    1038  * - make sure /etc/modules.conf exists
    1039  * - make sure user's mountlist is OK by running <tt>mindi --makemountlist</tt>
    1040  *
    1041  * @return number of problems with the user's setup (0 for success)
    1042  */
    1043 int some_basic_system_sanity_checks()
    1044 {
    1045 
    1046     /*@ buffers ************ */
    1047     char tmp[MAX_STR_LEN];
    1048     //  char command[MAX_STR_LEN];
    1049 
    1050     /*@ int's *************** */
    1051     int retval = 0;
    1052     long Lres;
    1053 
    1054 
    1055     mvaddstr_and_log_it(g_currentY, 0,
    1056                         "Checking sanity of your Linux distribution");
    1057 #ifndef __FreeBSD__
    1058     if (system("which mkfs.vfat &> /dev/null")
    1059         && !system("which mkfs.msdos &> /dev/null")) {
    1060         log_it
    1061             ("OK, you've got mkfs.msdos but not mkfs.vfat; time for the fairy to wave her magic wand...");
    1062         run_program_and_log_output
    1063             ("ln -sf `which mkfs.msdos` /sbin/mkfs.vfat", FALSE);
    1064     }
    1065     strcpy(tmp,
    1066            call_program_and_get_last_line_of_output
    1067            ("free | grep Mem | head -n1 | tr -s ' ' '\t' | cut -f2"));
    1068     if (atol(tmp) < 35000) {
    1069         retval++;
    1070         log_to_screen(_("You must have at least 32MB of RAM to use Mondo."));
    1071     }
    1072     if (atol(tmp) < 66000) {
    1073         log_to_screen
    1074             (_("WARNING! You have very little RAM. Please upgrade to 64MB or more."));
    1075     }
    1076 #endif
    1077 
    1078     if ((Lres = free_space_on_given_partition("/root")) == -1) {
    1079         Lres = free_space_on_given_partition("/");
    1080     }
    1081     log_it("Free space on given partition = %ld MB", Lres);
    1082 
    1083     if (Lres < 50) {
    1084         run_program_and_log_output
    1085             ("rm -Rf /root/images/mindi; mkdir -p /home/root/images/mindi; mkdir -p /root/images; ln -sf /home/root/images/mindi /root/images/mindi",
    1086              3);
    1087         //      fatal_error("Your / (or /root) partition has <50MB free. Please adjust your partition table to something saner.");
    1088     }
    1089 
    1090     if (system("which " MKE2FS_OR_NEWFS " > /dev/null 2> /dev/null")) {
    1091         retval++;
    1092         log_to_screen
    1093             ("Unable to find " MKE2FS_OR_NEWFS " in system path.");
    1094         fatal_error
    1095             ("Please use \"su -\", not \"su\" to become root. OK? ...and please don't e-mail the mailing list or me about this. Just read the message. :)");
    1096     }
    1097 #ifndef __FreeBSD__
    1098     if (run_program_and_log_output
    1099         ("grep ramdisk /proc/devices", FALSE)) {
    1100         if (!ask_me_yes_or_no
    1101             (_("Your kernel has no ramdisk support. That's mind-numbingly stupid but I'll allow it if you're planning to use a failsafe kernel. Are you?")))
    1102         {
    1103             //          retval++;
    1104             log_to_screen
    1105                 (_("It looks as if your kernel lacks ramdisk and initrd support."));
    1106             log_to_screen
    1107                 (_("I'll allow you to proceed but FYI, if I'm right, your kernel is broken."));
    1108         }
    1109     }
    1110 #endif
    1111     retval += whine_if_not_found(MKE2FS_OR_NEWFS);
    1112     retval += whine_if_not_found("mkisofs");
    1113     if (system("which dvdrecord > /dev/null 2> /dev/null")) {
    1114         retval += whine_if_not_found("cdrecord");
    1115     }
    1116     retval += whine_if_not_found("bzip2");
    1117     retval += whine_if_not_found("awk");
    1118     retval += whine_if_not_found("md5sum");
    1119     retval += whine_if_not_found("strings");
    1120     retval += whine_if_not_found("mindi");
    1121     retval += whine_if_not_found("buffer");
    1122 
    1123     // abort if Windows partition but no ms-sys and parted
    1124     if (!run_program_and_log_output
    1125         ("mount | grep -w vfat | grep -v /dev/fd | grep -v nexdisk", 0)
    1126         ||
    1127         !run_program_and_log_output
    1128         ("mount | grep -w dos | grep -v /dev/fd | grep -v nexdisk", 0)) {
    1129         log_to_screen(_("I think you have a Windows 9x partition."));
    1130         retval += whine_if_not_found("parted");
    1131 #ifndef __IA64__
    1132         /* IA64 always has one vfat partition for EFI even without Windows */
    1133         // retval +=
    1134         if (!find_home_of_exe("ms-sys")) {
    1135             log_to_screen(_("Please install ms-sys just in case."));
    1136         }
    1137 #endif
    1138     }
    1139 
    1140     if (!find_home_of_exe("cmp")) {
    1141         if (!find_home_of_exe("true")) {
    1142             whine_if_not_found("cmp");
    1143         } else {
    1144             log_to_screen
    1145                 (_("Your system lacks the 'cmp' binary. I'll create a dummy cmp for you."));
    1146             if (run_program_and_log_output
    1147                 ("cp -f `which true` /usr/bin/cmp", 0)) {
    1148                 fatal_error("Failed to create dummy 'cmp' file.");
    1149             }
    1150         }
    1151     }
    1152     run_program_and_log_output
    1153         ("umount `mount | grep cdr | cut -d' ' -f3 | tr '\n' ' '`", 5);
    1154     strcpy(tmp,
    1155            call_program_and_get_last_line_of_output
    1156            ("mount | grep -E \"cdr(om|w)\""));
    1157     if (strcmp("", tmp)) {
    1158         if (strstr(tmp, "autofs")) {
    1159             log_to_screen
    1160                 (_("Your CD-ROM is mounted via autofs. I therefore cannot tell"));
    1161             log_to_screen
    1162                 (_("if a CD actually is inserted. If a CD is inserted, please"));
    1163             log_to_screen(_("eject it. Thank you."));
    1164             log_it
    1165                 ("Ignoring autofs CD-ROM 'mount' since we hope nothing's in it.");
    1166         } else
    1167             if (run_program_and_log_output("uname -a | grep Knoppix", 5)) {
    1168             retval++;
    1169             fatal_error
    1170                 ("Your CD-ROM drive is mounted. Please unmount it.");
    1171         }
    1172     }
    1173 #ifndef __FreeBSD__
    1174     if (!does_file_exist("/etc/modules.conf")) {
    1175         if (does_file_exist("/etc/conf.modules")) {
    1176             log_it("Linking /etc/modules.conf to /etc/conf.modules");
    1177             run_program_and_log_output
    1178                 ("ln -sf /etc/conf.modules /etc/modules.conf", 5);
    1179         } else if (does_file_exist("/etc/modprobe.d")) {
    1180             log_it
    1181                 ("Directory /etc/modprobe.d found. mindi will use its contents.");
    1182         } else if (does_file_exist("/etc/modprobe.conf")) {
    1183             log_it("Linking /etc/modules.conf to /etc/modprobe.conf");
    1184             run_program_and_log_output
    1185                 ("ln -sf /etc/modprobe.conf /etc/modules.conf", 5);
    1186         } else {
    1187             retval++;
    1188             log_to_screen
    1189                 (_("Please find out what happened to /etc/modules.conf"));
    1190         }
    1191     }
    1192 #endif
    1193 
    1194     run_program_and_log_output("cat /etc/fstab", 5);
    1195 #ifdef __FreeBSD__
    1196     run_program_and_log_output("vinum printconfig", 5);
    1197 #else
    1198     run_program_and_log_output("cat /etc/raidtab", 5);
    1199 #endif
    1200 
    1201     if (run_program_and_log_output("mindi -V", 1)) {
    1202         log_to_screen(_("Could not ascertain mindi's version number."));
    1203         log_to_screen
    1204             (_("You have not installed Mondo and/or Mindi properly."));
    1205         log_to_screen(_("Please uninstall and reinstall them both."));
    1206         fatal_error("Please reinstall Mondo and Mindi.");
    1207     }
    1208     if (run_program_and_log_output
    1209         ("mindi --makemountlist /tmp/mountlist.txt.test", 5)) {
    1210         log_to_screen
    1211             (_("Mindi --makemountlist /tmp/mountlist.txt.test failed for some reason."));
    1212         log_to_screen
    1213             (_("Please run that command by hand and examine /var/log/mindi.log"));
    1214         log_to_screen
    1215             (_("for more information. Perhaps your /etc/fstab file is insane."));
    1216         log_to_screen
    1217             (_("Perhaps Mindi's MakeMountlist() subroutine has a bug. We'll see."));
    1218         retval++;
    1219     }
    1220 
    1221     if (!run_program_and_log_output("parted2fdisk -l | grep -i raid", 1)
    1222         && !does_file_exist("/etc/raidtab")) {
    1223         log_to_screen
    1224             (_("You have RAID partitions but no /etc/raidtab - creating one from /proc/mdstat"));
    1225         create_raidtab_from_mdstat("/etc/raidtab", "/proc/mdstat");
    1226     }
    1227 
    1228     if (retval) {
    1229         mvaddstr_and_log_it(g_currentY++, 74, _("Failed."));
    1230     } else {
    1231         mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
    1232     }
    1233     return (retval);
    1234 }
    1235 
    1236 /**
    1237  * Retrieve the line containing @p label from the config file.
    1238  * @param config_file The file to read from, usually @c /tmp/mondo-restore.cfg.
    1239  * @param label What to read from the file.
    1240  * @param value Where to put it.
    1241  * @return 0 for success, 1 for failure.
    1242  */
    1243 int read_cfg_var(char *config_file, char *label, char *value)
    1244 {
    1245     /*@ buffer ****************************************************** */
    1246     char command[MAX_STR_LEN * 2];
    1247     char tmp[MAX_STR_LEN];
    1248 
    1249     /*@ end vars *************************************************** */
    1250 
    1251     assert_string_is_neither_NULL_nor_zerolength(config_file);
    1252     assert_string_is_neither_NULL_nor_zerolength(label);
    1253     if (!does_file_exist(config_file)) {
    1254         sprintf(tmp, "(read_cfg_var) Cannot find %s config file",
    1255                 config_file);
    1256         log_to_screen(tmp);
    1257         value[0] = '\0';
    1258         return (1);
    1259     } else if (strstr(value, "/dev/") && strstr(value, "t0")
    1260                && !strcmp(label, "media-dev")) {
    1261         log_msg(2, "FYI, I shan't read new value for %s - already got %s",
    1262                 label, value);
    1263         return (0);
    1264     } else {
    1265         sprintf(command, "grep '%s .*' %s| cut -d' ' -f2,3,4,5",
    1266                 label, config_file);
    1267         strcpy(value, call_program_and_get_last_line_of_output(command));
    1268         if (strlen(value) == 0) {
    1269             return (1);
    1270         } else {
    1271             return (0);
    1272         }
    1273     }
    1274 }
    1275 
    1276 
    1277 
    1278 /**
    1279  * Remount @c supermount if it was unmounted earlier.
    1280  */
    1281 void remount_supermounts_if_necessary()
    1282 {
    1283     if (g_remount_cdrom_at_end) {
    1284         run_program_and_log_output("mount " MNT_CDROM, FALSE);
    1285     }
    1286     if (g_remount_floppy_at_end) {
    1287         run_program_and_log_output("mount " MNT_FLOPPY, FALSE);
    1288     }
    1289 }
    1290 
    1291 /**
    1292  * Unmount @c supermount if it's mounted.
    1293  */
    1294 void unmount_supermounts_if_necessary()
    1295 {
    1296     if (run_program_and_log_output
    1297         ("mount | grep cdrom | grep super", FALSE) == 0) {
    1298         g_remount_cdrom_at_end = TRUE;
    1299         run_program_and_log_output("umount " MNT_CDROM, FALSE);
    1300     }
    1301     if (run_program_and_log_output
    1302         ("mount | grep floppy | grep super", FALSE) == 0) {
    1303         g_remount_floppy_at_end = TRUE;
    1304         run_program_and_log_output("umount " MNT_FLOPPY, FALSE);
    1305     }
    1306 }
    1307 
    1308 /**
    1309  * Whether we had to stop autofs (if so, restart it at end).
    1310  */
    1311 bool g_autofs_stopped = FALSE;
    1312 
    1313 /**
    1314  * Path to the autofs initscript ("" if none exists).
    1315  */
    1316 char g_autofs_exe[MAX_STR_LEN];
    1317 
    1318 /**
    1319  * Autofs initscript in Xandros Linux distribution.
    1320  */
    1321 #define XANDROS_AUTOFS_FNAME "/etc/init.d/xandros-autofs"
    1322 
    1323 /**
    1324  * Autofs initscript in most Linux distributions.
    1325  */
    1326 #define STOCK_AUTOFS_FNAME "/etc/rc.d/init.d/autofs"
    1327 
    1328 /**
    1329  * If autofs is mounted, stop it (restart at end).
    1330  */
    1331 void stop_autofs_if_necessary()
    1332 {
    1333     char tmp[MAX_STR_LEN];
    1334 
    1335     g_autofs_exe[0] = '\0';
    1336     if (does_file_exist(XANDROS_AUTOFS_FNAME)) {
    1337         strcpy(g_autofs_exe, XANDROS_AUTOFS_FNAME);
    1338     } else if (does_file_exist(STOCK_AUTOFS_FNAME)) {
    1339         strcpy(g_autofs_exe, STOCK_AUTOFS_FNAME);
    1340     }
    1341 
    1342     if (!g_autofs_exe[0]) {
    1343         log_msg(3, "No autofs detected.");
    1344     } else {
    1345         log_msg(3, "%s --- autofs detected", g_autofs_exe);
    1346 // FIXME -- only disable it if it's running ---  sprintf(tmp, "%s status", autofs_exe);
    1347         sprintf(tmp, "%s stop", g_autofs_exe);
    1348         if (run_program_and_log_output(tmp, 2)) {
    1349             log_it("Failed to stop autofs - I assume it wasn't running");
    1350         } else {
    1351             g_autofs_stopped = TRUE;
    1352             log_it("Stopped autofs OK");
    1353         }
    1354     }
    1355 }
    1356 
    1357 /**
    1358  * If autofs was stopped earlier, restart it.
    1359  */
    1360 void restart_autofs_if_necessary()
    1361 {
    1362     char tmp[MAX_STR_LEN];
    1363 
    1364     if (!g_autofs_stopped || !g_autofs_exe[0]) {
    1365         log_msg(3, "No autofs detected.");
    1366         return;
    1367     }
    1368     sprintf(tmp, "%s start", g_autofs_exe);
    1369     if (run_program_and_log_output(tmp, 2)) {
    1370         log_it("Failed to start autofs");
    1371     } else {
    1372         g_autofs_stopped = FALSE;
    1373         log_it("Started autofs OK");
    1374     }
    1375 }
    1376 
    1377 
    1378 /**
    1379  * If this is a distribution like Gentoo that doesn't keep /boot mounted, mount it.
    1380  */
    1381 void mount_boot_if_necessary()
    1382 {
    1383     char tmp[MAX_STR_LEN];
    1384     char command[MAX_STR_LEN];
    1385 
    1386     log_msg(1, "Started sub");
    1387     log_msg(4, "About to set g_boot_mountpt[0] to '\\0'");
    1388     g_boot_mountpt[0] = '\0';
    1389     log_msg(4, "Done. Great. Seeting command to something");
    1390     strcpy(command,
    1391            "grep -v \":\" /etc/fstab | grep -vx \"#.*\" | grep -w \"/boot\" | tr -s ' ' '\t' | cut -f1 | head -n1");
    1392     log_msg(4, "Cool. Command = '%s'", command);
    1393     strcpy(tmp, call_program_and_get_last_line_of_output(command));
    1394     log_msg(4, "tmp = '%s'", tmp);
    1395     if (tmp[0]) {
    1396         log_it("/boot is at %s according to /etc/fstab", tmp);
    1397         if (strstr(tmp, "LABEL=")) {
    1398             if (!run_program_and_log_output("mount /boot", 5)) {
    1399                 strcpy(g_boot_mountpt, "/boot");
    1400                 log_msg(1, "Mounted /boot");
    1401             } else {
    1402                 log_it("...ignored cos it's a label :-)");
    1403             }
    1404         } else {
    1405             sprintf(command, "mount | grep -w \"%s\"", tmp);
    1406             log_msg(3, "command = %s", command);
    1407             if (run_program_and_log_output(command, 5)) {
    1408                 strcpy(g_boot_mountpt, tmp);
    1409                 sprintf(tmp,
    1410                         "%s (your /boot partition) is not mounted. I'll mount it before backing up",
    1411                         g_boot_mountpt);
    1412                 log_it(tmp);
    1413                 sprintf(tmp, "mount %s", g_boot_mountpt);
    1414                 if (run_program_and_log_output(tmp, 5)) {
    1415                     g_boot_mountpt[0] = '\0';
    1416                     log_msg(1, "Plan B");
    1417                     if (!run_program_and_log_output("mount /boot", 5)) {
    1418                         strcpy(g_boot_mountpt, "/boot");
    1419                         log_msg(1, "Plan B worked");
    1420                     } else {
    1421                         log_msg(1,
    1422                                 "Plan B failed. Unable to mount /boot for backup purposes. This probably means /boot is mounted already, or doesn't have its own partition.");
    1423                     }
    1424                 }
    1425             }
    1426         }
    1427     }
    1428     log_msg(1, "Ended sub");
    1429 }
    1430 
    1431 
    1432 /**
    1433  * If we mounted /boot earlier, unmount it.
    1434  */
    1435 void unmount_boot_if_necessary()
    1436 {
    1437     char tmp[MAX_STR_LEN];
    1438 
    1439     log_msg(3, "starting");
    1440     if (g_boot_mountpt[0]) {
    1441         sprintf(tmp, "umount %s", g_boot_mountpt);
    1442         if (run_program_and_log_output(tmp, 5)) {
    1443             log_it("WARNING - unable to unmount /boot");
    1444         }
    1445     }
    1446     log_msg(3, "leaving");
    1447 }
    1448 
    1449 
    1450 
    1451 /**
    1452  * Write a line to a configuration file. Writes a line of the form,
    1453  * @c label @c value.
    1454  * @param config_file The file to write to. Usually @c mondo-restore.cfg.
    1455  * @param label What to call this bit of data you're writing.
    1456  * @param value The bit of data you're writing.
    1457  * @return 0 for success, 1 for failure.
    1458  */
    1459 int write_cfg_var(char *config_file, char *label, char *value)
    1460 {
    1461     /*@ buffers ***************************************************** */
    1462     char command[MAX_STR_LEN * 2];
    1463     char tempfile[MAX_STR_LEN];
    1464     char tmp[MAX_STR_LEN];
    1465 
    1466 
    1467     /*@ end vars *************************************************** */
    1468     assert_string_is_neither_NULL_nor_zerolength(config_file);
    1469     assert_string_is_neither_NULL_nor_zerolength(label);
    1470     assert(value != NULL);
    1471     if (!does_file_exist(config_file)) {
    1472         sprintf(tmp, "(write_cfg_file) Cannot find %s config file",
    1473                 config_file);
    1474         log_to_screen(tmp);
    1475         return (1);
    1476     }
    1477     strcpy(tempfile,
    1478            call_program_and_get_last_line_of_output
    1479            ("mktemp -q /tmp/mojo-jojo.blah.XXXXXX"));
    1480     if (does_file_exist(config_file)) {
    1481         sprintf(command, "grep -vx '%s .*' %s > %s",
    1482                 label, config_file, tempfile);
    1483         paranoid_system(command);
    1484     }
    1485     sprintf(command, "echo \"%s %s\" >> %s", label, value, tempfile);
    1486     paranoid_system(command);
    1487     sprintf(command, "mv -f %s %s", tempfile, config_file);
    1488     paranoid_system(command);
    1489     unlink(tempfile);
    1490     return (0);
    1491 }
    1492 
    1493 
    149418/**
    149519 * The standard log_debug_msg() (log_msg() also due to a macro). Writes some describing
    149620 * information to the logfile.
    149721 */
    1498 void standard_log_debug_msg(int debug_level, const char *szFile,
     22void log_debug_msg(int debug_level, const char *szFile,
    149923                            const char *szFunction, int nLine,
    150024                            const char *fmt, ...)
     
    150327    int i;
    150428    static int depth = 0;
    1505     char *tmp;
    150629    FILE *fout;
    150730
     
    151134    }
    151235    depth++;
    1513 
    1514     malloc_string(tmp);
    151536
    151637    if (debug_level <= g_loglevel) {
     
    154667    }
    154768    depth--;
    1548     paranoid_free(tmp);
    154969}
    1550 
    1551 /**
    1552  * Function pointer to the @c log_debug_msg function to use. Points to standard_log_debug_msg() by default.
    1553  */
    1554 void (*log_debug_msg) (int, const char *, const char *, int, const char *,
    1555                        ...) = standard_log_debug_msg;
    1556 
    1557 
    1558 /**
    1559  * If @p y, malloc @p x, else free @p x.
    1560  * @bug This function seems orphaned. Please remove.
    1561  */
    1562 #define do_alloc_or_free_depending(x,y) { if(y) {x=malloc(MAX_STR_LEN);} else {paranoid_free(x);} }
    1563 
    1564 /**
    1565  * Allocate or free important globals, depending on @p mal.
    1566  * @param mal If TRUE, malloc; if FALSE, free.
    1567  */
    1568 void do_libmondo_global_strings_thing(int mal)
    1569 {
    1570     if (mal) {
    1571         iamhere("Malloc'ing globals");
    1572         malloc_string(g_boot_mountpt);
    1573         malloc_string(g_mondo_home);
    1574         malloc_string(g_tmpfs_mountpt);
    1575         malloc_string(g_erase_tmpdir_and_scratchdir);
    1576         malloc_string(g_serial_string);
    1577         malloc_string(g_magicdev_command);
    1578     } else {
    1579         iamhere("Freeing globals");
    1580         paranoid_free(g_boot_mountpt);
    1581         paranoid_free(g_mondo_home);
    1582         paranoid_free(g_tmpfs_mountpt);
    1583         paranoid_free(g_erase_tmpdir_and_scratchdir);
    1584         paranoid_free(g_serial_string);
    1585         paranoid_free(g_magicdev_command);
    1586     }
    1587 
    1588     /*
    1589        char**list_of_arrays[] = {
    1590        &g_boot_mountpt,
    1591        &g_mondo_home,
    1592        &g_tmpfs_mountpt,
    1593        &g_erase_tmpdir_and_scratchdir,
    1594        &g_serial_string,
    1595        &g_magicdev_command,
    1596        NULL};
    1597 
    1598        char**ppcurr;
    1599        int i;
    1600 
    1601        for(i=0;list_of_arrays[i];i++)
    1602        {
    1603        log_msg(5, "Allocating %d", i);
    1604        ppcurr = list_of_arrays[i];
    1605        if (mal)
    1606        { *ppcurr = malloc(MAX_STR_LEN); }
    1607        else
    1608        {
    1609        if (*ppcurr)
    1610        {
    1611        free(*ppcurr);
    1612        }
    1613        }
    1614        }
    1615        log_msg(5, "Returning");
    1616      */
    1617 }
    1618 
    1619 /**
    1620  * Allocate important globals.
    1621  * @see do_libmondo_global_strings_thing
    1622  */
    1623 void malloc_libmondo_global_strings(void)
    1624 {
    1625     do_libmondo_global_strings_thing(1);
    1626 }
    1627 
    1628 /**
    1629  * Free important globals.
    1630  * @see do_libmondo_global_strings_thing
    1631  */
    1632 void free_libmondo_global_strings(void)
    1633 {
    1634     do_libmondo_global_strings_thing(0);
    1635 }
    1636 
    1637 
    1638 
    1639 /**
    1640  * Stop @c magicdev if it's running.
    1641  * The command used to start it is saved in @p g_magicdev_command.
    1642  */
    1643 void stop_magicdev_if_necessary()
    1644 {
    1645     strcpy(g_magicdev_command,
    1646            call_program_and_get_last_line_of_output
    1647            ("ps ax | grep -w magicdev | grep -v grep | tr -s '\t' ' '| cut -d' ' -f6-99"));
    1648     if (g_magicdev_command[0]) {
    1649         log_msg(1, "g_magicdev_command = '%s'", g_magicdev_command);
    1650         paranoid_system("killall magicdev");
    1651     }
    1652 }
    1653 
    1654 
    1655 /**
    1656  * Restart magicdev if it was stopped.
    1657  */
    1658 void restart_magicdev_if_necessary()
    1659 {
    1660     char *tmp;
    1661 
    1662     malloc_string(tmp);
    1663     if (g_magicdev_command && g_magicdev_command[0]) {
    1664         sprintf(tmp, "%s &", g_magicdev_command);
    1665         paranoid_system(tmp);
    1666     }
    1667     paranoid_free(tmp);
    1668 }
    1669 
    1670 /* @} - end of utilityGroup */
  • branches/stable/mondo/mondo/mondoarchive/Makefile.am

    r423 r532  
    22## Process with Automake to generate Makefile.in
    33##
     4AM_CPPFLAGS = -DMONDO_CONF_DIR=\"$(sysconfdir)\"
    45
    56## Headers
  • branches/stable/mondo/mondo/test/mktest

    r531 r532  
    1 gcc -O2 -I../common test-conf.c ../common/libmondo-conf.c ../common/libmondo-msg.c
     1#!/bin/bash
     2#
     3# $Id$
     4#
     5# test script for library functions
     6#
     7    gcc -O2 -I../common test-conf.c ../common/libmondo-conf.c ../common/libmondo-msg.c -o test-conf
     8for f in "test-conf"; do
     9    chmod 755 $f
     10    ./$f > /tmp/$f.res
     11    diff -q $f.res /tmp/$f.res
     12    if [ $? -ne 0 ]; then
     13        echo "$f test KO !!"
     14    fi
     15done
  • branches/stable/tools/mkrpm

    r530 r532  
    8686        status=-1
    8787    fi
    88 fi
     88done
    8989if [ $status = 0 ]; then
    9090    echo "Installing RPMS as root ($pkg)"
Note: See TracChangeset for help on using the changeset viewer.