Ignore:
Timestamp:
Oct 7, 2005, 7:03:07 PM (14 years ago)
Author:
bcornec
Message:

some bugs corrected (size_t, & for getline, ...) + indent

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/mondo/mondo/common/libmondo-tools.c

    r30 r49  
    11/* libmondo-tools.c                                  misc tools
    2    $Id: libmondo-tools.c,v 1.14 2004/06/19 01:36:07 hugo Exp $
     2   $Id$
    33.
    44
     
    186186
    187187/*@unused@*/
    188 //static char cvsid[] = "$Id: libmondo-tools.c,v 1.14 2004/06/19 01:36:07 hugo Exp $";
     188//static char cvsid[] = "$Id$";
    189189
    190190extern int g_tape_buffer_size_MB;
     
    199199 * @{
    200200 */
    201 bool g_remount_cdrom_at_end, ///< TRUE if we unmounted the CD-ROM and should remount it when done with the backup.
    202     g_remount_floppy_at_end; ///< TRUE if we unmounted the floppy and should remount it when done with the backup.
    203 bool g_cd_recovery; ///< TRUE if we're making an "autonuke" backup.
     201bool g_remount_cdrom_at_end,    ///< TRUE if we unmounted the CD-ROM and should remount it when done with the backup.
     202 g_remount_floppy_at_end;       ///< TRUE if we unmounted the floppy and should remount it when done with the backup.
     203bool g_cd_recovery;             ///< TRUE if we're making an "autonuke" backup.
    204204double g_kernel_version;
    205205
     
    207207 * The place where /boot is mounted.
    208208 */
    209 char *g_boot_mountpt=NULL;
     209char *g_boot_mountpt = NULL;
    210210
    211211/**
    212212 * The location of Mondo's home directory.
    213213 */
    214 char *g_mondo_home=NULL;
     214char *g_mondo_home = NULL;
    215215
    216216/**
    217217 * The serial string (used to differentiate between backups) of the current backup.
    218218 */
    219 char *g_serial_string=NULL;
     219char *g_serial_string = NULL;
    220220
    221221/**
    222222 * The location where tmpfs is mounted, or "" if it's not mounted.
    223223 */
    224 char *g_tmpfs_mountpt=NULL;
    225 char *g_magicdev_command=NULL;
     224char *g_tmpfs_mountpt = NULL;
     225char *g_magicdev_command = NULL;
    226226
    227227/**
    228228 * The default maximum level to log messages at or below.
    229229 */
    230 int g_loglevel=DEFAULT_DEBUG_LEVEL;
     230int g_loglevel = DEFAULT_DEBUG_LEVEL;
    231231
    232232/* @} - end of globalGroup */
     
    255255 * @param exp The expression that failed (as a string).
    256256 */
    257 void _mondo_assert_fail (const char *file,
    258              const char *function,
    259              int         line,
    260              const char *exp)
    261 {
    262     static int ignoring_assertions = 0;
    263     bool is_valid = TRUE;
    264 
    265     log_it ("ASSERTION FAILED: `%s' at %s:%d in %s", exp, file, line, function);
    266     if (ignoring_assertions) {
    267     log_it ("Well, the user doesn't care...");
    268     return;
    269     }
    270 
     257void _mondo_assert_fail(const char *file,
     258                        const char *function, int line, const char *exp)
     259{
     260    static int ignoring_assertions = 0;
     261    bool is_valid = TRUE;
     262
     263    log_it("ASSERTION FAILED: `%s' at %s:%d in %s", exp, file, line,
     264           function);
     265    if (ignoring_assertions) {
     266        log_it("Well, the user doesn't care...");
     267        return;
     268    }
    271269#ifndef _XWIN
    272     if (!g_text_mode)
    273     newtSuspend();
    274 #endif
    275     printf ("ASSERTION FAILED: `%s'\n", exp);
    276     printf ("\tat %s:%d in %s\n\n", file, line, function);
    277     printf ("(I)gnore, ignore (A)ll, (D)ebug, a(B)ort, or (E)xit? ");
    278     do {
    279     is_valid = TRUE;
    280     switch (toupper (getchar())) {
    281     case 'A': // ignore (A)ll
    282         ignoring_assertions = 1;
    283         break;
    284     case 'B': // a(B)ort
    285         signal (SIGABRT, SIG_DFL); /* prevent SIGABRT handler from running */
    286         raise (SIGABRT);
    287         break;          /* "can't get here" */
    288     case 'D': // (D)ebug, aka asm("int 3")
     270    if (!g_text_mode)
     271        newtSuspend();
     272#endif
     273    printf("ASSERTION FAILED: `%s'\n", exp);
     274    printf("\tat %s:%d in %s\n\n", file, line, function);
     275    printf("(I)gnore, ignore (A)ll, (D)ebug, a(B)ort, or (E)xit? ");
     276    do {
     277        is_valid = TRUE;
     278        switch (toupper(getchar())) {
     279        case 'A':               // ignore (A)ll
     280            ignoring_assertions = 1;
     281            break;
     282        case 'B':               // a(B)ort
     283            signal(SIGABRT, SIG_DFL);   /* prevent SIGABRT handler from running */
     284            raise(SIGABRT);
     285            break;              /* "can't get here" */
     286        case 'D':               // (D)ebug, aka asm("int 3")
    289287#ifdef __IA32__
    290         __asm__ __volatile__ ("int $3"); // break to debugger
    291 #endif
    292         break;
    293     case 'E': // (E)xit
    294         fatal_error ("Failed assertion -- see above for details");
    295         break;          /* "can't get here" */
    296     case 'I': // (I)gnore
    297         break;
    298     /* These next two work as follows:
    299        the `default' catches the user's invalid choice and says so;
    300        the '\n' catches the newline on the end and prints the prompt again.
    301     */
    302     case '\n':
    303         printf ("(I)gnore, ignore (A)ll, (D)ebug, a(B)ort, or (E)xit? ");
    304         break;
    305     default:
    306         is_valid = FALSE;
    307         printf ("Invalid choice.\n");
    308         break;
    309     }
    310     } while (!is_valid);
    311 
    312     if (ignoring_assertions) {
    313     log_it ("Ignoring ALL assertions from now on.");
    314     } else {
    315     log_it ("Ignoring assertion: %s", exp);
    316     }
    317 
    318     getchar(); // skip \n
     288            __asm__ __volatile__("int $3"); // break to debugger
     289#endif
     290            break;
     291        case 'E':               // (E)xit
     292            fatal_error("Failed assertion -- see above for details");
     293            break;              /* "can't get here" */
     294        case 'I':               // (I)gnore
     295            break;
     296            /* These next two work as follows:
     297               the `default' catches the user's invalid choice and says so;
     298               the '\n' catches the newline on the end and prints the prompt again.
     299             */
     300        case '\n':
     301            printf
     302                ("(I)gnore, ignore (A)ll, (D)ebug, a(B)ort, or (E)xit? ");
     303            break;
     304        default:
     305            is_valid = FALSE;
     306            printf("Invalid choice.\n");
     307            break;
     308        }
     309    } while (!is_valid);
     310
     311    if (ignoring_assertions) {
     312        log_it("Ignoring ALL assertions from now on.");
     313    } else {
     314        log_it("Ignoring assertion: %s", exp);
     315    }
     316
     317    getchar();                  // skip \n
    319318
    320319#ifndef _XWIN
    321     if (!g_text_mode)
    322     newtResume();
     320    if (!g_text_mode)
     321        newtResume();
    323322#endif
    324323}
     
    330329void clean_up_KDE_desktop_if_necessary(void)
    331330{
    332   char *tmp;
    333 
    334   malloc_string(tmp);
    335   strcpy(tmp, "for i in `find /root /home -type d -name Desktop -maxdepth 2`; do \
     331    char *tmp;
     332
     333    malloc_string(tmp);
     334    strcpy(tmp,
     335           "for i in `find /root /home -type d -name Desktop -maxdepth 2`; do \
    336336file=$i/.directory; if [ -f \"$file\" ] ; then mv -f $file $file.old ; \
    337337cat $file.old | awk '{if (index($0, \"rootimagesmindi\")) { while (length($0)>2) { getline;} ; } \
    338338else { print $0;};}' > $file ; fi ; done");
    339   run_program_and_log_output(tmp, 5);
    340   paranoid_free(tmp);
     339    run_program_and_log_output(tmp, 5);
     340    paranoid_free(tmp);
    341341}
    342342
     
    351351int find_and_store_mondoarchives_home(char *home_sz)
    352352{
    353   assert(home_sz!=NULL);
    354   strcpy (home_sz,
    355       call_program_and_get_last_line_of_output
    356       ("find /usr/lib/ /usr/local/ /usr/share/ /usr/local/share/ /opt/ /ramdisk/usr/share/ -type d -maxdepth 2 -name include -prune -o -type d -maxdepth 2 -path '*/mondo/restore-scripts' -printf '%h\n' 2> /dev/null"));
    357 
    358   if (home_sz[0] == '\0')
    359     {
    360       strcpy (home_sz,
    361           call_program_and_get_last_line_of_output
    362           ("find /usr -type d -path '*/mondo/restore-scripts' -follow -maxdepth 3 -printf '%h\n' 2> /dev/null"));
    363     }
    364   if (home_sz[0] == '\0')
    365     {
    366       return(1);
    367     }
    368   else
    369     {
    370       return(0);
    371     }
     353    assert(home_sz != NULL);
     354    strcpy(home_sz,
     355           call_program_and_get_last_line_of_output
     356           ("find /usr/lib/ /usr/local/ /usr/share/ /usr/local/share/ /opt/ /ramdisk/usr/share/ -type d -maxdepth 2 -name include -prune -o -type d -maxdepth 2 -path '*/mondo/restore-scripts' -printf '%h\n' 2> /dev/null"));
     357
     358    if (home_sz[0] == '\0') {
     359        strcpy(home_sz,
     360               call_program_and_get_last_line_of_output
     361               ("find /usr -type d -path '*/mondo/restore-scripts' -follow -maxdepth 3 -printf '%h\n' 2> /dev/null"));
     362    }
     363    if (home_sz[0] == '\0') {
     364        return (1);
     365    } else {
     366        return (0);
     367    }
    372368}
    373369
     
    376372{
    377373#ifdef __IA32__
    378     return("i386");
     374    return ("i386");
    379375#endif
    380376#ifdef __IA64__
    381     return("ia64");
    382 #endif
    383     return("unknown");
     377    return ("ia64");
     378#endif
     379    return ("unknown");
    384380}
    385381
     
    388384double get_kernel_version()
    389385{
    390   char *p, tmp[200];
    391   double d;
     386    char *p, tmp[200];
     387    double d;
    392388#ifdef __FreeBSD__
    393   // JOSH - FIXME :)
    394   d = 5.2; // :-)
     389    // JOSH - FIXME :)
     390    d = 5.2;                    // :-)
    395391#else
    396   strcpy(tmp, call_program_and_get_last_line_of_output("uname -r"));
    397   p = strchr(tmp, '.');
    398   if (p)
    399     {
    400       p = strchr(++p, '.');
    401       if (p)
    402         {
    403       while(*p) { *p=*(p+1); p++; }
    404         }
    405     }
     392    strcpy(tmp, call_program_and_get_last_line_of_output("uname -r"));
     393    p = strchr(tmp, '.');
     394    if (p) {
     395        p = strchr(++p, '.');
     396        if (p) {
     397            while (*p) {
     398                *p = *(p + 1);
     399                p++;
     400            }
     401        }
     402    }
    406403//  log_msg(1, "tmp = '%s'", tmp);
    407   d = atof(tmp);
    408 #endif
    409   log_msg(1, "g_kernel_version = %f", d);
    410   return(d);
     404    d = atof(tmp);
     405#endif
     406    log_msg(1, "g_kernel_version = %f", d);
     407    return (d);
    411408}
    412409
     
    419416 * @return number of seconds since the epoch.
    420417 */
    421 long
    422 get_time ()
     418long get_time()
    423419{
    424420
    425421#if 0
    426422
    427     /*@ pointers *****************************************************/
    428   FILE *fin;
    429 
    430     /*@ buffers ******************************************************/
    431   char incoming[MAX_STR_LEN];
    432 
    433     /*@ end vars *****************************************************/
    434 
    435   if (!(fin = popen ("date +%s", "r"))) { log_OS_error("Cannot popen date"); return(0); }
    436   fgets (incoming, MAX_STR_LEN - 1, fin);
    437   paranoid_pclose (fin);
    438   return (atol (incoming));
     423    /*@ pointers **************************************************** */
     424    FILE *fin;
     425
     426    /*@ buffers ***************************************************** */
     427    char incoming[MAX_STR_LEN];
     428
     429    /*@ end vars **************************************************** */
     430
     431    if (!(fin = popen("date +%s", "r"))) {
     432        log_OS_error("Cannot popen date");
     433        return (0);
     434    }
     435    fgets(incoming, MAX_STR_LEN - 1, fin);
     436    paranoid_pclose(fin);
     437    return (atol(incoming));
    439438#else
    440   return (long) time ((void *) 0);
     439    return (long) time((void *) 0);
    441440#endif
    442441}
     
    456455 */
    457456#ifdef __FreeBSD__
    458 void initialize_raidrec (struct vinum_volume *raidrec)
    459 {
    460   int i, j;
    461   raidrec->volname[0] = '\0';
    462   raidrec->plexes = 0;
    463   for (i = 0; i < 9; ++i) {
    464     raidrec->plex[i].raidlevel = -1;
    465     raidrec->plex[i].stripesize = 0;
    466     raidrec->plex[i].subdisks = 0;
    467     for (j = 0; j < 9; ++j) {
    468        strcpy (raidrec->plex[i].sd[j].which_device, "");
    469     }
    470   }
     457void initialize_raidrec(struct vinum_volume *raidrec)
     458{
     459    int i, j;
     460    raidrec->volname[0] = '\0';
     461    raidrec->plexes = 0;
     462    for (i = 0; i < 9; ++i) {
     463        raidrec->plex[i].raidlevel = -1;
     464        raidrec->plex[i].stripesize = 0;
     465        raidrec->plex[i].subdisks = 0;
     466        for (j = 0; j < 9; ++j) {
     467            strcpy(raidrec->plex[i].sd[j].which_device, "");
     468        }
     469    }
    471470}
    472471#else
    473 void initialize_raidrec (struct raid_device_record *raidrec)
    474 {
    475   assert(raidrec!=NULL);
    476   raidrec->raid_device[0] = '\0';
    477   raidrec->raid_level = 0;
    478   raidrec->chunk_size = 4;
    479   raidrec->persistent_superblock = 1;
    480   raidrec->data_disks.entries = 0;
    481   raidrec->spare_disks.entries = 0;
    482   raidrec->parity_disks.entries = 0;
    483   raidrec->failed_disks.entries = 0;
    484   raidrec->additional_vars.entries = 0;
     472void initialize_raidrec(struct raid_device_record *raidrec)
     473{
     474    assert(raidrec != NULL);
     475    raidrec->raid_device[0] = '\0';
     476    raidrec->raid_level = 0;
     477    raidrec->chunk_size = 4;
     478    raidrec->persistent_superblock = 1;
     479    raidrec->data_disks.entries = 0;
     480    raidrec->spare_disks.entries = 0;
     481    raidrec->parity_disks.entries = 0;
     482    raidrec->failed_disks.entries = 0;
     483    raidrec->additional_vars.entries = 0;
    485484}
    486485#endif
     
    497496{
    498497#ifdef __FreeBSD__
    499   system("kldstat | grep msdosfs || kldload msdosfs 2> /dev/null");
    500   system("kldstat | grep ext2fs  || kldload ext2fs 2> /dev/null");
     498    system("kldstat | grep msdosfs || kldload msdosfs 2> /dev/null");
     499    system("kldstat | grep ext2fs  || kldload ext2fs 2> /dev/null");
    501500#else
    502   system("modprobe dos &> /dev/null");
    503   system("modprobe fat &> /dev/null");
    504   system("modprobe vfat &> /dev/null");
    505   //  system("modprobe osst &> /dev/null");
     501    system("modprobe dos &> /dev/null");
     502    system("modprobe fat &> /dev/null");
     503    system("modprobe vfat &> /dev/null");
     504    //  system("modprobe osst &> /dev/null");
    506505#endif
    507506}
     
    512511 * @bug This function seems orphaned. Please remove.
    513512 */
    514 void
    515 log_trace (char *o)
    516 {
    517     /*@ pointers *****************************************************/
    518   FILE *fout;
    519 
    520     /*@ buffers ******************************************************/
    521   char output[MAX_STR_LEN];
    522 
    523     /*@ int    *******************************************************/
    524   int i;
    525 
    526     /*@ end vars ****************************************************/
    527 
    528   if (o[0] == '\0')
    529     {
    530       return;
    531     }
    532   strcpy (output, o);
    533   i = (int) strlen (output);
    534   if (i <= 0)
    535     {
    536       return;
    537     }
    538   if (output[i - 1] < 32)
    539     {
    540       output[i - 1] = '\0';
    541     }
    542   if (g_text_mode /* && !strstr(last_line_of_file(MONDO_LOGFILE),output) */ )
    543     {
    544       printf ("%s\n", output);
    545     }
    546 
    547   fout = fopen (MONDO_TRACEFILE, "a");
    548   if (fout)
    549     {
    550       fprintf (fout, "%s\n", output);
    551       paranoid_fclose (fout);
    552     }
    553   else
    554     {
    555       log_OS_error( "Cannot write to tracefile" );
    556     }
     513void log_trace(char *o)
     514{
     515    /*@ pointers **************************************************** */
     516    FILE *fout;
     517
     518    /*@ buffers ***************************************************** */
     519    char output[MAX_STR_LEN];
     520
     521    /*@ int    ****************************************************** */
     522    int i;
     523
     524    /*@ end vars *************************************************** */
     525
     526    if (o[0] == '\0') {
     527        return;
     528    }
     529    strcpy(output, o);
     530    i = (int) strlen(output);
     531    if (i <= 0) {
     532        return;
     533    }
     534    if (output[i - 1] < 32) {
     535        output[i - 1] = '\0';
     536    }
     537    if (g_text_mode
     538        /* && !strstr(last_line_of_file(MONDO_LOGFILE),output) */ ) {
     539        printf("%s\n", output);
     540    }
     541
     542    fout = fopen(MONDO_TRACEFILE, "a");
     543    if (fout) {
     544        fprintf(fout, "%s\n", output);
     545        paranoid_fclose(fout);
     546    } else {
     547        log_OS_error("Cannot write to tracefile");
     548    }
    557549}
    558550
     
    592584 * do not exist.
    593585 */
    594 int post_param_configuration (struct s_bkpinfo *bkpinfo)
    595 {
    596   char *extra_cdrom_params;
    597   char *mondo_mkisofs_sz;
    598   char *command;
    599   char *mtpt;
    600   char *hostname, *ip_address;
    601   int retval=0;
    602   long avm = 0;
    603   char *colon;
    604   char *cdr_exe;
    605   char *tmp;
    606   int rdsiz_MB;
    607       char *iso_dev;
    608       char *iso_mnt;
    609       char *iso_tmp;
    610       char *iso_path;
    611 
    612   assert(bkpinfo!=NULL);
    613   malloc_string(extra_cdrom_params);
    614   malloc_string(mondo_mkisofs_sz);
    615   malloc_string(command);
    616   malloc_string(mtpt);
    617   malloc_string(hostname);
    618   malloc_string(ip_address);
    619   malloc_string(cdr_exe);
    620   malloc_string(tmp);
    621       malloc_string(iso_dev);
    622       malloc_string(iso_mnt);
    623       malloc_string(iso_tmp);
    624       malloc_string(iso_path);
    625   bkpinfo->optimal_set_size = (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)?4:8) * 1024;
    626 
    627   log_msg(1, "Foo");
    628   if (bkpinfo->backup_media_type == tape)
    629     {
    630       log_msg(1, "Bar");
    631       sprintf(tmp, "mt -f %s status", bkpinfo->media_device);
    632       log_msg(1, "tmp = '%s'", tmp);
    633       if (run_program_and_log_output(tmp, 3))
    634         {
    635           fatal_error("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.");
    636     }
    637     }   
    638   make_hole_for_dir(bkpinfo->scratchdir);
    639   make_hole_for_dir(bkpinfo->tmpdir);
    640   if (bkpinfo->backup_media_type == iso)
    641       make_hole_for_dir(bkpinfo->isodir);
    642 
    643   run_program_and_log_output ("uname -a", 5);
    644   run_program_and_log_output ("cat /etc/*issue*", 5);
    645   sprintf(g_tmpfs_mountpt, "%s/tmpfs", bkpinfo->tmpdir);
    646   sprintf(command, "mkdir -p %s", g_tmpfs_mountpt);
    647   paranoid_system(command);
    648   rdsiz_MB = PPCFG_RAMDISK_SIZE + g_tape_buffer_size_MB;
     586int post_param_configuration(struct s_bkpinfo *bkpinfo)
     587{
     588    char *extra_cdrom_params;
     589    char *mondo_mkisofs_sz;
     590    char *command;
     591    char *mtpt;
     592    char *hostname, *ip_address;
     593    int retval = 0;
     594    long avm = 0;
     595    char *colon;
     596    char *cdr_exe;
     597    char *tmp;
     598    int rdsiz_MB;
     599    char *iso_dev;
     600    char *iso_mnt;
     601    char *iso_tmp;
     602    char *iso_path;
     603
     604    assert(bkpinfo != NULL);
     605    malloc_string(extra_cdrom_params);
     606    malloc_string(mondo_mkisofs_sz);
     607    malloc_string(command);
     608    malloc_string(mtpt);
     609    malloc_string(hostname);
     610    malloc_string(ip_address);
     611    malloc_string(cdr_exe);
     612    malloc_string(tmp);
     613    malloc_string(iso_dev);
     614    malloc_string(iso_mnt);
     615    malloc_string(iso_tmp);
     616    malloc_string(iso_path);
     617    bkpinfo->optimal_set_size =
     618        (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type) ? 4 : 8) *
     619        1024;
     620
     621    log_msg(1, "Foo");
     622    if (bkpinfo->backup_media_type == tape) {
     623        log_msg(1, "Bar");
     624        sprintf(tmp, "mt -f %s status", bkpinfo->media_device);
     625        log_msg(1, "tmp = '%s'", tmp);
     626        if (run_program_and_log_output(tmp, 3)) {
     627            fatal_error
     628                ("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.");
     629        }
     630    }
     631    make_hole_for_dir(bkpinfo->scratchdir);
     632    make_hole_for_dir(bkpinfo->tmpdir);
     633    if (bkpinfo->backup_media_type == iso)
     634        make_hole_for_dir(bkpinfo->isodir);
     635
     636    run_program_and_log_output("uname -a", 5);
     637    run_program_and_log_output("cat /etc/*issue*", 5);
     638    sprintf(g_tmpfs_mountpt, "%s/tmpfs", bkpinfo->tmpdir);
     639    sprintf(command, "mkdir -p %s", g_tmpfs_mountpt);
     640    paranoid_system(command);
     641    rdsiz_MB = PPCFG_RAMDISK_SIZE + g_tape_buffer_size_MB;
    649642#ifdef __FreeBSD__
    650   strcpy(tmp, call_program_and_get_last_line_of_output("vmstat | tail -1 | tr -s ' ' | cut -d' ' -f6"));
    651   avm += atol (tmp);
    652   strcpy(tmp, call_program_and_get_last_line_of_output("swapinfo | grep -v Device | tr -s ' ' | cut -d' ' -f4 | tr '\n' '+' | sed 's/+$//' | bc"));
    653   avm += atol (tmp);
    654   sprintf(command, "mdmfs -s %d%c md9 %s", rdsiz_MB, 'm', g_tmpfs_mountpt);
     643    strcpy(tmp,
     644           call_program_and_get_last_line_of_output
     645           ("vmstat | tail -1 | tr -s ' ' | cut -d' ' -f6"));
     646    avm += atol(tmp);
     647    strcpy(tmp,
     648           call_program_and_get_last_line_of_output
     649           ("swapinfo | grep -v Device | tr -s ' ' | cut -d' ' -f4 | tr '\n' '+' | sed 's/+$//' | bc"));
     650    avm += atol(tmp);
     651    sprintf(command, "mdmfs -s %d%c md9 %s", rdsiz_MB, 'm',
     652            g_tmpfs_mountpt);
    655653#else
    656   strcpy(tmp, call_program_and_get_last_line_of_output("free | grep \":\" | tr -s ' ' '\t' | cut -f2 | head -n1"));
    657   avm += atol (tmp);
    658   sprintf(command, "mount /dev/shm -t tmpfs %s -o size=%d%c", g_tmpfs_mountpt, rdsiz_MB, 'm');
    659   run_program_and_log_output ("cat /proc/cpuinfo", 5);
    660   run_program_and_log_output ("rpm -q newt newt-devel slang slang-devel ncurses ncurses-devel gcc", 5);
    661 #endif
    662   if (avm/1024 > rdsiz_MB*3)
    663     {
    664       if (run_program_and_log_output(command, 5))
     654    strcpy(tmp,
     655           call_program_and_get_last_line_of_output
     656           ("free | grep \":\" | tr -s ' ' '\t' | cut -f2 | head -n1"));
     657    avm += atol(tmp);
     658    sprintf(command, "mount /dev/shm -t tmpfs %s -o size=%d%c",
     659            g_tmpfs_mountpt, rdsiz_MB, 'm');
     660    run_program_and_log_output("cat /proc/cpuinfo", 5);
     661    run_program_and_log_output
     662        ("rpm -q newt newt-devel slang slang-devel ncurses ncurses-devel gcc",
     663         5);
     664#endif
     665    if (avm / 1024 > rdsiz_MB * 3) {
     666        if (run_program_and_log_output(command, 5)) {
     667            g_tmpfs_mountpt[0] = '\0';
     668            log_it("Failed to mount tmpfs");
     669        } else {
     670            log_it("Tmpfs mounted OK - %d MB", rdsiz_MB);
     671        }
     672    } else {
     673        g_tmpfs_mountpt[0] = '\0';
     674        log_it("It doesn't seem you have enough swap to use tmpfs. Fine.");
     675    }
     676
     677    if (bkpinfo->use_lzo) {
     678        strcpy(bkpinfo->zip_exe, "lzop");
     679        strcpy(bkpinfo->zip_suffix, "lzo");
     680    } else if (bkpinfo->compression_level != 0) {
     681        strcpy(bkpinfo->zip_exe, "bzip2");
     682        strcpy(bkpinfo->zip_suffix, "bz2");
     683    } else {
     684        bkpinfo->zip_exe[0] = bkpinfo->zip_suffix[0] = '\0';
     685    }
     686
     687// DVD
     688
     689    if (bkpinfo->backup_media_type == dvd) {
     690        extra_cdrom_params[0] = '\0';
     691        mondo_mkisofs_sz[0] = '\0';
     692        if (find_home_of_exe("growisofs")) {
     693            strcpy(cdr_exe, "growisofs");
     694        }                       // unlikely to be used
     695        else {
     696            fatal_error("Please install growisofs.");
     697        }
     698        if (bkpinfo->nonbootable_backup) {
     699            strcat(mondo_mkisofs_sz, MONDO_GROWISOFS_NONBOOT);
     700        } else if
     701#ifdef __FreeBSD__
     702            (TRUE)
     703#else
     704            (bkpinfo->make_cd_use_lilo)
     705#endif
     706#ifdef __IA64__
    665707    {
    666       g_tmpfs_mountpt[0] = '\0';
    667       log_it("Failed to mount tmpfs");
    668     }
    669       else
     708        strcat(mondo_mkisofs_sz, MONDO_GROWISOFS_REGULAR_ELILO);
     709    }
     710#else
    670711    {
    671       log_it("Tmpfs mounted OK - %d MB", rdsiz_MB);
    672     }
    673     }
    674   else
    675     {
    676       g_tmpfs_mountpt[0] = '\0';
    677       log_it ("It doesn't seem you have enough swap to use tmpfs. Fine.");
    678     }
    679 
    680   if (bkpinfo->use_lzo)
    681     {
    682       strcpy (bkpinfo->zip_exe, "lzop");
    683       strcpy (bkpinfo->zip_suffix, "lzo");
    684     }
    685   else if (bkpinfo->compression_level!=0)
    686     {
    687       strcpy (bkpinfo->zip_exe, "bzip2");
    688       strcpy (bkpinfo->zip_suffix, "bz2");
    689     }
    690   else
    691     {
    692       bkpinfo->zip_exe[0] = bkpinfo->zip_suffix[0] = '\0';
    693     }
    694 
    695 // DVD
    696 
    697   if (bkpinfo->backup_media_type == dvd)
    698       {
    699       extra_cdrom_params[0] = '\0';
    700       mondo_mkisofs_sz[0] = '\0';
    701       if (find_home_of_exe("growisofs"))
    702     { strcpy(cdr_exe, "growisofs"); } // unlikely to be used
    703       else
    704         { fatal_error("Please install growisofs."); }
    705       if (bkpinfo->nonbootable_backup)
    706         { strcat(mondo_mkisofs_sz, MONDO_GROWISOFS_NONBOOT); }
    707       else if
     712        strcat(mondo_mkisofs_sz, MONDO_GROWISOFS_REGULAR_LILO);
     713    }
     714#endif
     715        else
     716        {
     717            strcat(mondo_mkisofs_sz, MONDO_GROWISOFS_REGULAR_SYSLINUX);
     718        }
     719        if (bkpinfo->manual_cd_tray) {
     720            fatal_error("Manual CD tray + DVD not supported yet.");
     721            // -m isn't supported by growisofs, BTW...
     722        } else {
     723            sprintf(bkpinfo->call_make_iso,
     724                    "%s %s -Z %s . 2>> _ERR_",
     725                    mondo_mkisofs_sz,
     726                    extra_cdrom_params, bkpinfo->media_device);
     727        }
     728        log_msg(2, "call_make_iso (DVD res) is ... %s",
     729                bkpinfo->call_make_iso);
     730    }                           // end of DVD code
     731
     732// CD-R or CD-RW
     733    if (bkpinfo->backup_media_type == cdrw
     734        || bkpinfo->backup_media_type == cdr) {
     735        extra_cdrom_params[0] = '\0';
     736        if (!bkpinfo->manual_cd_tray) {
     737            strcat(extra_cdrom_params, "-waiti ");
     738        }
     739        if (bkpinfo->backup_media_type == cdrw) {
     740            strcat(extra_cdrom_params, "blank=fast ");
     741        }
     742        if (find_home_of_exe("cdrecord")) {
     743            strcpy(cdr_exe, "cdrecord");
     744        } else if (find_home_of_exe("dvdrecord")) {
     745            strcpy(cdr_exe, "dvdrecord");
     746        } else {
     747            fatal_error("Please install either cdrecord or dvdrecord.");
     748        }
     749        if (bkpinfo->nonbootable_backup) {
     750            strcpy(mondo_mkisofs_sz, MONDO_MKISOFS_NONBOOT);
     751        } else if
    708752#ifdef __FreeBSD__
    709         (TRUE)
     753            (TRUE)
    710754#else
    711         (bkpinfo->make_cd_use_lilo)
     755            (bkpinfo->make_cd_use_lilo)
    712756#endif
    713757#ifdef __IA64__
    714         { strcat(mondo_mkisofs_sz, MONDO_GROWISOFS_REGULAR_ELILO); }
     758    {
     759        strcat(mondo_mkisofs_sz, MONDO_MKISOFS_REGULAR_ELILO);
     760    }
    715761#else
    716         { strcat(mondo_mkisofs_sz, MONDO_GROWISOFS_REGULAR_LILO); }
    717 #endif
    718       else
    719         { strcat(mondo_mkisofs_sz, MONDO_GROWISOFS_REGULAR_SYSLINUX); }
    720       if (bkpinfo->manual_cd_tray)
    721762    {
    722       fatal_error("Manual CD tray + DVD not supported yet.");
    723       // -m isn't supported by growisofs, BTW...
    724     }
    725       else
    726     {
    727       sprintf (bkpinfo->call_make_iso,
    728            "%s %s -Z %s . 2>> _ERR_",
    729            mondo_mkisofs_sz,
    730            extra_cdrom_params,
    731            bkpinfo->media_device);
    732         }
    733       log_msg(2, "call_make_iso (DVD res) is ... %s", bkpinfo->call_make_iso);
    734     } // end of DVD code
    735 
    736 // CD-R or CD-RW
    737   if (bkpinfo->backup_media_type == cdrw || bkpinfo->backup_media_type == cdr)
    738     {
    739       extra_cdrom_params[0] = '\0';
    740       if (!bkpinfo->manual_cd_tray)
    741     {
    742       strcat (extra_cdrom_params, "-waiti ");
    743     }
    744       if (bkpinfo->backup_media_type == cdrw)
    745     {
    746       strcat (extra_cdrom_params, "blank=fast ");
    747     }
    748       if (find_home_of_exe("cdrecord"))
    749     { strcpy(cdr_exe, "cdrecord"); }
    750       else if (find_home_of_exe("dvdrecord"))
    751     { strcpy(cdr_exe, "dvdrecord"); }
    752       else
    753         { fatal_error("Please install either cdrecord or dvdrecord."); }
    754       if (bkpinfo->nonbootable_backup)
    755         { strcpy(mondo_mkisofs_sz, MONDO_MKISOFS_NONBOOT); }
    756       else if
    757 #ifdef __FreeBSD__
    758         (TRUE)
    759 #else
    760         (bkpinfo->make_cd_use_lilo)
    761 #endif
    762 #ifdef __IA64__
    763         { strcat(mondo_mkisofs_sz, MONDO_MKISOFS_REGULAR_ELILO); }
    764 #else
    765         { strcpy(mondo_mkisofs_sz, MONDO_MKISOFS_REGULAR_LILO); }
    766 #endif
    767       else
    768         { strcpy(mondo_mkisofs_sz, MONDO_MKISOFS_REGULAR_SYSLINUX); }
    769       if (bkpinfo->manual_cd_tray)
    770     {
    771       sprintf (bkpinfo->call_before_iso,
    772            "%s -o %s/temporary.iso . 2>> _ERR_", mondo_mkisofs_sz, bkpinfo->tmpdir);
    773       sprintf (bkpinfo->call_make_iso,
    774            "%s %s -v %s fs=4m dev=%s speed=%d %s/temporary.iso",
    775            cdr_exe,
    776            (bkpinfo->please_dont_eject)?" ":"-eject",
    777            extra_cdrom_params, bkpinfo->media_device,
    778            bkpinfo->cdrw_speed, bkpinfo->tmpdir);
    779     }
    780       else
    781     {
    782       sprintf (bkpinfo->call_make_iso,
    783            "%s . 2>> _ERR_ | %s %s %s fs=4m dev=%s speed=%d -",
    784            mondo_mkisofs_sz, cdr_exe,
    785            (bkpinfo->please_dont_eject)?" ":"-eject",
    786            extra_cdrom_params, bkpinfo->media_device,
    787            bkpinfo->cdrw_speed);
    788         }
    789     } // end of CD code
    790 
    791   /*
    792   if (bkpinfo->backup_data && bkpinfo->backup_media_type == tape)
    793     {
    794       sprintf (tmp,
    795            "dd if=/dev/zero of=%s bs=%ld count=32 2> /dev/null",
    796            bkpinfo->media_device, bkpinfo->internal_tape_block_size);
    797       if (system(tmp))
    798     {
    799       retval++;
    800       fprintf (stderr,
    801            "Cannot write to tape device. Is the tape set read-only?\n");
    802     }
    803     } // end of tape code
    804   */
    805 
    806 
    807   if (bkpinfo->backup_media_type == iso)
    808     {
     763        strcpy(mondo_mkisofs_sz, MONDO_MKISOFS_REGULAR_LILO);
     764    }
     765#endif
     766        else
     767        {
     768            strcpy(mondo_mkisofs_sz, MONDO_MKISOFS_REGULAR_SYSLINUX);
     769        }
     770        if (bkpinfo->manual_cd_tray) {
     771            sprintf(bkpinfo->call_before_iso,
     772                    "%s -o %s/temporary.iso . 2>> _ERR_", mondo_mkisofs_sz,
     773                    bkpinfo->tmpdir);
     774            sprintf(bkpinfo->call_make_iso,
     775                    "%s %s -v %s fs=4m dev=%s speed=%d %s/temporary.iso",
     776                    cdr_exe, (bkpinfo->please_dont_eject) ? " " : "-eject",
     777                    extra_cdrom_params, bkpinfo->media_device,
     778                    bkpinfo->cdrw_speed, bkpinfo->tmpdir);
     779        } else {
     780            sprintf(bkpinfo->call_make_iso,
     781                    "%s . 2>> _ERR_ | %s %s %s fs=4m dev=%s speed=%d -",
     782                    mondo_mkisofs_sz, cdr_exe,
     783                    (bkpinfo->please_dont_eject) ? " " : "-eject",
     784                    extra_cdrom_params, bkpinfo->media_device,
     785                    bkpinfo->cdrw_speed);
     786        }
     787    }                           // end of CD code
     788
     789    /*
     790       if (bkpinfo->backup_data && bkpinfo->backup_media_type == tape)
     791       {
     792       sprintf (tmp,
     793       "dd if=/dev/zero of=%s bs=%ld count=32 2> /dev/null",
     794       bkpinfo->media_device, bkpinfo->internal_tape_block_size);
     795       if (system(tmp))
     796       {
     797       retval++;
     798       fprintf (stderr,
     799       "Cannot write to tape device. Is the tape set read-only?\n");
     800       }
     801       } // end of tape code
     802     */
     803
     804
     805    if (bkpinfo->backup_media_type == iso) {
    809806
    810807/* Patch by Conor Daly <conor.daly@met.ie>
     
    815812 */
    816813
    817       log_it("isodir = %s", bkpinfo->isodir);
    818       sprintf(command, "df %s | tail -n1 | cut -d' ' -f1", bkpinfo->isodir);
    819       log_it("command = %s", command);
    820       log_it("res of it = %s", call_program_and_get_last_line_of_output(command));
    821       sprintf(iso_dev, "%s", call_program_and_get_last_line_of_output(command));
    822       sprintf(tmp, "%s/ISO-DEV", bkpinfo->tmpdir);
    823       write_one_liner_data_file(tmp, call_program_and_get_last_line_of_output(command));
    824 
    825       sprintf(command, "mount | grep -w %s | tail -n1 | cut -d' ' -f3", iso_dev);
    826       log_it("command = %s", command);
    827       log_it("res of it = %s", call_program_and_get_last_line_of_output(command));
    828       sprintf(iso_mnt, "%s", call_program_and_get_last_line_of_output(command));
    829       sprintf(tmp, "%s/ISO-MNT", bkpinfo->tmpdir);
    830       write_one_liner_data_file(tmp, call_program_and_get_last_line_of_output(command));
    831 log_it("isomnt: %s, %d", iso_mnt, strlen(iso_mnt));
    832       sprintf(iso_tmp, "%s", bkpinfo->isodir);
    833       if (strlen(iso_tmp) < strlen(iso_mnt))
    834         {
    835       iso_path[0] = '\0';
    836     }
    837       else
    838         {
    839           sprintf(iso_path, "%s", iso_tmp + strlen(iso_mnt));
    840     }
    841       sprintf(tmp, "%s/ISODIR", bkpinfo->tmpdir);
    842       write_one_liner_data_file(tmp, iso_path);
    843 log_it("isodir: %s", iso_path);
     814        log_it("isodir = %s", bkpinfo->isodir);
     815        sprintf(command, "df %s | tail -n1 | cut -d' ' -f1",
     816                bkpinfo->isodir);
     817        log_it("command = %s", command);
     818        log_it("res of it = %s",
     819               call_program_and_get_last_line_of_output(command));
     820        sprintf(iso_dev, "%s",
     821                call_program_and_get_last_line_of_output(command));
     822        sprintf(tmp, "%s/ISO-DEV", bkpinfo->tmpdir);
     823        write_one_liner_data_file(tmp,
     824                                  call_program_and_get_last_line_of_output
     825                                  (command));
     826
     827        sprintf(command, "mount | grep -w %s | tail -n1 | cut -d' ' -f3",
     828                iso_dev);
     829        log_it("command = %s", command);
     830        log_it("res of it = %s",
     831               call_program_and_get_last_line_of_output(command));
     832        sprintf(iso_mnt, "%s",
     833                call_program_and_get_last_line_of_output(command));
     834        sprintf(tmp, "%s/ISO-MNT", bkpinfo->tmpdir);
     835        write_one_liner_data_file(tmp,
     836                                  call_program_and_get_last_line_of_output
     837                                  (command));
     838        log_it("isomnt: %s, %d", iso_mnt, strlen(iso_mnt));
     839        sprintf(iso_tmp, "%s", bkpinfo->isodir);
     840        if (strlen(iso_tmp) < strlen(iso_mnt)) {
     841            iso_path[0] = '\0';
     842        } else {
     843            sprintf(iso_path, "%s", iso_tmp + strlen(iso_mnt));
     844        }
     845        sprintf(tmp, "%s/ISODIR", bkpinfo->tmpdir);
     846        write_one_liner_data_file(tmp, iso_path);
     847        log_it("isodir: %s", iso_path);
    844848
    845849/* End patch */
    846     } // end of iso code
    847 
    848   if (bkpinfo->backup_media_type == nfs) {
    849       strcpy (hostname, bkpinfo->nfs_mount);
    850       colon = strchr (hostname, ':');
    851       if (!colon) {
    852       log_it ("nfs mount doesn't have a colon in it");
    853       retval++;
    854       } else {
    855       struct hostent *hent;
    856 
    857       *colon = '\0';
    858       hent = gethostbyname (hostname);
    859       if (!hent) {
    860           log_it ("Can't resolve NFS mount (%s): %s", hostname, hstrerror (h_errno));
    861           retval++;
    862       } else {
    863           strcpy (ip_address, inet_ntoa
    864               ((struct in_addr)*((struct in_addr *)hent->h_addr)));
    865           strcat (ip_address, strchr (bkpinfo->nfs_mount, ':'));
    866           strcpy (bkpinfo->nfs_mount, ip_address);
    867       }
    868       }
    869   }
    870 
    871   log_it("Finished processing incoming params");
    872   if (retval)
    873     {
    874       fprintf (stderr, "Type 'man mondoarchive' for help.\n");
    875     }
    876   sprintf (tmp, "%s", MONDO_TMPISOS);   /* added #define 22 apr 2002 */
    877   if (does_file_exist (tmp))
    878     {
    879       unlink (tmp);
    880     }
    881   if (strlen (bkpinfo->tmpdir) < 2 || strlen (bkpinfo->scratchdir) < 2)
    882     {
    883       log_it ("tmpdir or scratchdir are blank/missing");
    884       retval++;
    885     }
    886   if (bkpinfo->include_paths[0] == '\0')
    887     {
    888     //      fatal_error ("Why no backup path?");
    889     strcpy (bkpinfo->include_paths, "/");
    890     }
    891   chmod(bkpinfo->scratchdir, 0700);
    892   chmod(bkpinfo->tmpdir, 0700);
    893   g_backup_media_type = bkpinfo->backup_media_type;
    894   paranoid_free(mtpt);
    895   paranoid_free(extra_cdrom_params);
    896   paranoid_free(mondo_mkisofs_sz);
    897   paranoid_free(command);
    898   paranoid_free(hostname);
    899   paranoid_free(ip_address);
    900   paranoid_free(cdr_exe);
    901   paranoid_free(tmp);
    902   paranoid_free(iso_dev);
    903   paranoid_free(iso_mnt);
    904   paranoid_free(iso_tmp);
    905   paranoid_free(iso_path);
    906   return(retval);
     850    }                           // end of iso code
     851
     852    if (bkpinfo->backup_media_type == nfs) {
     853        strcpy(hostname, bkpinfo->nfs_mount);
     854        colon = strchr(hostname, ':');
     855        if (!colon) {
     856            log_it("nfs mount doesn't have a colon in it");
     857            retval++;
     858        } else {
     859            struct hostent *hent;
     860
     861            *colon = '\0';
     862            hent = gethostbyname(hostname);
     863            if (!hent) {
     864                log_it("Can't resolve NFS mount (%s): %s", hostname,
     865                       hstrerror(h_errno));
     866                retval++;
     867            } else {
     868                strcpy(ip_address, inet_ntoa
     869                       ((struct in_addr)
     870                        *((struct in_addr *) hent->h_addr)));
     871                strcat(ip_address, strchr(bkpinfo->nfs_mount, ':'));
     872                strcpy(bkpinfo->nfs_mount, ip_address);
     873            }
     874        }
     875    }
     876
     877    log_it("Finished processing incoming params");
     878    if (retval) {
     879        fprintf(stderr, "Type 'man mondoarchive' for help.\n");
     880    }
     881    sprintf(tmp, "%s", MONDO_TMPISOS);  /* added #define 22 apr 2002 */
     882    if (does_file_exist(tmp)) {
     883        unlink(tmp);
     884    }
     885    if (strlen(bkpinfo->tmpdir) < 2 || strlen(bkpinfo->scratchdir) < 2) {
     886        log_it("tmpdir or scratchdir are blank/missing");
     887        retval++;
     888    }
     889    if (bkpinfo->include_paths[0] == '\0') {
     890        //      fatal_error ("Why no backup path?");
     891        strcpy(bkpinfo->include_paths, "/");
     892    }
     893    chmod(bkpinfo->scratchdir, 0700);
     894    chmod(bkpinfo->tmpdir, 0700);
     895    g_backup_media_type = bkpinfo->backup_media_type;
     896    paranoid_free(mtpt);
     897    paranoid_free(extra_cdrom_params);
     898    paranoid_free(mondo_mkisofs_sz);
     899    paranoid_free(command);
     900    paranoid_free(hostname);
     901    paranoid_free(ip_address);
     902    paranoid_free(cdr_exe);
     903    paranoid_free(tmp);
     904    paranoid_free(iso_dev);
     905    paranoid_free(iso_mnt);
     906    paranoid_free(iso_tmp);
     907    paranoid_free(iso_path);
     908    return (retval);
    907909}
    908910
     
    918920int pre_param_configuration(struct s_bkpinfo *bkpinfo)
    919921{
    920   int res=0;
    921 
    922   make_hole_for_dir(MNT_CDROM);
    923   assert(bkpinfo!=NULL);
    924   srandom ((unsigned long)(time (NULL)));
    925   insmod_crucial_modules();
    926   reset_bkpinfo (bkpinfo); // also sets defaults ('/'=backup path, 3=compression level)
    927   if (bkpinfo->disaster_recovery) {
    928     if (!does_nonMS_partition_exist()) {
    929       fatal_error ("I am in disaster recovery mode\nPlease don't run mondoarchive.");
    930     }
    931   }
    932 
    933   unlink (MONDO_TRACEFILE);
    934   run_program_and_log_output( "rm -Rf /tmp/changed.files*", FALSE);
    935   if (find_and_store_mondoarchives_home(g_mondo_home))
    936     {
    937       fprintf (stderr,
    938            "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");
    939       res++;
    940       return(res);
    941     }
    942   res += some_basic_system_sanity_checks ();
    943   if (res)
    944     {
    945       log_it ("Your distribution did not pass Mondo's sanity test.");
    946     }
    947   g_current_media_number = 1;
    948   bkpinfo->postnuke_tarball[0] = bkpinfo->nfs_mount[0] = '\0';
    949   return(res);
     922    int res = 0;
     923
     924    make_hole_for_dir(MNT_CDROM);
     925    assert(bkpinfo != NULL);
     926    srandom((unsigned long) (time(NULL)));
     927    insmod_crucial_modules();
     928    reset_bkpinfo(bkpinfo);     // also sets defaults ('/'=backup path, 3=compression level)
     929    if (bkpinfo->disaster_recovery) {
     930        if (!does_nonMS_partition_exist()) {
     931            fatal_error
     932                ("I am in disaster recovery mode\nPlease don't run mondoarchive.");
     933        }
     934    }
     935
     936    unlink(MONDO_TRACEFILE);
     937    run_program_and_log_output("rm -Rf /tmp/changed.files*", FALSE);
     938    if (find_and_store_mondoarchives_home(g_mondo_home)) {
     939        fprintf(stderr,
     940                "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");
     941        res++;
     942        return (res);
     943    }
     944    res += some_basic_system_sanity_checks();
     945    if (res) {
     946        log_it("Your distribution did not pass Mondo's sanity test.");
     947    }
     948    g_current_media_number = 1;
     949    bkpinfo->postnuke_tarball[0] = bkpinfo->nfs_mount[0] = '\0';
     950    return (res);
    950951}
    951952
     
    957958 * @param bkpinfo The @c bkpinfo to reset.
    958959 */
    959 void
    960 reset_bkpinfo (struct s_bkpinfo *bkpinfo)
    961 {
    962   int i;
    963 
    964   log_msg(1, "Hi");
    965   assert(bkpinfo!=NULL);
    966   memset((void*)bkpinfo, 0, sizeof(struct s_bkpinfo));
    967   bkpinfo->manual_cd_tray = FALSE;
    968   bkpinfo->internal_tape_block_size = DEFAULT_INTERNAL_TAPE_BLOCK_SIZE;
    969   bkpinfo->media_device[0] = '\0';
    970   for(i=0; i<=MAX_NOOF_MEDIA; i++) { bkpinfo->media_size[i] = -1; }
    971   bkpinfo->boot_loader = '\0';
    972   bkpinfo->boot_device[0] = '\0';
    973   bkpinfo->zip_exe[0] = '\0';
    974   bkpinfo->zip_suffix[0] = '\0';
    975   bkpinfo->restore_path[0] = '\0';
    976   bkpinfo->use_lzo = FALSE;
    977   bkpinfo->do_not_compress_these[0] = '\0';
    978   bkpinfo->verify_data = FALSE;
    979   bkpinfo->backup_data = FALSE;
    980   bkpinfo->restore_data = FALSE;
    981   bkpinfo->disaster_recovery = (am_I_in_disaster_recovery_mode()?TRUE:FALSE);
    982   if (bkpinfo->disaster_recovery)
    983     { strcpy(bkpinfo->isodir, "/"); }
    984   else
    985     { strcpy (bkpinfo->isodir, "/root/images/mondo"); }
    986   strcpy (bkpinfo->prefix, "mondorescue");
    987 
    988   bkpinfo->scratchdir[0] = '\0';
    989   bkpinfo->make_filelist = TRUE; // unless -J supplied to mondoarchive
    990   sprintf( bkpinfo->tmpdir, "/tmp/tmpfs/mondo.tmp.%d", (int) ( random() %32768 ) ); // for mondorestore
    991   bkpinfo->optimal_set_size = 0;
    992   bkpinfo->backup_media_type = none;
    993   strcpy (bkpinfo->include_paths, "/");
    994   bkpinfo->exclude_paths[0] = '\0';
    995   bkpinfo->call_before_iso[0] = '\0';
    996   bkpinfo->call_make_iso[0] = '\0';
    997   bkpinfo->call_burn_iso[0] = '\0';
    998   bkpinfo->call_after_iso[0] = '\0';
    999   bkpinfo->image_devs[0] = '\0';
    1000   bkpinfo->postnuke_tarball[0] = '\0';
    1001   bkpinfo->kernel_path[0] = '\0';
    1002   bkpinfo->nfs_mount[0] = '\0';
    1003   bkpinfo->nfs_remote_dir[0] = '\0';
    1004   bkpinfo->wipe_media_first = FALSE;
    1005   bkpinfo->differential = FALSE;
    1006   bkpinfo->cdrw_speed = 0;
     960void reset_bkpinfo(struct s_bkpinfo *bkpinfo)
     961{
     962    int i;
     963
     964    log_msg(1, "Hi");
     965    assert(bkpinfo != NULL);
     966    memset((void *) bkpinfo, 0, sizeof(struct s_bkpinfo));
     967    bkpinfo->manual_cd_tray = FALSE;
     968    bkpinfo->internal_tape_block_size = DEFAULT_INTERNAL_TAPE_BLOCK_SIZE;
     969    bkpinfo->media_device[0] = '\0';
     970    for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
     971        bkpinfo->media_size[i] = -1;
     972    }
     973    bkpinfo->boot_loader = '\0';
     974    bkpinfo->boot_device[0] = '\0';
     975    bkpinfo->zip_exe[0] = '\0';
     976    bkpinfo->zip_suffix[0] = '\0';
     977    bkpinfo->restore_path[0] = '\0';
     978    bkpinfo->use_lzo = FALSE;
     979    bkpinfo->do_not_compress_these[0] = '\0';
     980    bkpinfo->verify_data = FALSE;
     981    bkpinfo->backup_data = FALSE;
     982    bkpinfo->restore_data = FALSE;
     983    bkpinfo->disaster_recovery =
     984        (am_I_in_disaster_recovery_mode()? TRUE : FALSE);
     985    if (bkpinfo->disaster_recovery) {
     986        strcpy(bkpinfo->isodir, "/");
     987    } else {
     988        strcpy(bkpinfo->isodir, "/root/images/mondo");
     989    }
     990    strcpy(bkpinfo->prefix, "mondorescue");
     991
     992    bkpinfo->scratchdir[0] = '\0';
     993    bkpinfo->make_filelist = TRUE;  // unless -J supplied to mondoarchive
     994    sprintf(bkpinfo->tmpdir, "/tmp/tmpfs/mondo.tmp.%d", (int) (random() % 32768));  // for mondorestore
     995    bkpinfo->optimal_set_size = 0;
     996    bkpinfo->backup_media_type = none;
     997    strcpy(bkpinfo->include_paths, "/");
     998    bkpinfo->exclude_paths[0] = '\0';
     999    bkpinfo->call_before_iso[0] = '\0';
     1000    bkpinfo->call_make_iso[0] = '\0';
     1001    bkpinfo->call_burn_iso[0] = '\0';
     1002    bkpinfo->call_after_iso[0] = '\0';
     1003    bkpinfo->image_devs[0] = '\0';
     1004    bkpinfo->postnuke_tarball[0] = '\0';
     1005    bkpinfo->kernel_path[0] = '\0';
     1006    bkpinfo->nfs_mount[0] = '\0';
     1007    bkpinfo->nfs_remote_dir[0] = '\0';
     1008    bkpinfo->wipe_media_first = FALSE;
     1009    bkpinfo->differential = FALSE;
     1010    bkpinfo->cdrw_speed = 0;
    10071011// patch by Herman Kuster 
    1008   bkpinfo->differential = 0;
     1012    bkpinfo->differential = 0;
    10091013// patch end
    1010   bkpinfo->compression_level = 3;
     1014    bkpinfo->compression_level = 3;
    10111015}
    10121016
     
    10191023 * @return The free space on @p partition, in MB.
    10201024 */
    1021 long free_space_on_given_partition(char*partition)
    1022 {
    1023   char command[MAX_STR_LEN], out_sz[MAX_STR_LEN];
    1024   long res;
    1025 
    1026   assert_string_is_neither_NULL_nor_zerolength(partition);
    1027 
    1028   sprintf(command, "df -m %s &> /dev/null", partition);
    1029   if (system(command))
    1030     { return(-1); } // partition does not exist
    1031   sprintf(command, "df -m %s | tail -n1 | tr -s ' ' '\t' | cut -f4", partition);
    1032   strcpy(out_sz, call_program_and_get_last_line_of_output(command));
    1033   if (strlen(out_sz)==0)
    1034     { return(-1); } // error within df, probably
    1035   res = atol(out_sz);
    1036   return(res);
     1025long free_space_on_given_partition(char *partition)
     1026{
     1027    char command[MAX_STR_LEN], out_sz[MAX_STR_LEN];
     1028    long res;
     1029
     1030    assert_string_is_neither_NULL_nor_zerolength(partition);
     1031
     1032    sprintf(command, "df -m %s &> /dev/null", partition);
     1033    if (system(command)) {
     1034        return (-1);
     1035    }                           // partition does not exist
     1036    sprintf(command, "df -m %s | tail -n1 | tr -s ' ' '\t' | cut -f4",
     1037            partition);
     1038    strcpy(out_sz, call_program_and_get_last_line_of_output(command));
     1039    if (strlen(out_sz) == 0) {
     1040        return (-1);
     1041    }                           // error within df, probably
     1042    res = atol(out_sz);
     1043    return (res);
    10371044}
    10381045
     
    10511058 * @return number of problems with the user's setup (0 for success)
    10521059 */
    1053 int
    1054 some_basic_system_sanity_checks ()
    1055 {
    1056 
    1057     /*@ buffers *************/
    1058   char tmp[MAX_STR_LEN];
    1059   //  char command[MAX_STR_LEN];
    1060 
    1061     /*@ int's ****************/
    1062   int retval = 0;
    1063   long Lres;
    1064 
    1065 
    1066   mvaddstr_and_log_it (g_currentY, 0,
    1067                "Checking sanity of your Linux distribution");
     1060int some_basic_system_sanity_checks()
     1061{
     1062
     1063    /*@ buffers ************ */
     1064    char tmp[MAX_STR_LEN];
     1065    //  char command[MAX_STR_LEN];
     1066
     1067    /*@ int's *************** */
     1068    int retval = 0;
     1069    long Lres;
     1070
     1071
     1072    mvaddstr_and_log_it(g_currentY, 0,
     1073                        "Checking sanity of your Linux distribution");
    10681074#ifndef __FreeBSD__
    1069   if (system("which mkfs.vfat &> /dev/null") && !system("which mkfs.msdos &> /dev/null"))
    1070     {
    1071       log_it("OK, you've got mkfs.msdos but not mkfs.vfat; time for the fairy to wave her magic wand...");
    1072       run_program_and_log_output("ln -sf `which mkfs.msdos` /sbin/mkfs.vfat", FALSE);
    1073     }
    1074   strcpy (tmp,
    1075       call_program_and_get_last_line_of_output
    1076       ("free | grep Mem | head -n1 | tr -s ' ' '\t' | cut -f2"));
    1077   if (atol (tmp) < 35000)
    1078     {
    1079       retval++;
    1080       log_to_screen ("You must have at least 32MB of RAM to use Mondo.");
    1081     }
    1082   if (atol (tmp) < 66000)
    1083     {
    1084       log_to_screen
    1085     ("WARNING! You have very little RAM. Please upgrade to 64MB or more.");
    1086     }
    1087 #endif
    1088 
    1089   if ((Lres = free_space_on_given_partition("/root"))==-1)
    1090     { Lres = free_space_on_given_partition("/"); }
    1091   log_it("Free space on given partition = %ld MB", Lres);
    1092 
    1093   if (Lres < 50)
    1094     {
    1095       run_program_and_log_output("rm -Rf /root/images/mindi; mkdir -p /home/root/images/mindi; mkdir -p /root/images; ln -sf /home/root/images/mindi /root/images/mindi", 3);
    1096       //      fatal_error("Your / (or /root) partition has <50MB free. Please adjust your partition table to something saner.");
    1097     }
    1098 
    1099   if (system ("which " MKE2FS_OR_NEWFS " > /dev/null 2> /dev/null"))
    1100     {
    1101       retval++;
    1102       log_to_screen
    1103     ("Unable to find " MKE2FS_OR_NEWFS " in system path.");
    1104       fatal_error
    1105         ("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. :)");
    1106     }
     1075    if (system("which mkfs.vfat &> /dev/null")
     1076        && !system("which mkfs.msdos &> /dev/null")) {
     1077        log_it
     1078            ("OK, you've got mkfs.msdos but not mkfs.vfat; time for the fairy to wave her magic wand...");
     1079        run_program_and_log_output
     1080            ("ln -sf `which mkfs.msdos` /sbin/mkfs.vfat", FALSE);
     1081    }
     1082    strcpy(tmp,
     1083           call_program_and_get_last_line_of_output
     1084           ("free | grep Mem | head -n1 | tr -s ' ' '\t' | cut -f2"));
     1085    if (atol(tmp) < 35000) {
     1086        retval++;
     1087        log_to_screen("You must have at least 32MB of RAM to use Mondo.");
     1088    }
     1089    if (atol(tmp) < 66000) {
     1090        log_to_screen
     1091            ("WARNING! You have very little RAM. Please upgrade to 64MB or more.");
     1092    }
     1093#endif
     1094
     1095    if ((Lres = free_space_on_given_partition("/root")) == -1) {
     1096        Lres = free_space_on_given_partition("/");
     1097    }
     1098    log_it("Free space on given partition = %ld MB", Lres);
     1099
     1100    if (Lres < 50) {
     1101        run_program_and_log_output
     1102            ("rm -Rf /root/images/mindi; mkdir -p /home/root/images/mindi; mkdir -p /root/images; ln -sf /home/root/images/mindi /root/images/mindi",
     1103             3);
     1104        //      fatal_error("Your / (or /root) partition has <50MB free. Please adjust your partition table to something saner.");
     1105    }
     1106
     1107    if (system("which " MKE2FS_OR_NEWFS " > /dev/null 2> /dev/null")) {
     1108        retval++;
     1109        log_to_screen
     1110            ("Unable to find " MKE2FS_OR_NEWFS " in system path.");
     1111        fatal_error
     1112            ("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. :)");
     1113    }
    11071114#ifndef __FreeBSD__
    1108   if (run_program_and_log_output ("cat /proc/devices | grep ramdisk", FALSE))
    1109     {
    1110       if (!ask_me_yes_or_no("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?"))
    1111         {
    1112       //          retval++;
    1113           log_to_screen
    1114             ("It looks as if your kernel lacks ramdisk and initrd support.");
    1115       log_to_screen
    1116         ("I'll allow you to proceed but FYI, if I'm right, your kernel is broken.");
    1117         }
    1118     }
    1119 #endif
    1120   retval += whine_if_not_found (MKE2FS_OR_NEWFS);
    1121   retval += whine_if_not_found ("mkisofs");
    1122   if (system("which dvdrecord > /dev/null 2> /dev/null"))
    1123     { retval += whine_if_not_found ("cdrecord"); }
    1124   retval += whine_if_not_found ("bzip2");
    1125   retval += whine_if_not_found ("awk");
    1126   retval += whine_if_not_found ("md5sum");
    1127   retval += whine_if_not_found ("strings");
    1128   retval += whine_if_not_found ("mindi");
    1129   retval += whine_if_not_found ("buffer");
    1130 
    1131   // abort if Windows partition but no ms-sys and parted
    1132   if (!run_program_and_log_output("mount | grep -w vfat | grep -v /dev/fd | grep -v nexdisk", 0) ||
    1133       !run_program_and_log_output("mount | grep -w dos | grep -v /dev/fd | grep -v nexdisk", 0))
    1134     {
    1135       log_to_screen("I think you have a Windows 9x partition.");
    1136       retval += whine_if_not_found ("parted");
     1115    if (run_program_and_log_output
     1116        ("cat /proc/devices | grep ramdisk", FALSE)) {
     1117        if (!ask_me_yes_or_no
     1118            ("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?"))
     1119        {
     1120            //          retval++;
     1121            log_to_screen
     1122                ("It looks as if your kernel lacks ramdisk and initrd support.");
     1123            log_to_screen
     1124                ("I'll allow you to proceed but FYI, if I'm right, your kernel is broken.");
     1125        }
     1126    }
     1127#endif
     1128    retval += whine_if_not_found(MKE2FS_OR_NEWFS);
     1129    retval += whine_if_not_found("mkisofs");
     1130    if (system("which dvdrecord > /dev/null 2> /dev/null")) {
     1131        retval += whine_if_not_found("cdrecord");
     1132    }
     1133    retval += whine_if_not_found("bzip2");
     1134    retval += whine_if_not_found("awk");
     1135    retval += whine_if_not_found("md5sum");
     1136    retval += whine_if_not_found("strings");
     1137    retval += whine_if_not_found("mindi");
     1138    retval += whine_if_not_found("buffer");
     1139
     1140    // abort if Windows partition but no ms-sys and parted
     1141    if (!run_program_and_log_output
     1142        ("mount | grep -w vfat | grep -v /dev/fd | grep -v nexdisk", 0)
     1143        ||
     1144        !run_program_and_log_output
     1145        ("mount | grep -w dos | grep -v /dev/fd | grep -v nexdisk", 0)) {
     1146        log_to_screen("I think you have a Windows 9x partition.");
     1147        retval += whine_if_not_found("parted");
    11371148#ifndef __IA64__
    1138       /* IA64 always has one vfat partition for EFI even without Windows */
    1139       // retval +=
    1140       if (!find_home_of_exe("ms-sys"))
    1141         {
    1142       log_to_screen("Please install ms-sys just in case.");
    1143     }
    1144 #endif
    1145     }
    1146 
    1147   if (!find_home_of_exe("cmp"))
    1148     {
    1149       if (!find_home_of_exe("true"))
    1150         { whine_if_not_found ("cmp"); }
    1151       else
    1152         {
    1153           log_to_screen("Your system lacks the 'cmp' binary. I'll create a dummy cmp for you.");
    1154           if (run_program_and_log_output("cp -f `which true` /usr/bin/cmp", 0))
    1155             { fatal_error("Failed to create dummy 'cmp' file."); }
    1156         }
    1157     }
    1158   run_program_and_log_output("umount `mount | grep cdr | cut -d' ' -f3 | tr '\n' ' '`", 5);
    1159   strcpy (tmp,
    1160       call_program_and_get_last_line_of_output
    1161       ("mount | grep -E \"cdr(om|w)\""));
    1162   if (strcmp ("", tmp))
    1163     {
    1164     if (strstr (tmp, "autofs")) {
    1165         log_to_screen ("Your CD-ROM is mounted via autofs. I therefore cannot tell");
    1166         log_to_screen ("if a CD actually is inserted. If a CD is inserted, please");
    1167         log_to_screen ("eject it. Thank you.");
    1168         log_it ("Ignoring autofs CD-ROM 'mount' since we hope nothing's in it.");
    1169     } else if (run_program_and_log_output("uname -a | grep Knoppix", 5)) {
    1170         retval++;
    1171         fatal_error ("Your CD-ROM drive is mounted. Please unmount it.");
    1172     }
    1173     }
     1149        /* IA64 always has one vfat partition for EFI even without Windows */
     1150        // retval +=
     1151        if (!find_home_of_exe("ms-sys")) {
     1152            log_to_screen("Please install ms-sys just in case.");
     1153        }
     1154#endif
     1155    }
     1156
     1157    if (!find_home_of_exe("cmp")) {
     1158        if (!find_home_of_exe("true")) {
     1159            whine_if_not_found("cmp");
     1160        } else {
     1161            log_to_screen
     1162                ("Your system lacks the 'cmp' binary. I'll create a dummy cmp for you.");
     1163            if (run_program_and_log_output
     1164                ("cp -f `which true` /usr/bin/cmp", 0)) {
     1165                fatal_error("Failed to create dummy 'cmp' file.");
     1166            }
     1167        }
     1168    }
     1169    run_program_and_log_output
     1170        ("umount `mount | grep cdr | cut -d' ' -f3 | tr '\n' ' '`", 5);
     1171    strcpy(tmp,
     1172           call_program_and_get_last_line_of_output
     1173           ("mount | grep -E \"cdr(om|w)\""));
     1174    if (strcmp("", tmp)) {
     1175        if (strstr(tmp, "autofs")) {
     1176            log_to_screen
     1177                ("Your CD-ROM is mounted via autofs. I therefore cannot tell");
     1178            log_to_screen
     1179                ("if a CD actually is inserted. If a CD is inserted, please");
     1180            log_to_screen("eject it. Thank you.");
     1181            log_it
     1182                ("Ignoring autofs CD-ROM 'mount' since we hope nothing's in it.");
     1183        } else
     1184            if (run_program_and_log_output("uname -a | grep Knoppix", 5)) {
     1185            retval++;
     1186            fatal_error
     1187                ("Your CD-ROM drive is mounted. Please unmount it.");
     1188        }
     1189    }
    11741190#ifndef __FreeBSD__
    1175   if (!does_file_exist ("/etc/modules.conf"))
    1176     {
    1177       if (does_file_exist("/etc/conf.modules"))
    1178         {
    1179           log_it("Linking /etc/modules.conf to /etc/conf.modules");
    1180           run_program_and_log_output("ln -sf /etc/conf.modules /etc/modules.conf", 5);
    1181         }
    1182       else if (does_file_exist("/etc/modprobe.d"))
    1183     {
    1184       log_it("Directory /etc/modprobe.d found. mindi will use its contents.");
    1185     }
    1186       else if (does_file_exist("/etc/modprobe.conf"))
    1187         {
    1188           log_it("Linking /etc/modules.conf to /etc/modprobe.conf");
    1189           run_program_and_log_output("ln -sf /etc/modprobe.conf /etc/modules.conf", 5);
    1190     }
    1191       else
    1192         {
    1193           retval++;
    1194           log_to_screen ("Please find out what happened to /etc/modules.conf");
    1195         }
    1196     }
    1197 #endif
    1198 
    1199   run_program_and_log_output("cat /etc/fstab", 5);
     1191    if (!does_file_exist("/etc/modules.conf")) {
     1192        if (does_file_exist("/etc/conf.modules")) {
     1193            log_it("Linking /etc/modules.conf to /etc/conf.modules");
     1194            run_program_and_log_output
     1195                ("ln -sf /etc/conf.modules /etc/modules.conf", 5);
     1196        } else if (does_file_exist("/etc/modprobe.d")) {
     1197            log_it
     1198                ("Directory /etc/modprobe.d found. mindi will use its contents.");
     1199        } else if (does_file_exist("/etc/modprobe.conf")) {
     1200            log_it("Linking /etc/modules.conf to /etc/modprobe.conf");
     1201            run_program_and_log_output
     1202                ("ln -sf /etc/modprobe.conf /etc/modules.conf", 5);
     1203        } else {
     1204            retval++;
     1205            log_to_screen
     1206                ("Please find out what happened to /etc/modules.conf");
     1207        }
     1208    }
     1209#endif
     1210
     1211    run_program_and_log_output("cat /etc/fstab", 5);
    12001212#ifdef __FreeBSD__
    1201   run_program_and_log_output("vinum printconfig", 5);
     1213    run_program_and_log_output("vinum printconfig", 5);
    12021214#else
    1203   run_program_and_log_output("cat /etc/raidtab", 5);
    1204 #endif
    1205 
    1206   if (run_program_and_log_output("mindi -V", 1))
    1207     {
    1208       log_to_screen("Could not ascertain mindi's version number.");
    1209       log_to_screen("You have not installed Mondo and/or Mindi properly.");
    1210       log_to_screen("Please uninstall and reinstall them both.");
    1211       fatal_error("Please reinstall Mondo and Mindi.");
    1212     }
    1213   if (run_program_and_log_output("mindi --makemountlist /tmp/mountlist.txt.test", 5))
    1214     {
    1215       log_to_screen("Mindi --makemountlist /tmp/mountlist.txt.test failed for some reason.");
    1216       log_to_screen("Please run that command by hand and examine /var/log/mindi.log");
    1217       log_to_screen("for more information. Perhaps your /etc/fstab file is insane.");
    1218       log_to_screen("Perhaps Mindi's MakeMountlist() subroutine has a bug. We'll see.");
    1219       retval++;
    1220     }
    1221 
    1222   if (!run_program_and_log_output("fdisk -l | grep -i raid", 1) && !does_file_exist("/etc/raidtab"))
    1223     {
    1224       log_to_screen("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     {
    1230       mvaddstr_and_log_it (g_currentY++, 74, "Failed.");
    1231     }
    1232   else
    1233     {
    1234       mvaddstr_and_log_it (g_currentY++, 74, "Done.");
    1235     }
    1236   return (retval);
     1215    run_program_and_log_output("cat /etc/raidtab", 5);
     1216#endif
     1217
     1218    if (run_program_and_log_output("mindi -V", 1)) {
     1219        log_to_screen("Could not ascertain mindi's version number.");
     1220        log_to_screen
     1221            ("You have not installed Mondo and/or Mindi properly.");
     1222        log_to_screen("Please uninstall and reinstall them both.");
     1223        fatal_error("Please reinstall Mondo and Mindi.");
     1224    }
     1225    if (run_program_and_log_output
     1226        ("mindi --makemountlist /tmp/mountlist.txt.test", 5)) {
     1227        log_to_screen
     1228            ("Mindi --makemountlist /tmp/mountlist.txt.test failed for some reason.");
     1229        log_to_screen
     1230            ("Please run that command by hand and examine /var/log/mindi.log");
     1231        log_to_screen
     1232            ("for more information. Perhaps your /etc/fstab file is insane.");
     1233        log_to_screen
     1234            ("Perhaps Mindi's MakeMountlist() subroutine has a bug. We'll see.");
     1235        retval++;
     1236    }
     1237
     1238    if (!run_program_and_log_output("fdisk -l | grep -i raid", 1)
     1239        && !does_file_exist("/etc/raidtab")) {
     1240        log_to_screen
     1241            ("You have RAID partitions but no /etc/raidtab - creating one from /proc/mdstat");
     1242        create_raidtab_from_mdstat("/etc/raidtab", "/proc/mdstat");
     1243    }
     1244
     1245    if (retval) {
     1246        mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
     1247    } else {
     1248        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
     1249    }
     1250    return (retval);
    12371251}
    12381252
     
    12441258 * @return 0 for success, 1 for failure.
    12451259 */
    1246 int
    1247 read_cfg_var (char *config_file, char *label, char *value)
    1248 {
    1249     /*@ buffer *******************************************************/
    1250   char command[MAX_STR_LEN*2];
    1251   char tmp[MAX_STR_LEN];
    1252 
    1253     /*@ end vars ****************************************************/
    1254 
    1255   assert_string_is_neither_NULL_nor_zerolength(config_file);
    1256   assert_string_is_neither_NULL_nor_zerolength(label);
    1257   if (!does_file_exist (config_file))
    1258     {
    1259       sprintf (tmp, "(read_cfg_var) Cannot find %s config file", config_file);
    1260       log_to_screen (tmp);
    1261       value[0] = '\0';
    1262       return (1);
    1263     }
    1264   else if (strstr(value, "/dev/") && strstr(value, "t0") && !strcmp(label, "media-dev"))
    1265     {
    1266       log_msg (2, "FYI, I shan't read new value for %s - already got %s", label, value);
    1267       return(0);
    1268     }
    1269   else
    1270     {
    1271       sprintf (command, "cat %s | grep \"%s .*\" | cut -d' ' -f2,3,4,5",
    1272            config_file, label);
    1273       strcpy (value, call_program_and_get_last_line_of_output (command));
    1274       if (strlen (value) == 0)
    1275     {
    1276       return (1);
    1277     }
    1278       else
    1279     {
    1280       return (0);
    1281     }
    1282     }
     1260int read_cfg_var(char *config_file, char *label, char *value)
     1261{
     1262    /*@ buffer ****************************************************** */
     1263    char command[MAX_STR_LEN * 2];
     1264    char tmp[MAX_STR_LEN];
     1265
     1266    /*@ end vars *************************************************** */
     1267
     1268    assert_string_is_neither_NULL_nor_zerolength(config_file);
     1269    assert_string_is_neither_NULL_nor_zerolength(label);
     1270    if (!does_file_exist(config_file)) {
     1271        sprintf(tmp, "(read_cfg_var) Cannot find %s config file",
     1272                config_file);
     1273        log_to_screen(tmp);
     1274        value[0] = '\0';
     1275        return (1);
     1276    } else if (strstr(value, "/dev/") && strstr(value, "t0")
     1277               && !strcmp(label, "media-dev")) {
     1278        log_msg(2, "FYI, I shan't read new value for %s - already got %s",
     1279                label, value);
     1280        return (0);
     1281    } else {
     1282        sprintf(command, "cat %s | grep \"%s .*\" | cut -d' ' -f2,3,4,5",
     1283                config_file, label);
     1284        strcpy(value, call_program_and_get_last_line_of_output(command));
     1285        if (strlen(value) == 0) {
     1286            return (1);
     1287        } else {
     1288            return (0);
     1289        }
     1290    }
    12831291}
    12841292
     
    12901298void remount_supermounts_if_necessary()
    12911299{
    1292   if (g_remount_cdrom_at_end)
    1293     {
    1294       run_program_and_log_output ("mount "MNT_CDROM, FALSE);
    1295     }
    1296   if (g_remount_floppy_at_end)
    1297     {
    1298       run_program_and_log_output ("mount "MNT_FLOPPY, FALSE);
    1299     }
     1300    if (g_remount_cdrom_at_end) {
     1301        run_program_and_log_output("mount " MNT_CDROM, FALSE);
     1302    }
     1303    if (g_remount_floppy_at_end) {
     1304        run_program_and_log_output("mount " MNT_FLOPPY, FALSE);
     1305    }
    13001306}
    13011307
     
    13051311void unmount_supermounts_if_necessary()
    13061312{
    1307   if (run_program_and_log_output ("mount | grep cdrom | grep super", FALSE) == 0)
    1308     {
    1309       g_remount_cdrom_at_end = TRUE;
    1310       run_program_and_log_output ("umount "MNT_CDROM, FALSE);
    1311     }
    1312   if (run_program_and_log_output ("mount | grep floppy | grep super", FALSE) == 0)
    1313     {
    1314       g_remount_floppy_at_end = TRUE;
    1315       run_program_and_log_output ("umount "MNT_FLOPPY, FALSE);
    1316     }
     1313    if (run_program_and_log_output
     1314        ("mount | grep cdrom | grep super", FALSE) == 0) {
     1315        g_remount_cdrom_at_end = TRUE;
     1316        run_program_and_log_output("umount " MNT_CDROM, FALSE);
     1317    }
     1318    if (run_program_and_log_output
     1319        ("mount | grep floppy | grep super", FALSE) == 0) {
     1320        g_remount_floppy_at_end = TRUE;
     1321        run_program_and_log_output("umount " MNT_FLOPPY, FALSE);
     1322    }
    13171323}
    13181324
     
    13201326 * Whether we had to stop autofs (if so, restart it at end).
    13211327 */
    1322 bool g_autofs_stopped=FALSE;
     1328bool g_autofs_stopped = FALSE;
    13231329
    13241330/**
     
    13421348void stop_autofs_if_necessary()
    13431349{
    1344   char tmp[MAX_STR_LEN];
    1345  
    1346   g_autofs_exe[0] = '\0';
    1347   if (does_file_exist(XANDROS_AUTOFS_FNAME))
    1348     { strcpy(g_autofs_exe, XANDROS_AUTOFS_FNAME); } 
    1349   else if (does_file_exist(STOCK_AUTOFS_FNAME))
    1350     { strcpy(g_autofs_exe, STOCK_AUTOFS_FNAME); }
    1351    
    1352   if (!g_autofs_exe[0]) { log_msg(3, "No autofs detected."); } 
    1353   else
    1354     {
    1355       log_msg(3, "%s --- autofs detected", g_autofs_exe);
     1350    char tmp[MAX_STR_LEN];
     1351
     1352    g_autofs_exe[0] = '\0';
     1353    if (does_file_exist(XANDROS_AUTOFS_FNAME)) {
     1354        strcpy(g_autofs_exe, XANDROS_AUTOFS_FNAME);
     1355    } else if (does_file_exist(STOCK_AUTOFS_FNAME)) {
     1356        strcpy(g_autofs_exe, STOCK_AUTOFS_FNAME);
     1357    }
     1358
     1359    if (!g_autofs_exe[0]) {
     1360        log_msg(3, "No autofs detected.");
     1361    } else {
     1362        log_msg(3, "%s --- autofs detected", g_autofs_exe);
    13561363// FIXME -- only disable it if it's running ---  sprintf(tmp, "%s status", autofs_exe);
    1357       sprintf(tmp, "%s stop", g_autofs_exe);
    1358       if (run_program_and_log_output(tmp, 2))
    1359         { log_it("Failed to stop autofs - I assume it wasn't running"); }
    1360       else
    1361         { g_autofs_stopped = TRUE; log_it("Stopped autofs OK"); }
    1362     }
     1364        sprintf(tmp, "%s stop", g_autofs_exe);
     1365        if (run_program_and_log_output(tmp, 2)) {
     1366            log_it("Failed to stop autofs - I assume it wasn't running");
     1367        } else {
     1368            g_autofs_stopped = TRUE;
     1369            log_it("Stopped autofs OK");
     1370        }
     1371    }
    13631372}
    13641373
     
    13681377void restart_autofs_if_necessary()
    13691378{
    1370   char tmp[MAX_STR_LEN];
    1371  
    1372   if (!g_autofs_stopped || !g_autofs_exe[0]) { log_msg(3, "No autofs detected."); return; } 
    1373   sprintf(tmp, "%s start", g_autofs_exe);
    1374   if (run_program_and_log_output(tmp, 2))
    1375     { log_it("Failed to start autofs"); }
    1376   else
    1377     { g_autofs_stopped = FALSE; log_it("Started autofs OK"); }
     1379    char tmp[MAX_STR_LEN];
     1380
     1381    if (!g_autofs_stopped || !g_autofs_exe[0]) {
     1382        log_msg(3, "No autofs detected.");
     1383        return;
     1384    }
     1385    sprintf(tmp, "%s start", g_autofs_exe);
     1386    if (run_program_and_log_output(tmp, 2)) {
     1387        log_it("Failed to start autofs");
     1388    } else {
     1389        g_autofs_stopped = FALSE;
     1390        log_it("Started autofs OK");
     1391    }
    13781392}
    13791393
     
    13841398void mount_boot_if_necessary()
    13851399{
    1386   char tmp[MAX_STR_LEN];
    1387   char command[MAX_STR_LEN];
    1388 
    1389   log_msg(1, "Started sub");
    1390   log_msg(4, "About to set g_boot_mountpt[0] to '\\0'");
    1391   g_boot_mountpt[0] = '\0';
    1392   log_msg(4, "Done. Great. Seeting command to something");
    1393   strcpy(command, "cat /etc/fstab | grep -v \":\" | grep -vx \"#.*\" | grep -w \"/boot\" | tr -s ' ' '\t' | cut -f1 | head -n1");
    1394   log_msg(4, "Cool. Command = '%s'", command);
    1395   strcpy(tmp, call_program_and_get_last_line_of_output(command));
    1396   log_msg(4, "tmp = '%s'", tmp);
    1397   if (tmp[0])
    1398     {
    1399       log_it("/boot is at %s according to /etc/fstab", tmp);
    1400       if (strstr(tmp, "LABEL="))
    1401         {
    1402       if (!run_program_and_log_output("mount /boot", 5))
    1403         {
    1404           strcpy(g_boot_mountpt, "/boot");
    1405           log_msg(1, "Mounted /boot");
    1406         }
    1407       else
    1408         {
    1409           log_it("...ignored cos it's a label :-)");
    1410         }
    1411     }
    1412       else
    1413         {
    1414           sprintf(command, "mount | grep -w \"%s\"", tmp);
    1415           log_msg(3, "command = %s", command);
    1416           if (run_program_and_log_output(command, 5))
    1417             {
    1418           strcpy(g_boot_mountpt, tmp);
    1419               sprintf(tmp, "%s (your /boot partition) is not mounted. I'll mount it before backing up", g_boot_mountpt);
    1420           log_it(tmp);
    1421           sprintf(tmp, "mount %s", g_boot_mountpt);
    1422           if (run_program_and_log_output(tmp, 5))
    1423         {
    1424           g_boot_mountpt[0] = '\0';
    1425           log_msg(1, "Plan B");
    1426           if (!run_program_and_log_output("mount /boot", 5))
    1427             {
    1428               strcpy(g_boot_mountpt, "/boot");
    1429               log_msg(1, "Plan B worked");
    1430             }
    1431           else
    1432             {
    1433               log_msg(1, "Plan B failed. Unable to mount /boot for backup purposes. This probably means /boot is mounted already, or doesn't have its own partition.");
    1434             }
    1435         }
    1436             }
    1437         }
    1438     }
    1439   log_msg(1, "Ended sub");
     1400    char tmp[MAX_STR_LEN];
     1401    char command[MAX_STR_LEN];
     1402
     1403    log_msg(1, "Started sub");
     1404    log_msg(4, "About to set g_boot_mountpt[0] to '\\0'");
     1405    g_boot_mountpt[0] = '\0';
     1406    log_msg(4, "Done. Great. Seeting command to something");
     1407    strcpy(command,
     1408           "cat /etc/fstab | grep -v \":\" | grep -vx \"#.*\" | grep -w \"/boot\" | tr -s ' ' '\t' | cut -f1 | head -n1");
     1409    log_msg(4, "Cool. Command = '%s'", command);
     1410    strcpy(tmp, call_program_and_get_last_line_of_output(command));
     1411    log_msg(4, "tmp = '%s'", tmp);
     1412    if (tmp[0]) {
     1413        log_it("/boot is at %s according to /etc/fstab", tmp);
     1414        if (strstr(tmp, "LABEL=")) {
     1415            if (!run_program_and_log_output("mount /boot", 5)) {
     1416                strcpy(g_boot_mountpt, "/boot");
     1417                log_msg(1, "Mounted /boot");
     1418            } else {
     1419                log_it("...ignored cos it's a label :-)");
     1420            }
     1421        } else {
     1422            sprintf(command, "mount | grep -w \"%s\"", tmp);
     1423            log_msg(3, "command = %s", command);
     1424            if (run_program_and_log_output(command, 5)) {
     1425                strcpy(g_boot_mountpt, tmp);
     1426                sprintf(tmp,
     1427                        "%s (your /boot partition) is not mounted. I'll mount it before backing up",
     1428                        g_boot_mountpt);
     1429                log_it(tmp);
     1430                sprintf(tmp, "mount %s", g_boot_mountpt);
     1431                if (run_program_and_log_output(tmp, 5)) {
     1432                    g_boot_mountpt[0] = '\0';
     1433                    log_msg(1, "Plan B");
     1434                    if (!run_program_and_log_output("mount /boot", 5)) {
     1435                        strcpy(g_boot_mountpt, "/boot");
     1436                        log_msg(1, "Plan B worked");
     1437                    } else {
     1438                        log_msg(1,
     1439                                "Plan B failed. Unable to mount /boot for backup purposes. This probably means /boot is mounted already, or doesn't have its own partition.");
     1440                    }
     1441                }
     1442            }
     1443        }
     1444    }
     1445    log_msg(1, "Ended sub");
    14401446}
    14411447
     
    14461452void unmount_boot_if_necessary()
    14471453{
    1448   char tmp[MAX_STR_LEN];
    1449 
    1450   log_msg(3, "starting");
    1451   if (g_boot_mountpt[0])
    1452     {
    1453       sprintf(tmp, "umount %s", g_boot_mountpt);
    1454       if (run_program_and_log_output(tmp, 5))
    1455     { log_it("WARNING - unable to unmount /boot"); }
    1456     }
    1457    log_msg(3, "leaving");
     1454    char tmp[MAX_STR_LEN];
     1455
     1456    log_msg(3, "starting");
     1457    if (g_boot_mountpt[0]) {
     1458        sprintf(tmp, "umount %s", g_boot_mountpt);
     1459        if (run_program_and_log_output(tmp, 5)) {
     1460            log_it("WARNING - unable to unmount /boot");
     1461        }
     1462    }
     1463    log_msg(3, "leaving");
    14581464}
    14591465
     
    14681474 * @return 0 for success, 1 for failure.
    14691475 */
    1470 int
    1471 write_cfg_var (char *config_file, char *label, char *value)
    1472 {
    1473     /*@ buffers ******************************************************/
    1474   char command[MAX_STR_LEN*2];
    1475   char tempfile[MAX_STR_LEN];
    1476   char tmp[MAX_STR_LEN];
    1477 
    1478 
    1479     /*@ end vars ****************************************************/
    1480   assert_string_is_neither_NULL_nor_zerolength(config_file);
    1481   assert_string_is_neither_NULL_nor_zerolength(label);
    1482   assert(value!=NULL);
    1483   if (!does_file_exist (config_file))
    1484     {
    1485       sprintf (tmp, "(write_cfg_file) Cannot find %s config file",
    1486            config_file);
    1487       log_to_screen (tmp);
    1488       return(1);
    1489     }
    1490   strcpy (tempfile,
    1491       call_program_and_get_last_line_of_output
    1492       ("mktemp -q /tmp/mojo-jojo.blah.XXXXXX"));
    1493   if (does_file_exist (config_file))
    1494     {
    1495       sprintf (command, "cat %s | grep -vx \"%s .*\" > %s", config_file,
    1496            label, tempfile);
    1497       paranoid_system (command);
    1498     }
    1499   sprintf (command, "echo \"%s %s\" >> %s", label, value, tempfile);
    1500   paranoid_system (command);
    1501   sprintf (command, "mv -f %s %s", tempfile, config_file);
    1502   paranoid_system (command);
    1503   unlink (tempfile);
    1504   return (0);
     1476int write_cfg_var(char *config_file, char *label, char *value)
     1477{
     1478    /*@ buffers ***************************************************** */
     1479    char command[MAX_STR_LEN * 2];
     1480    char tempfile[MAX_STR_LEN];
     1481    char tmp[MAX_STR_LEN];
     1482
     1483
     1484    /*@ end vars *************************************************** */
     1485    assert_string_is_neither_NULL_nor_zerolength(config_file);
     1486    assert_string_is_neither_NULL_nor_zerolength(label);
     1487    assert(value != NULL);
     1488    if (!does_file_exist(config_file)) {
     1489        sprintf(tmp, "(write_cfg_file) Cannot find %s config file",
     1490                config_file);
     1491        log_to_screen(tmp);
     1492        return (1);
     1493    }
     1494    strcpy(tempfile,
     1495           call_program_and_get_last_line_of_output
     1496           ("mktemp -q /tmp/mojo-jojo.blah.XXXXXX"));
     1497    if (does_file_exist(config_file)) {
     1498        sprintf(command, "cat %s | grep -vx \"%s .*\" > %s", config_file,
     1499                label, tempfile);
     1500        paranoid_system(command);
     1501    }
     1502    sprintf(command, "echo \"%s %s\" >> %s", label, value, tempfile);
     1503    paranoid_system(command);
     1504    sprintf(command, "mv -f %s %s", tempfile, config_file);
     1505    paranoid_system(command);
     1506    unlink(tempfile);
     1507    return (0);
    15051508}
    15061509
     
    15111514 */
    15121515void standard_log_debug_msg(int debug_level, const char *szFile,
    1513                 const char *szFunction, int nLine, const char *fmt, ...)
    1514 {
    1515   va_list args;
    1516   int i;
    1517   static int depth=0; 
    1518   char *tmp;
    1519   FILE*fout;
    1520 
    1521   if (depth>5) { depth--; return; }
    1522   depth++;
    1523 
    1524   malloc_string(tmp);
    1525 
    1526   if (debug_level <= g_loglevel)
    1527     {
    1528       va_start(args, fmt);
    1529       if (!(fout = fopen (MONDO_LOGFILE, "a")))
    1530     { return; } // fatal_error("Failed to openout to logfile - sheesh..."); }
    1531 
    1532       // add tabs to distinguish log levels
    1533       if (debug_level > 0)
    1534     {
    1535       for (i = 1; i < debug_level; i++)
    1536         fprintf(fout, "\t");
    1537       if (getpid() == g_main_pid)
    1538         fprintf(fout, "[Main] %s->%s#%d: ", szFile, szFunction, nLine);
    1539       else if (getpid() == g_buffer_pid && g_buffer_pid>0)
    1540         fprintf(fout, "[Buff] %s->%s#%d: ", szFile, szFunction, nLine);
    1541       else
    1542         fprintf(fout, "[TH=%d] %s->%s#%d: ", getpid(), szFile, szFunction, nLine);
    1543     }
    1544       vfprintf(fout, fmt, args);
    1545 
    1546     // do not slow down the progran if standard debug level
    1547     // must be enabled: if no flush, the log won't be up-to-date if there
    1548     // is a segfault
    1549     //if (g_dwDebugLevel != 1)
    1550 
    1551       va_end(args);
    1552       fprintf(fout, "\n");
    1553       paranoid_fclose(fout);
    1554     }
    1555   depth--;
    1556   paranoid_free(tmp);
     1516                            const char *szFunction, int nLine,
     1517                            const char *fmt, ...)
     1518{
     1519    va_list args;
     1520    int i;
     1521    static int depth = 0;
     1522    char *tmp;
     1523    FILE *fout;
     1524
     1525    if (depth > 5) {
     1526        depth--;
     1527        return;
     1528    }
     1529    depth++;
     1530
     1531    malloc_string(tmp);
     1532
     1533    if (debug_level <= g_loglevel) {
     1534        va_start(args, fmt);
     1535        if (!(fout = fopen(MONDO_LOGFILE, "a"))) {
     1536            return;
     1537        }                       // fatal_error("Failed to openout to logfile - sheesh..."); }
     1538
     1539        // add tabs to distinguish log levels
     1540        if (debug_level > 0) {
     1541            for (i = 1; i < debug_level; i++)
     1542                fprintf(fout, "\t");
     1543            if (getpid() == g_main_pid)
     1544                fprintf(fout, "[Main] %s->%s#%d: ", szFile, szFunction,
     1545                        nLine);
     1546            else if (getpid() == g_buffer_pid && g_buffer_pid > 0)
     1547                fprintf(fout, "[Buff] %s->%s#%d: ", szFile, szFunction,
     1548                        nLine);
     1549            else
     1550                fprintf(fout, "[TH=%d] %s->%s#%d: ", getpid(), szFile,
     1551                        szFunction, nLine);
     1552        }
     1553        vfprintf(fout, fmt, args);
     1554
     1555        // do not slow down the progran if standard debug level
     1556        // must be enabled: if no flush, the log won't be up-to-date if there
     1557        // is a segfault
     1558        //if (g_dwDebugLevel != 1)
     1559
     1560        va_end(args);
     1561        fprintf(fout, "\n");
     1562        paranoid_fclose(fout);
     1563    }
     1564    depth--;
     1565    paranoid_free(tmp);
    15571566}
    15581567
     
    15601569 * Function pointer to the @c log_debug_msg function to use. Points to standard_log_debug_msg() by default.
    15611570 */
    1562 void (*log_debug_msg) (int, const char *, const char *, int, const char *, ...) = standard_log_debug_msg;
     1571void (*log_debug_msg) (int, const char *, const char *, int, const char *,
     1572                       ...) = standard_log_debug_msg;
    15631573
    15641574
     
    15751585void do_libmondo_global_strings_thing(int mal)
    15761586{
    1577   if (mal)
    1578     {
    1579       iamhere("Malloc'ing globals");
    1580       malloc_string(g_boot_mountpt);
    1581       malloc_string(g_mondo_home);
    1582       malloc_string(g_tmpfs_mountpt);
    1583       malloc_string(g_erase_tmpdir_and_scratchdir);
    1584       malloc_string(g_serial_string);
    1585       malloc_string(g_magicdev_command);
    1586     }
    1587   else
    1588     {
    1589       iamhere("Freeing globals");
    1590       paranoid_free(g_boot_mountpt);
    1591       paranoid_free(g_mondo_home);
    1592       paranoid_free(g_tmpfs_mountpt);
    1593       paranoid_free(g_erase_tmpdir_and_scratchdir);
    1594       paranoid_free(g_serial_string);
    1595       paranoid_free(g_magicdev_command);
    1596     }
    1597 
    1598   /*
    1599   char**list_of_arrays[] = {
    1600     &g_boot_mountpt,
    1601     &g_mondo_home,
    1602     &g_tmpfs_mountpt,
    1603     &g_erase_tmpdir_and_scratchdir,
    1604     &g_serial_string,
    1605     &g_magicdev_command,
    1606     NULL};
    1607 
    1608   char**ppcurr;
    1609   int i;
    1610  
    1611   for(i=0;list_of_arrays[i];i++)
    1612     {
    1613       log_msg(5, "Allocating %d", i);
    1614       ppcurr = list_of_arrays[i];
    1615       if (mal)
    1616         { *ppcurr = malloc(MAX_STR_LEN); }
    1617       else
    1618         {
    1619       if (*ppcurr)
    1620         {
    1621           free(*ppcurr);
    1622         }
    1623     }
    1624     }
    1625   log_msg(5, "Returning");
    1626   */
     1587    if (mal) {
     1588        iamhere("Malloc'ing globals");
     1589        malloc_string(g_boot_mountpt);
     1590        malloc_string(g_mondo_home);
     1591        malloc_string(g_tmpfs_mountpt);
     1592        malloc_string(g_erase_tmpdir_and_scratchdir);
     1593        malloc_string(g_serial_string);
     1594        malloc_string(g_magicdev_command);
     1595    } else {
     1596        iamhere("Freeing globals");
     1597        paranoid_free(g_boot_mountpt);
     1598        paranoid_free(g_mondo_home);
     1599        paranoid_free(g_tmpfs_mountpt);
     1600        paranoid_free(g_erase_tmpdir_and_scratchdir);
     1601        paranoid_free(g_serial_string);
     1602        paranoid_free(g_magicdev_command);
     1603    }
     1604
     1605    /*
     1606       char**list_of_arrays[] = {
     1607       &g_boot_mountpt,
     1608       &g_mondo_home,
     1609       &g_tmpfs_mountpt,
     1610       &g_erase_tmpdir_and_scratchdir,
     1611       &g_serial_string,
     1612       &g_magicdev_command,
     1613       NULL};
     1614
     1615       char**ppcurr;
     1616       int i;
     1617
     1618       for(i=0;list_of_arrays[i];i++)
     1619       {
     1620       log_msg(5, "Allocating %d", i);
     1621       ppcurr = list_of_arrays[i];
     1622       if (mal)
     1623       { *ppcurr = malloc(MAX_STR_LEN); }
     1624       else
     1625       {
     1626       if (*ppcurr)
     1627       {
     1628       free(*ppcurr);
     1629       }
     1630       }
     1631       }
     1632       log_msg(5, "Returning");
     1633     */
    16271634}
    16281635
     
    16331640void malloc_libmondo_global_strings(void)
    16341641{
    1635   do_libmondo_global_strings_thing(1);
     1642    do_libmondo_global_strings_thing(1);
    16361643}
    16371644
     
    16421649void free_libmondo_global_strings(void)
    16431650{
    1644   do_libmondo_global_strings_thing(0);
     1651    do_libmondo_global_strings_thing(0);
    16451652}
    16461653
     
    16531660void stop_magicdev_if_necessary()
    16541661{
    1655   strcpy(g_magicdev_command, call_program_and_get_last_line_of_output("ps ax | grep -w magicdev | grep -v grep | tr -s '\t' ' '| cut -d' ' -f6-99"));
    1656   if (g_magicdev_command[0])
    1657     {
    1658       log_msg(1, "g_magicdev_command = '%s'", g_magicdev_command);
    1659       paranoid_system("killall magicdev");
    1660     }
     1662    strcpy(g_magicdev_command,
     1663           call_program_and_get_last_line_of_output
     1664           ("ps ax | grep -w magicdev | grep -v grep | tr -s '\t' ' '| cut -d' ' -f6-99"));
     1665    if (g_magicdev_command[0]) {
     1666        log_msg(1, "g_magicdev_command = '%s'", g_magicdev_command);
     1667        paranoid_system("killall magicdev");
     1668    }
    16611669}
    16621670
     
    16671675void restart_magicdev_if_necessary()
    16681676{
    1669   char *tmp;
    1670  
    1671   malloc_string(tmp);
    1672   if (g_magicdev_command && g_magicdev_command[0])
    1673     {
    1674       sprintf(tmp, "%s &", g_magicdev_command);
    1675       paranoid_system(tmp);
    1676     }
    1677   paranoid_free(tmp);
     1677    char *tmp;
     1678
     1679    malloc_string(tmp);
     1680    if (g_magicdev_command && g_magicdev_command[0]) {
     1681        sprintf(tmp, "%s &", g_magicdev_command);
     1682        paranoid_system(tmp);
     1683    }
     1684    paranoid_free(tmp);
    16781685}
    16791686
Note: See TracChangeset for help on using the changeset viewer.