Changeset 106 for branches/2.04_berlios


Ignore:
Timestamp:
Nov 6, 2005, 3:51:10 AM (14 years ago)
Author:
andree
Message:

Fixed command line parsing so that option '-C' (CD streaming) takes
an argument for the media write speed to bring things inline with the
manpage and the behaviour for other write options.

See also Debian bug #269072.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/2.04_berlios/mondo/mondo/mondoarchive/mondo-cli.c

    r30 r106  
    77edited by            : by Stan Benoit 4/2002
    88email                : troff@nakedsoul.org
    9 cvsid                : $Id: mondo-cli.c,v 1.11 2004/06/21 20:20:36 hugo Exp $
     9cvsid                : $Id$
    1010 ***************************************************************************/
    1111
     
    175175
    176176
    177 //static char cvsid[] = "$Id: mondo-cli.c,v 1.11 2004/06/21 20:20:36 hugo Exp $";
     177//static char cvsid[] = "$Id$";
    178178
    179179extern int g_loglevel;
    180180extern bool g_text_mode;
    181 extern bool g_skip_floppies; ///< Whether to skip the creation of boot disks
    182 extern char g_startdir[MAX_STR_LEN]; ///< ????? @bug ?????
     181extern bool g_skip_floppies;    ///< Whether to skip the creation of boot disks
     182extern char g_startdir[MAX_STR_LEN];    ///< ????? @bug ?????
    183183extern char g_erase_tmpdir_and_scratchdir[MAX_STR_LEN];
    184184extern char g_tmpfs_mountpt[MAX_STR_LEN];
     
    195195
    196196/*@ bool******** **************************************************/
    197 bool g_debugging = FALSE; ///< ????? @bug ????? @ingroup globalGroup
    198 bool g_running_live = FALSE; ///< ????? @bug ????? @ingroup globalGroup
     197bool g_debugging = FALSE;       ///< ????? @bug ????? @ingroup globalGroup
     198bool g_running_live = FALSE;    ///< ????? @bug ????? @ingroup globalGroup
    199199extern bool g_cd_recovery;
    200200
     
    220220
    221221
    222 extern char*resolve_softlinks_to_get_to_actual_device_file(char*);
     222extern char *resolve_softlinks_to_get_to_actual_device_file(char *);
    223223
    224224
     
    236236 */
    237237int
    238 handle_incoming_parameters (int argc, char *argv[], struct s_bkpinfo *bkpinfo)
     238handle_incoming_parameters(int argc, char *argv[],
     239                           struct s_bkpinfo *bkpinfo)
    239240{
    240     /*@ int ****/
    241   int res = 0;
    242   int retval = 0;
    243   int i = 0, j;
    244 
    245     /*@ buffers ****************/
    246   char *tmp;
    247   char flag_val[128][MAX_STR_LEN];
    248   bool flag_set[128];
    249 
    250   malloc_string(tmp);
    251   sensibly_set_tmpdir_and_scratchdir(bkpinfo);
    252   for (i = 0; i < 128; i++)
    253     {
    254       flag_val[i][0] = '\0';
    255       flag_set[i] = FALSE;
    256     }
    257   //  strcpy (bkpinfo->tmpdir, "/root/images/mondo");
    258   //  strcpy (bkpinfo->scratchdir, "/home");
    259   for(j=1; j<=MAX_NOOF_MEDIA; j++) {bkpinfo->media_size[j] = 650;}  /* default */
    260   res = retrieve_switches_from_command_line (argc, argv, flag_val, flag_set);
    261   retval += res;
    262   if (!retval)
    263     {
    264       res = process_switches (bkpinfo, flag_val, flag_set);
    265       retval += res;
    266     }
     241    /*@ int *** */
     242    int res = 0;
     243    int retval = 0;
     244    int i = 0, j;
     245
     246    /*@ buffers *************** */
     247    char *tmp;
     248    char flag_val[128][MAX_STR_LEN];
     249    bool flag_set[128];
     250
     251    malloc_string(tmp);
     252    sensibly_set_tmpdir_and_scratchdir(bkpinfo);
     253    for (i = 0; i < 128; i++) {
     254        flag_val[i][0] = '\0';
     255        flag_set[i] = FALSE;
     256    }
     257    //  strcpy (bkpinfo->tmpdir, "/root/images/mondo");
     258    //  strcpy (bkpinfo->scratchdir, "/home");
     259    for (j = 1; j <= MAX_NOOF_MEDIA; j++) {
     260        bkpinfo->media_size[j] = 650;
     261    }                           /* default */
     262    res =
     263        retrieve_switches_from_command_line(argc, argv, flag_val,
     264                                            flag_set);
     265    retval += res;
     266    if (!retval) {
     267        res = process_switches(bkpinfo, flag_val, flag_set);
     268        retval += res;
     269    }
    267270/*
    268271  if (!retval)
    269272    {
    270273*/
    271       log_msg (3, "Switches:-");
    272       for (i = 0; i < 128; i++)
    273     {
    274       if (flag_set[i])
    275         {
    276           sprintf (tmp, "-%c %s", i, flag_val[i]);
    277           log_msg (3, tmp);
    278         }
     274    log_msg(3, "Switches:-");
     275    for (i = 0; i < 128; i++) {
     276        if (flag_set[i]) {
     277            sprintf(tmp, "-%c %s", i, flag_val[i]);
     278            log_msg(3, tmp);
     279        }
    279280    }
    280281//    }
    281   sprintf (tmp, "rm -Rf %s/tmp.mondo.*", bkpinfo->tmpdir);
    282   paranoid_system (tmp);
    283   sprintf (tmp, "rm -Rf %s/mondo.scratch.*", bkpinfo->scratchdir);
    284   paranoid_system (tmp);
    285   sprintf (bkpinfo->tmpdir + strlen (bkpinfo->tmpdir), "/tmp.mondo.%ld",
    286        random () % 32767);
    287   sprintf (bkpinfo->scratchdir + strlen (bkpinfo->scratchdir),
    288        "/mondo.scratch.%ld", random () % 32767);
    289   sprintf (tmp, "mkdir -p %s/tmpfs", bkpinfo->tmpdir);
    290   paranoid_system (tmp);
    291   sprintf (tmp, "mkdir -p %s", bkpinfo->scratchdir);
    292   paranoid_system (tmp);
    293   if (bkpinfo->nfs_mount[0] != '\0')
    294     {
    295       store_nfs_config (bkpinfo);
    296     }
    297   paranoid_free(tmp);
    298   return (retval);
     282    sprintf(tmp, "rm -Rf %s/tmp.mondo.*", bkpinfo->tmpdir);
     283    paranoid_system(tmp);
     284    sprintf(tmp, "rm -Rf %s/mondo.scratch.*", bkpinfo->scratchdir);
     285    paranoid_system(tmp);
     286    sprintf(bkpinfo->tmpdir + strlen(bkpinfo->tmpdir), "/tmp.mondo.%ld",
     287            random() % 32767);
     288    sprintf(bkpinfo->scratchdir + strlen(bkpinfo->scratchdir),
     289            "/mondo.scratch.%ld", random() % 32767);
     290    sprintf(tmp, "mkdir -p %s/tmpfs", bkpinfo->tmpdir);
     291    paranoid_system(tmp);
     292    sprintf(tmp, "mkdir -p %s", bkpinfo->scratchdir);
     293    paranoid_system(tmp);
     294    if (bkpinfo->nfs_mount[0] != '\0') {
     295        store_nfs_config(bkpinfo);
     296    }
     297    paranoid_free(tmp);
     298    return (retval);
    299299}
    300300
     
    311311int process_the_s_switch(struct s_bkpinfo *bkpinfo, char *value)
    312312{
    313       int j;
    314       char tmp[MAX_STR_LEN], *p, comment[MAX_STR_LEN];
    315 
    316   assert(bkpinfo!=NULL);
    317   assert(value!=NULL);
    318 
    319       bkpinfo->media_size[0] = -1; /* dummy value */
    320       for(j=1, p=value; j<MAX_NOOF_MEDIA && strchr(p,','); j++, p=strchr(p,',')+1)
    321     {
    322       strncpy(tmp, p, MAX_STR_LEN);
    323       *(strchr(tmp,',')) = '\0';
    324       bkpinfo->media_size[j] = friendly_sizestr_to_sizelong (tmp);
    325           sprintf(comment, "media_size[%d] = %ld", j, bkpinfo->media_size[j]);
    326           log_msg(3, comment);
    327     }
    328       for(; j<=MAX_NOOF_MEDIA; j++)
    329     {
    330       bkpinfo->media_size[j] = friendly_sizestr_to_sizelong (p);
     313    int j;
     314    char tmp[MAX_STR_LEN], *p, comment[MAX_STR_LEN];
     315
     316    assert(bkpinfo != NULL);
     317    assert(value != NULL);
     318
     319    bkpinfo->media_size[0] = -1;    /* dummy value */
     320    for (j = 1, p = value; j < MAX_NOOF_MEDIA && strchr(p, ',');
     321         j++, p = strchr(p, ',') + 1) {
     322        strncpy(tmp, p, MAX_STR_LEN);
     323        *(strchr(tmp, ',')) = '\0';
     324        bkpinfo->media_size[j] = friendly_sizestr_to_sizelong(tmp);
     325        sprintf(comment, "media_size[%d] = %ld", j,
     326                bkpinfo->media_size[j]);
     327        log_msg(3, comment);
     328    }
     329    for (; j <= MAX_NOOF_MEDIA; j++) {
     330        bkpinfo->media_size[j] = friendly_sizestr_to_sizelong(p);
    331331    }
    332332//      bkpinfo->media_size[0] = bkpinfo->media_size[MAX_NOOF_MEDIA];
    333       for(j=1; j<=MAX_NOOF_MEDIA; j++)
    334         {
    335           if (bkpinfo->media_size[j]<=0) { log_msg(1, "You gave media #%d an invalid size\n", j); return(-1); }
    336         }
    337       return(0);
     333    for (j = 1; j <= MAX_NOOF_MEDIA; j++) {
     334        if (bkpinfo->media_size[j] <= 0) {
     335            log_msg(1, "You gave media #%d an invalid size\n", j);
     336            return (-1);
     337        }
     338    }
     339    return (0);
    338340}
    339341
     
    351353 */
    352354int
    353 process_switches (struct s_bkpinfo *bkpinfo, char flag_val[128][MAX_STR_LEN],
    354           bool flag_set[128])
     355process_switches(struct s_bkpinfo *bkpinfo,
     356                 char flag_val[128][MAX_STR_LEN], bool flag_set[128])
    355357{
    356358
    357     /*@ ints ****/
    358   int i = 0;
    359   int retval = 0;
    360   int percent = 0;
    361 
    362     /*@ buffers ***/
    363   char *tmp;
    364   char *psz;
    365 
    366   long itbs;
    367 
    368   malloc_string(tmp);
    369   malloc_string(psz);
    370 
    371   assert(bkpinfo!=NULL);
    372   assert(flag_val!=NULL);
    373   assert(flag_set!=NULL);
    374 
    375   bkpinfo->internal_tape_block_size = DEFAULT_INTERNAL_TAPE_BLOCK_SIZE;
     359    /*@ ints *** */
     360    int i = 0;
     361    int retval = 0;
     362    int percent = 0;
     363
     364    /*@ buffers ** */
     365    char *tmp;
     366    char *psz;
     367
     368    long itbs;
     369
     370    malloc_string(tmp);
     371    malloc_string(psz);
     372
     373    assert(bkpinfo != NULL);
     374    assert(flag_val != NULL);
     375    assert(flag_set != NULL);
     376
     377    bkpinfo->internal_tape_block_size = DEFAULT_INTERNAL_TAPE_BLOCK_SIZE;
    376378
    377379/* compulsory */
    378   i =
    379     flag_set['c'] + flag_set['i'] + flag_set['n'] +
    380     flag_set['t'] + flag_set['u'] + flag_set['r'] +
    381     flag_set['w'] + flag_set['C'];
    382   if (i == 0)
    383     {
    384       retval++;
    385       log_to_screen( "You must specify the media type\n");
    386     }
    387   if (i > 1)
    388     {
    389       retval++;
    390       log_to_screen( "Please specify only one media type\n");
    391     }
    392   if (flag_set['K'])
    393     {
    394       g_loglevel = atoi(flag_val['K']);
    395       if (g_loglevel < 3) { g_loglevel = 3; }
    396     }
    397   if (flag_set['L'] && flag_set['0'])
    398     {
    399       retval++;
    400       log_to_screen( "You cannot have 'no compression' _and_ LZOP.\n");
    401     }
    402   bkpinfo->backup_data = flag_set['O'];
    403   bkpinfo->verify_data = flag_set['V'];
    404   if (flag_set['I'] && !bkpinfo->backup_data)
    405     {
    406       log_to_screen ("-I switch is ignored if just verifying");
    407     }
    408   if (flag_set['E'] && !bkpinfo->backup_data)
    409     {
    410       log_to_screen ("-E switch is ignored if just verifying");
    411     }
    412 
    413   if (!find_home_of_exe("afio"))
    414     {
    415       if (find_home_of_exe("star"))
     380    i = flag_set['c'] + flag_set['i'] + flag_set['n'] +
     381        flag_set['t'] + flag_set['u'] + flag_set['r'] +
     382        flag_set['w'] + flag_set['C'];
     383    if (i == 0) {
     384        retval++;
     385        log_to_screen("You must specify the media type\n");
     386    }
     387    if (i > 1) {
     388        retval++;
     389        log_to_screen("Please specify only one media type\n");
     390    }
     391    if (flag_set['K']) {
     392        g_loglevel = atoi(flag_val['K']);
     393        if (g_loglevel < 3) {
     394            g_loglevel = 3;
     395        }
     396    }
     397    if (flag_set['L'] && flag_set['0']) {
     398        retval++;
     399        log_to_screen("You cannot have 'no compression' _and_ LZOP.\n");
     400    }
     401    bkpinfo->backup_data = flag_set['O'];
     402    bkpinfo->verify_data = flag_set['V'];
     403    if (flag_set['I'] && !bkpinfo->backup_data) {
     404        log_to_screen("-I switch is ignored if just verifying");
     405    }
     406    if (flag_set['E'] && !bkpinfo->backup_data) {
     407        log_to_screen("-E switch is ignored if just verifying");
     408    }
     409
     410    if (!find_home_of_exe("afio")) {
     411        if (find_home_of_exe("star")) {
     412            flag_set['R'] = TRUE;
     413            log_msg(1, "Using star instead of afio");
     414        } else {
     415            fatal_error
     416                ("Neither afio nor star is installed. Please install at least one.");
     417        }
     418    }
     419
     420    if (flag_set['R']) {
     421        bkpinfo->use_star = TRUE;
     422        if (flag_set['L']) {
     423            fatal_error("You may not use star and lzop at the same time.");
     424        }
     425        if (!find_home_of_exe("star")) {
     426            fatal_error
     427                ("Please install 'star' RPM or tarball if you are going to use -R. Thanks.");
     428        }
     429    }
     430    if (flag_set['W']) {
     431        bkpinfo->nonbootable_backup = TRUE;
     432        log_to_screen("Warning - you have opted for non-bootable backup");
     433        if (flag_set['f'] || flag_set['l']) {
     434            log_to_screen
     435                ("You don't need to specify bootloader or bootdevice");
     436        }
     437    }
     438    if (flag_set['t'] && flag_set['H']) {
     439        fatal_error
     440            ("Sorry, you may not nuke w/o warning from tape. Drop -H, please.");
     441    }
     442    if (flag_set['I']) {
     443        if (!strcmp(bkpinfo->include_paths, "/")) {
     444            log_msg(2, "'/' is pleonastic.");
     445            bkpinfo->include_paths[0] = '\0';
     446        }
     447        if (bkpinfo->include_paths[0]) {
     448            strcat(bkpinfo->include_paths, " ");
     449        }
     450        strncpy(bkpinfo->include_paths + strlen(bkpinfo->include_paths),
     451                flag_val['I'],
     452                MAX_STR_LEN - strlen(bkpinfo->include_paths));
     453        log_msg(1, "include_paths is now '%s'", bkpinfo->include_paths);
     454        if (bkpinfo->include_paths[0] == '-') {
     455            retval++;
     456            log_to_screen("Please supply a sensible value with '-I'\n");
     457        }
     458    }
     459
     460    if (g_kernel_version >= 2.6 && !flag_set['d']
     461        && (flag_set['c'] || flag_set['w'])) {
     462        fatal_error
     463            ("If you are using the 2.6.x kernel, please specify the CD-R(W) device.");
     464    }
     465
     466
     467    if (flag_set['J']) {
     468        if (flag_set['I']) {
     469            retval++;
     470            log_to_screen
     471                ("Please do not use -J in combination with -I. If you want to make a list of files to backup, that's fine, use -J <filename> but please don't muddy the waters by combining -J with -I. Thanks. :-)");
     472        }
     473        bkpinfo->make_filelist = FALSE;
     474        strcpy(bkpinfo->include_paths, flag_val['J']);
     475    }
     476    if (flag_set['c'] || flag_set['w'] || flag_set['C'] || flag_set['r']) {
     477        if (!flag_set['r'] && g_kernel_version <= 2.5
     478            && strstr(flag_val['d'], "/dev/")) {
     479            fatal_error
     480                ("Please don't give a /dev entry. Give a SCSI node for the parameter of the -d flag.");
     481        }
     482        if (flag_set['r'] && g_kernel_version <= 2.5
     483            && !strstr(flag_val['d'], "/dev/")) {
     484            fatal_error
     485                ("Please give a /dev entry, not a SCSI node, as the parameter of the -d flag.");
     486        }
     487        if (g_kernel_version >= 2.6 && !strstr(flag_val['d'], "/dev/")) {
     488            log_to_screen
     489                ("Linus says 2.6 has a broken ide-scsi module. Proceed at your own risk...");
     490        }
     491
     492        if (system("which cdrecord > /dev/null 2> /dev/null")
     493            && system("which dvdrecord > /dev/null 2> /dev/null")) {
     494            fatal_error
     495                ("Please install dvdrecord/cdrecord and try again.");
     496        }
     497        if (flag_set['C']) {
     498            bkpinfo->cdrw_speed = atoi(flag_val['C']);
     499            if (bkpinfo->cdrw_speed < 1) {
     500                fatal_error
     501                    ("You specified a silly speed for a CD-R[W] drive");
     502            }
     503            if (!flag_set['L']) {
     504                log_to_screen
     505                    ("You must use -L with -C. Therefore I am setting it for you.");
     506                flag_set['L'] = 1;
     507                flag_val['L'][0] = '\0';
     508            }
     509        } else {
     510            log_msg(3, "flag_val['c'] = %s", flag_val['c']);
     511            log_msg(3, "flag_val['w'] = %s", flag_val['w']);
     512//    log_msg(3, "flag_set['r'] = %i", flag_set['r'] );
     513            if (flag_set['c']) {
     514                bkpinfo->cdrw_speed = atoi(flag_val['c']);
     515            } else if (flag_set['w']) {
     516                bkpinfo->cdrw_speed = atoi(flag_val['w']);
     517            } else if (flag_set['r']) {
     518                bkpinfo->cdrw_speed = 1;    /*atoi(flag_val['r']); */
     519            }
     520
     521            if (bkpinfo->cdrw_speed < 1) {
     522                fatal_error
     523                    ("You specified a silly speed for a CD-R[W] drive");
     524            }
     525        }
     526    }
     527    if (flag_set['t'] && !flag_set['d']) {
     528        log_it("Hmm! No tape drive specified. Let's see what we can do.");
     529        if (find_tape_device_and_size(flag_val['d'], tmp)) {
     530            fatal_error
     531                ("Tape device not specified. I couldn't find it either.");
     532        }
     533        flag_set['d'] = TRUE;
     534        sprintf(tmp,
     535                "You didn't specify a tape streamer device. I'm assuming %s",
     536                flag_val['d']);
     537        log_to_screen(tmp);
     538        percent = 0;
     539    }
     540
     541    if (flag_set['r'])          // DVD
    416542    {
    417       flag_set['R'] = TRUE;
    418       log_msg(1, "Using star instead of afio");
    419     }
    420       else
    421     {
    422       fatal_error("Neither afio nor star is installed. Please install at least one.");
    423     }
    424     }
    425 
    426   if (flag_set['R'])
    427     {
    428       bkpinfo->use_star = TRUE;
    429       if (flag_set['L'])
    430         { fatal_error ("You may not use star and lzop at the same time."); }
    431       if (!find_home_of_exe("star"))
    432         { fatal_error ("Please install 'star' RPM or tarball if you are going to use -R. Thanks."); }
    433     }
    434   if (flag_set['W'])
    435     {
    436       bkpinfo->nonbootable_backup = TRUE;
    437       log_to_screen ("Warning - you have opted for non-bootable backup");
    438       if (flag_set['f'] || flag_set['l'])
    439         {
    440           log_to_screen ("You don't need to specify bootloader or bootdevice");
    441         }
    442     }
    443   if (flag_set['t'] && flag_set['H'])
    444     { fatal_error("Sorry, you may not nuke w/o warning from tape. Drop -H, please."); }
    445   if (flag_set['I'])
    446     {
    447       if (!strcmp(bkpinfo->include_paths, "/"))
    448     {
    449       log_msg(2, "'/' is pleonastic.");
    450       bkpinfo->include_paths[0] = '\0';
    451     }
    452       if (bkpinfo->include_paths[0])
    453         { strcat(bkpinfo->include_paths," "); }
    454       strncpy (bkpinfo->include_paths+strlen(bkpinfo->include_paths), flag_val['I'], MAX_STR_LEN - strlen(bkpinfo->include_paths));
    455       log_msg(1, "include_paths is now '%s'", bkpinfo->include_paths);
    456       if (bkpinfo->include_paths[0] == '-')
    457     {
    458       retval++;
    459       log_to_screen( "Please supply a sensible value with '-I'\n");
    460     }
    461     }
    462    
    463   if (g_kernel_version >= 2.6 && !flag_set['d'] && (flag_set['c'] || flag_set['w']))
    464     {
    465       fatal_error("If you are using the 2.6.x kernel, please specify the CD-R(W) device.");
    466     }
    467 
    468 
    469   if (flag_set['J'])
    470     {
    471       if (flag_set['I'])
    472     {
    473       retval++;
    474       log_to_screen( "Please do not use -J in combination with -I. If you want to make a list of files to backup, that's fine, use -J <filename> but please don't muddy the waters by combining -J with -I. Thanks. :-)");
    475     }
    476       bkpinfo->make_filelist = FALSE;
    477       strcpy(bkpinfo->include_paths, flag_val['J']);
    478     }
    479   if (flag_set['c'] || flag_set['w'] || flag_set['C'] || flag_set['r'])
    480     {
    481       if (!flag_set['r'] && g_kernel_version <= 2.5 && strstr(flag_val['d'], "/dev/"))
    482         { fatal_error("Please don't give a /dev entry. Give a SCSI node for the parameter of the -d flag."); }
    483       if (flag_set['r'] && g_kernel_version <= 2.5 && !strstr(flag_val['d'], "/dev/"))
    484         { fatal_error("Please give a /dev entry, not a SCSI node, as the parameter of the -d flag."); }
    485       if (g_kernel_version >= 2.6 && !strstr(flag_val['d'], "/dev/"))
    486     { log_to_screen("Linus says 2.6 has a broken ide-scsi module. Proceed at your own risk..."); }
    487 
    488       if (system ("which cdrecord > /dev/null 2> /dev/null") && system("which dvdrecord > /dev/null 2> /dev/null"))
    489     {
    490       fatal_error ("Please install dvdrecord/cdrecord and try again.");
    491     }
    492       if (flag_set['C'])
    493     {
    494       bkpinfo->cdrw_speed = 2;
    495       if (!flag_set['L'])
    496         {
    497         log_to_screen ("You must use -L with -C. Therefore I am setting it for you.");
    498         flag_set['L'] = 1;
    499         flag_val['L'][0] = '\0';
    500         }
    501     }
    502       else
    503     {
    504       log_msg(3, "flag_val['c'] = %s", flag_val['c'] );
    505       log_msg(3, "flag_val['w'] = %s", flag_val['w'] );
    506 //    log_msg(3, "flag_set['r'] = %i", flag_set['r'] );
    507       if (flag_set['c']) { bkpinfo->cdrw_speed = atoi(flag_val['c']); }
    508       else
    509       if (flag_set['w']) { bkpinfo->cdrw_speed = atoi(flag_val['w']); }
    510       else
    511       if (flag_set['r']) { bkpinfo->cdrw_speed = 1; /*atoi(flag_val['r']);*/ }
    512 
    513       if (bkpinfo->cdrw_speed < 1)
    514         {
    515           fatal_error ("You specified a silly speed for a CD-R[W] drive");
    516         }
    517     }
    518     }
    519   if (flag_set['t'] && !flag_set['d'])
    520     {
    521       log_it("Hmm! No tape drive specified. Let's see what we can do.");
    522       if (find_tape_device_and_size(flag_val['d'], tmp))
    523         { fatal_error("Tape device not specified. I couldn't find it either."); }
    524       flag_set['d'] = TRUE;
    525       sprintf(tmp, "You didn't specify a tape streamer device. I'm assuming %s", flag_val['d']);
    526       log_to_screen(tmp);
    527       percent = 0;
    528     }
    529 
    530   if (flag_set['r']) // DVD
    531     {
    532       if (flag_set['m'])
    533     { fatal_error("Manual CD tray (-m) not yet supported in conjunction w/ DVD drives. Drop -m."); }
    534       if (!flag_set['d'])
    535         {
    536           if (!find_dvd_device(flag_val['d'], FALSE))
    537         {
    538           flag_set['d'] = TRUE;
    539           log_to_screen("I guess DVD drive is at %s", flag_val['d']);
    540         }
    541     }
    542       if (!find_home_of_exe("growisofs"))
    543         { fatal_error("Please install growisofs (probably part of dvd+rw-tools). If you want DVD support, you need it."); }
    544       if (!find_home_of_exe("dvd+rw-format"))
    545         { fatal_error("Please install dvd+rw-format (probably part of dvd+rw-tools). If you want DVD support, you need it."); }
    546       if (strchr(flag_val['d'], ','))
    547         { fatal_error("Please don't give a SCSI node. Give a _device_, preferably a /dev entry, for the parameter of the -d flag."); }
    548       if (!flag_set['s'])
    549         {
    550         sprintf (flag_val['s'], "%d", DEFAULT_DVD_DISK_SIZE); // 4.7 salesman's GB = 4.482 real GB = 4582 MB
    551         strcat ( flag_val['s'], "m");
    552         log_to_screen ("You did not specify a size (-s) for DVD. I'm guessing %s.", flag_val['s']);
    553         flag_set['s'] = 1;
    554     }
     543        if (flag_set['m']) {
     544            fatal_error
     545                ("Manual CD tray (-m) not yet supported in conjunction w/ DVD drives. Drop -m.");
     546        }
     547        if (!flag_set['d']) {
     548            if (!find_dvd_device(flag_val['d'], FALSE)) {
     549                flag_set['d'] = TRUE;
     550                log_to_screen("I guess DVD drive is at %s", flag_val['d']);
     551            }
     552        }
     553        if (!find_home_of_exe("growisofs")) {
     554            fatal_error
     555                ("Please install growisofs (probably part of dvd+rw-tools). If you want DVD support, you need it.");
     556        }
     557        if (!find_home_of_exe("dvd+rw-format")) {
     558            fatal_error
     559                ("Please install dvd+rw-format (probably part of dvd+rw-tools). If you want DVD support, you need it.");
     560        }
     561        if (strchr(flag_val['d'], ',')) {
     562            fatal_error
     563                ("Please don't give a SCSI node. Give a _device_, preferably a /dev entry, for the parameter of the -d flag.");
     564        }
     565        if (!flag_set['s']) {
     566            sprintf(flag_val['s'], "%d", DEFAULT_DVD_DISK_SIZE);    // 4.7 salesman's GB = 4.482 real GB = 4582 MB
     567            strcat(flag_val['s'], "m");
     568            log_to_screen
     569                ("You did not specify a size (-s) for DVD. I'm guessing %s.",
     570                 flag_val['s']);
     571            flag_set['s'] = 1;
     572        }
    555573/*
    556574      if (flag_set['Z']) {
     
    558576      }
    559577*/
    560     }
    561 
    562   if (flag_set['t'] || flag_set['u'])
    563     {               /* tape size */
    564       if (strchr(flag_val['d'], ','))
    565         { fatal_error("Please don't give a SCSI node. Give a _device_, preferably a /dev entry, for the parameter of the -d flag."); }
    566       if (flag_set['O'])
     578    }
     579
     580    if (flag_set['t'] || flag_set['u']) {   /* tape size */
     581        if (strchr(flag_val['d'], ',')) {
     582            fatal_error
     583                ("Please don't give a SCSI node. Give a _device_, preferably a /dev entry, for the parameter of the -d flag.");
     584        }
     585        if (flag_set['O']) {
     586            if (flag_set['s']) {
     587                if (flag_set['t']) {
     588                    fatal_error
     589                        ("For the moment, please don't specify a tape size. Mondo should handle end-of-tape gracefully anyway.");
     590                }
     591                if (process_the_s_switch(bkpinfo, flag_val['s'])) {
     592                    fatal_error("Bad -s switch");
     593                }
     594            } else if (flag_set['u'] || flag_set['t']) {
     595                for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
     596                    bkpinfo->media_size[i] = 0;
     597                }
     598            } else {
     599                retval++;
     600                log_to_screen("Tape size not specified.\n");
     601            }
     602        }
     603    } else {                    /* CD size */
     604        if (flag_set['s']) {
     605            if (process_the_s_switch(bkpinfo, flag_val['s'])) {
     606                fatal_error("Bad -s switch");
     607            }
     608        }
     609        if (flag_set['w']) {
     610            bkpinfo->wipe_media_first = TRUE;
     611        }                       /* CD-RW */
     612    }
     613    if (flag_set['n']) {
     614        strncpy(bkpinfo->nfs_mount, flag_val['n'], MAX_STR_LEN);
     615        if (!flag_set['d']) {
     616            strncpy(bkpinfo->nfs_remote_dir, "/", MAX_STR_LEN);
     617        }
     618        sprintf(tmp, "mount | grep -x \"%s .*\" | cut -d' ' -f3",
     619                bkpinfo->nfs_mount);
     620        strncpy(bkpinfo->isodir,
     621                call_program_and_get_last_line_of_output(tmp),
     622                MAX_STR_LEN / 4);
     623        if (strlen(bkpinfo->isodir) < 3) {
     624            retval++;
     625            log_to_screen("NFS share is not mounted. Please mount it.\n");
     626        }
     627        log_msg(3, "mount = %s", bkpinfo->nfs_mount);
     628        log_msg(3, "isodir= %s", bkpinfo->isodir);
     629    }
     630    if (flag_set['c']) {
     631        bkpinfo->backup_media_type = cdr;
     632    }
     633    if (flag_set['C']) {
     634        bkpinfo->backup_media_type = cdstream;
     635    }
     636    if (flag_set['i']) {
     637        bkpinfo->backup_media_type = iso;
     638    }
     639    if (flag_set['n']) {
     640        bkpinfo->backup_media_type = nfs;
     641    }
     642    if (flag_set['r']) {
     643        bkpinfo->backup_media_type = dvd;
     644    }
     645    if (flag_set['t']) {
     646        bkpinfo->backup_media_type = tape;
     647    }
     648    if (flag_set['u']) {
     649        bkpinfo->backup_media_type = udev;
     650    }
     651    if (flag_set['w']) {
     652        bkpinfo->backup_media_type = cdrw;
     653    }
     654
     655/* optional, popular */
     656    if (flag_set['g']) {
     657        g_text_mode = FALSE;
     658    }
     659    if (flag_set['E']) {
     660        if (bkpinfo->exclude_paths[0]) {
     661            strcat(bkpinfo->exclude_paths, " ");
     662        }
     663        strncpy(bkpinfo->exclude_paths + strlen(bkpinfo->exclude_paths),
     664                flag_val['E'],
     665                MAX_STR_LEN - strlen(bkpinfo->exclude_paths));
     666    }
     667    if (flag_set['e']) {
     668        bkpinfo->please_dont_eject = TRUE;
     669    }
     670    if (flag_set['N'])          // exclude NFS mounts & devices
    567671    {
    568       if (flag_set['s'])
    569         {
    570               if (flag_set['t']) { fatal_error("For the moment, please don't specify a tape size. Mondo should handle end-of-tape gracefully anyway."); }
    571               if (process_the_s_switch(bkpinfo, flag_val['s'])) {fatal_error("Bad -s switch");}
    572             }
    573       else if (flag_set['u'] || flag_set['t'])
    574             {
    575           for(i=0; i<=MAX_NOOF_MEDIA; i++) { bkpinfo->media_size[i] = 0; }
    576         }
    577       else
    578         {
    579           retval++;
    580           log_to_screen( "Tape size not specified.\n");
    581         }
    582     }
    583     }
    584   else
    585     {               /* CD size */
    586       if (flag_set['s'])
    587     {
    588           if (process_the_s_switch(bkpinfo, flag_val['s'])) {fatal_error("Bad -s switch");}
    589     }
    590       if (flag_set['w'])
    591     {
    592       bkpinfo->wipe_media_first = TRUE;
    593     }           /* CD-RW */
    594     }
    595   if (flag_set['n'])
    596     {
    597       strncpy (bkpinfo->nfs_mount, flag_val['n'], MAX_STR_LEN);
    598       if (!flag_set['d'])
    599     {
    600       strncpy (bkpinfo->nfs_remote_dir, "/", MAX_STR_LEN);
    601     }
    602       sprintf (tmp, "mount | grep -x \"%s .*\" | cut -d' ' -f3",
    603            bkpinfo->nfs_mount);
    604       strncpy (bkpinfo->isodir,
    605           call_program_and_get_last_line_of_output (tmp), MAX_STR_LEN/4);
    606       if (strlen (bkpinfo->isodir) < 3)
    607     {
    608       retval++;
    609       log_to_screen( "NFS share is not mounted. Please mount it.\n");
    610     }
    611       log_msg(3, "mount = %s", bkpinfo->nfs_mount);
    612       log_msg(3, "isodir= %s", bkpinfo->isodir);
    613     }     
    614   if (flag_set['c']) { bkpinfo->backup_media_type = cdr; }
    615   if (flag_set['C']) { bkpinfo->backup_media_type = cdstream; }
    616   if (flag_set['i']) { bkpinfo->backup_media_type = iso; }
    617   if (flag_set['n']) { bkpinfo->backup_media_type = nfs; }
    618   if (flag_set['r']) { bkpinfo->backup_media_type = dvd; }
    619   if (flag_set['t']) { bkpinfo->backup_media_type = tape; }
    620   if (flag_set['u']) { bkpinfo->backup_media_type = udev; }
    621   if (flag_set['w']) { bkpinfo->backup_media_type = cdrw; }
    622 
    623 /* optional, popular */
    624   if (flag_set['g'])
    625     {
    626       g_text_mode = FALSE;
    627     }
    628   if (flag_set['E'])
    629     {
    630       if (bkpinfo->exclude_paths[0])
    631         { strcat(bkpinfo->exclude_paths," "); }
    632       strncpy (bkpinfo->exclude_paths+strlen(bkpinfo->exclude_paths), flag_val['E'], MAX_STR_LEN - strlen(bkpinfo->exclude_paths));
    633     }
    634   if (flag_set['e'])
    635     {
    636       bkpinfo->please_dont_eject = TRUE;
    637     }
    638   if (flag_set['N']) // exclude NFS mounts & devices
    639     {
    640672//      strncpy(psz, list_of_NFS_devices_and_mounts(), MAX_STR_LEN);
    641       strncpy(psz, list_of_NFS_mounts_only(), MAX_STR_LEN);
    642       if (bkpinfo->exclude_paths[0]) { strncat(bkpinfo->exclude_paths, " ", MAX_STR_LEN); }
    643       strncat(bkpinfo->exclude_paths, psz, MAX_STR_LEN);
    644       log_msg(3, "-N means we're now excluding %s", bkpinfo->exclude_paths);
    645     }
    646   if (strlen(bkpinfo->exclude_paths) >= MAX_STR_LEN)
    647     {
    648       fatal_error("Your '-E' parameter is too long. Please use '-J'. (See manual.)");
    649     }
    650   if (flag_set['b'])
    651     {
    652       strcpy(psz, flag_val['b']);
    653       log_msg(1, "psz = '%s'", psz);
    654       if (psz[strlen(psz)-1] == 'k')
    655     { psz[strlen(psz)-1] = '\0'; itbs = atol(psz) * 1024L; }
    656       else
    657     { itbs = atol(psz); }
    658       log_msg(1, "'%s' --> %ld", flag_val['b'], itbs);
    659       log_msg(1, "Internal tape block size is now %ld bytes", itbs);
    660       if (itbs%512!=0 || itbs < 256 || itbs > 1024L*1024)
    661     { fatal_error("Are you nuts? Silly, your internal tape block size is. Abort, I shall."); }
    662       bkpinfo->internal_tape_block_size = itbs;
    663     }
    664   if (flag_set['D'])
    665     {
    666       bkpinfo->differential = 1;
     673        strncpy(psz, list_of_NFS_mounts_only(), MAX_STR_LEN);
     674        if (bkpinfo->exclude_paths[0]) {
     675            strncat(bkpinfo->exclude_paths, " ", MAX_STR_LEN);
     676        }
     677        strncat(bkpinfo->exclude_paths, psz, MAX_STR_LEN);
     678        log_msg(3, "-N means we're now excluding %s",
     679                bkpinfo->exclude_paths);
     680    }
     681    if (strlen(bkpinfo->exclude_paths) >= MAX_STR_LEN) {
     682        fatal_error
     683            ("Your '-E' parameter is too long. Please use '-J'. (See manual.)");
     684    }
     685    if (flag_set['b']) {
     686        strcpy(psz, flag_val['b']);
     687        log_msg(1, "psz = '%s'", psz);
     688        if (psz[strlen(psz) - 1] == 'k') {
     689            psz[strlen(psz) - 1] = '\0';
     690            itbs = atol(psz) * 1024L;
     691        } else {
     692            itbs = atol(psz);
     693        }
     694        log_msg(1, "'%s' --> %ld", flag_val['b'], itbs);
     695        log_msg(1, "Internal tape block size is now %ld bytes", itbs);
     696        if (itbs % 512 != 0 || itbs < 256 || itbs > 1024L * 1024) {
     697            fatal_error
     698                ("Are you nuts? Silly, your internal tape block size is. Abort, I shall.");
     699        }
     700        bkpinfo->internal_tape_block_size = itbs;
     701    }
     702    if (flag_set['D']) {
     703        bkpinfo->differential = 1;
    667704//      bkpinfo->differential = atoi (flag_val['D']);
    668       if ((bkpinfo->differential < 1) || (bkpinfo->differential > 9))
    669     {
    670         fatal_error ("The D option should be between 1 and 9 inclusive");
    671     }
    672     }
    673   if (flag_set['x'])
    674     {
    675       strncpy (bkpinfo->image_devs, flag_val['x'], MAX_STR_LEN/4);
    676       if (run_program_and_log_output("which partimagehack", 2))
    677         { fatal_error("Please install partimagehack RPM/tarball."); }
    678     }
    679   if (flag_set['m'])
    680     {
    681       bkpinfo->manual_cd_tray = TRUE;
    682     }
    683   if (flag_set['k'])
    684     {
    685       strncpy (bkpinfo->kernel_path, flag_val['k'], MAX_STR_LEN);
    686       if (!strcmp (bkpinfo->kernel_path, "failsafe"))
    687     {
    688       strcpy (bkpinfo->kernel_path, "FAILSAFE");
    689     }
    690       if (strcmp (bkpinfo->kernel_path, "FAILSAFE")
    691       && !does_file_exist (bkpinfo->kernel_path))
    692     {
    693       retval++;
    694       sprintf(tmp,
    695            "You specified kernel '%s', which does not exist\n",
    696            bkpinfo->kernel_path);
    697           log_to_screen(tmp);
    698     }
    699     }
    700 if (flag_set['p'])
    701     {
    702       strncpy (bkpinfo->prefix, flag_val['p'], MAX_STR_LEN/4);
    703     }
    704 
    705 
    706   if (flag_set['d'])
    707     {               /* backup directory (if ISO/NFS) */
    708       if (flag_set['i'])
    709     {
    710       strncpy (bkpinfo->isodir, flag_val['d'], MAX_STR_LEN/4);
    711           sprintf(tmp, "ls -l %s", bkpinfo->isodir);
    712           if (run_program_and_log_output(tmp, FALSE)) { fatal_error("output folder does not exist - please create it"); }
    713     }
    714       else if (flag_set['n'])
    715     {
    716       strncpy (bkpinfo->nfs_remote_dir, flag_val['d'], MAX_STR_LEN);
    717     }
    718       else          /* backup device (if tape/CD-R/CD-RW) */
    719     {
    720       strncpy (bkpinfo->media_device, flag_val['d'], MAX_STR_LEN/4);
    721     }
    722     }
    723 
    724   if (flag_set['n'])
    725     {
    726       sprintf (tmp, "echo hi > %s/%s/.dummy.txt", bkpinfo->isodir, bkpinfo->nfs_remote_dir);
    727       if (run_program_and_log_output (tmp, FALSE))
    728     {
    729       retval++;
    730       sprintf (tmp, "Are you sure directory '%s' exists in remote dir '%s'?\nIf so, do you have rights to write to it?\n",
    731            bkpinfo->nfs_remote_dir, bkpinfo->nfs_mount);
    732           log_to_screen (tmp);
    733     }
    734     }
    735 
    736   if (!flag_set['d'] && (flag_set['c'] || flag_set['w'] || flag_set['C']))
    737     {
    738       if (g_kernel_version >= 2.6)
    739         {
    740       if (popup_and_get_string("Device", "Please specify the device", bkpinfo->media_device, MAX_STR_LEN/4))
    741             {
    742           retval ++;
    743           log_to_screen("User opted to cancel.");
    744         }
    745     }
    746       else if (find_cdrw_device (bkpinfo->media_device))
    747     {
    748       retval++;
    749       log_to_screen(
    750            "Tried and failed to find CD-R[W] drive automatically.\n");
    751     }
    752       else
    753     {
    754       flag_set['d'] = TRUE;
    755       strncpy (flag_val['d'], bkpinfo->media_device, MAX_STR_LEN/4);
    756     }
    757     }
    758 
    759   if (!flag_set['d'] && !flag_set['n'] && !flag_set['C'])
    760     {
    761       retval++;
    762       log_to_screen( "Please specify the backup device/directory.\n");
    763       fatal_error("You didn't use -d to specify the backup device/directory.");
    764     }
     705        if ((bkpinfo->differential < 1) || (bkpinfo->differential > 9)) {
     706            fatal_error
     707                ("The D option should be between 1 and 9 inclusive");
     708        }
     709    }
     710    if (flag_set['x']) {
     711        strncpy(bkpinfo->image_devs, flag_val['x'], MAX_STR_LEN / 4);
     712        if (run_program_and_log_output("which partimagehack", 2)) {
     713            fatal_error("Please install partimagehack RPM/tarball.");
     714        }
     715    }
     716    if (flag_set['m']) {
     717        bkpinfo->manual_cd_tray = TRUE;
     718    }
     719    if (flag_set['k']) {
     720        strncpy(bkpinfo->kernel_path, flag_val['k'], MAX_STR_LEN);
     721        if (!strcmp(bkpinfo->kernel_path, "failsafe")) {
     722            strcpy(bkpinfo->kernel_path, "FAILSAFE");
     723        }
     724        if (strcmp(bkpinfo->kernel_path, "FAILSAFE")
     725            && !does_file_exist(bkpinfo->kernel_path)) {
     726            retval++;
     727            sprintf(tmp,
     728                    "You specified kernel '%s', which does not exist\n",
     729                    bkpinfo->kernel_path);
     730            log_to_screen(tmp);
     731        }
     732    }
     733    if (flag_set['p']) {
     734        strncpy(bkpinfo->prefix, flag_val['p'], MAX_STR_LEN / 4);
     735    }
     736
     737
     738    if (flag_set['d']) {        /* backup directory (if ISO/NFS) */
     739        if (flag_set['i']) {
     740            strncpy(bkpinfo->isodir, flag_val['d'], MAX_STR_LEN / 4);
     741            sprintf(tmp, "ls -l %s", bkpinfo->isodir);
     742            if (run_program_and_log_output(tmp, FALSE)) {
     743                fatal_error
     744                    ("output folder does not exist - please create it");
     745            }
     746        } else if (flag_set['n']) {
     747            strncpy(bkpinfo->nfs_remote_dir, flag_val['d'], MAX_STR_LEN);
     748        } else {                /* backup device (if tape/CD-R/CD-RW) */
     749
     750            strncpy(bkpinfo->media_device, flag_val['d'], MAX_STR_LEN / 4);
     751        }
     752    }
     753
     754    if (flag_set['n']) {
     755        sprintf(tmp, "echo hi > %s/%s/.dummy.txt", bkpinfo->isodir,
     756                bkpinfo->nfs_remote_dir);
     757        if (run_program_and_log_output(tmp, FALSE)) {
     758            retval++;
     759            sprintf(tmp,
     760                    "Are you sure directory '%s' exists in remote dir '%s'?\nIf so, do you have rights to write to it?\n",
     761                    bkpinfo->nfs_remote_dir, bkpinfo->nfs_mount);
     762            log_to_screen(tmp);
     763        }
     764    }
     765
     766    if (!flag_set['d']
     767        && (flag_set['c'] || flag_set['w'] || flag_set['C'])) {
     768        if (g_kernel_version >= 2.6) {
     769            if (popup_and_get_string
     770                ("Device", "Please specify the device",
     771                 bkpinfo->media_device, MAX_STR_LEN / 4)) {
     772                retval++;
     773                log_to_screen("User opted to cancel.");
     774            }
     775        } else if (find_cdrw_device(bkpinfo->media_device)) {
     776            retval++;
     777            log_to_screen
     778                ("Tried and failed to find CD-R[W] drive automatically.\n");
     779        } else {
     780            flag_set['d'] = TRUE;
     781            strncpy(flag_val['d'], bkpinfo->media_device, MAX_STR_LEN / 4);
     782        }
     783    }
     784
     785    if (!flag_set['d'] && !flag_set['n'] && !flag_set['C']) {
     786        retval++;
     787        log_to_screen("Please specify the backup device/directory.\n");
     788        fatal_error
     789            ("You didn't use -d to specify the backup device/directory.");
     790    }
    765791/* optional, obscure */
    766   for (i = '0'; i <= '9'; i++)
    767     {
    768       if (flag_set[i])
    769     {
    770       bkpinfo->compression_level = i - '0';
    771     }           /* not '\0' but '0' */
    772     }
    773   if (flag_set['S'])
    774     {
    775       sprintf (bkpinfo->scratchdir, "%s/mondo.scratch.%ld", flag_val['S'],
    776            random () % 32768);
    777     }
    778   if (flag_set['T'])
    779     {
    780       sprintf (bkpinfo->tmpdir, "%s/tmp.mondo.%ld", flag_val['T'],
    781            random () % 32768);
    782       sprintf(tmp, "touch %s/.foo.dat", flag_val['T']);
    783       if (run_program_and_log_output(tmp, 1))
    784         {
    785       retval++;
    786       log_to_screen( "Please specify a tempdir which I can write to. :)");
    787       fatal_error("I cannot write to the tempdir you specified.");
    788     }
    789       sprintf(tmp, "ln -sf %s/.foo.dat %s/.bar.dat", flag_val['T'], flag_val['T']);
    790       if (run_program_and_log_output(tmp, 1))
    791         {
    792       retval++;
    793       log_to_screen("Please don't specify a SAMBA or VFAT or NFS tmpdir.");
    794       fatal_error("I cannot write to the tempdir you specified.");
    795     }     
    796     }
    797   if (flag_set['A'])
    798     {
    799       strncpy (bkpinfo->call_after_iso, flag_val['A'], MAX_STR_LEN);
    800     }
    801   if (flag_set['B'])
    802     {
    803       strncpy (bkpinfo->call_before_iso, flag_val['B'], MAX_STR_LEN);
    804     }
    805   if (flag_set['F'])
    806     {
    807       g_skip_floppies = TRUE;
    808     }
    809   if (flag_set['H'])
    810     {
    811       g_cd_recovery = TRUE;
    812     }
    813   if (flag_set['l'])
    814     {
     792    for (i = '0'; i <= '9'; i++) {
     793        if (flag_set[i]) {
     794            bkpinfo->compression_level = i - '0';
     795        }                       /* not '\0' but '0' */
     796    }
     797    if (flag_set['S']) {
     798        sprintf(bkpinfo->scratchdir, "%s/mondo.scratch.%ld", flag_val['S'],
     799                random() % 32768);
     800    }
     801    if (flag_set['T']) {
     802        sprintf(bkpinfo->tmpdir, "%s/tmp.mondo.%ld", flag_val['T'],
     803                random() % 32768);
     804        sprintf(tmp, "touch %s/.foo.dat", flag_val['T']);
     805        if (run_program_and_log_output(tmp, 1)) {
     806            retval++;
     807            log_to_screen
     808                ("Please specify a tempdir which I can write to. :)");
     809            fatal_error("I cannot write to the tempdir you specified.");
     810        }
     811        sprintf(tmp, "ln -sf %s/.foo.dat %s/.bar.dat", flag_val['T'],
     812                flag_val['T']);
     813        if (run_program_and_log_output(tmp, 1)) {
     814            retval++;
     815            log_to_screen
     816                ("Please don't specify a SAMBA or VFAT or NFS tmpdir.");
     817            fatal_error("I cannot write to the tempdir you specified.");
     818        }
     819    }
     820    if (flag_set['A']) {
     821        strncpy(bkpinfo->call_after_iso, flag_val['A'], MAX_STR_LEN);
     822    }
     823    if (flag_set['B']) {
     824        strncpy(bkpinfo->call_before_iso, flag_val['B'], MAX_STR_LEN);
     825    }
     826    if (flag_set['F']) {
     827        g_skip_floppies = TRUE;
     828    }
     829    if (flag_set['H']) {
     830        g_cd_recovery = TRUE;
     831    }
     832    if (flag_set['l']) {
    815833#ifdef __FreeBSD__
    816834#  define BOOT_LOADER_CHARS "GLBMR"
     
    822840#  endif
    823841#endif
    824       if (!strchr(BOOT_LOADER_CHARS, (bkpinfo->boot_loader = flag_val['l'][0])))
    825     {
    826       log_msg(1, "%c? WTF is %c? I need G, L, E or R.", bkpinfo->boot_loader, bkpinfo->boot_loader);
    827       fatal_error("Please specify GRUB, LILO, ELILO  or RAW with the -l switch");
    828     }
     842        if (!strchr
     843            (BOOT_LOADER_CHARS,
     844             (bkpinfo->boot_loader = flag_val['l'][0]))) {
     845            log_msg(1, "%c? WTF is %c? I need G, L, E or R.",
     846                    bkpinfo->boot_loader, bkpinfo->boot_loader);
     847            fatal_error
     848                ("Please specify GRUB, LILO, ELILO  or RAW with the -l switch");
     849        }
    829850#undef BOOT_LOADER_CHARS
    830     }
    831   if (flag_set['f'])
    832     {
    833       strncpy (bkpinfo->boot_device, resolve_softlinks_to_get_to_actual_device_file(flag_val['f']), MAX_STR_LEN/4);
    834     }
    835   if (flag_set['P'])
    836     {
    837       strncpy (bkpinfo->postnuke_tarball, flag_val['P'], MAX_STR_LEN);
    838     }
    839   if (flag_set['Q'])
    840     {
    841       i = which_boot_loader(tmp);
    842       log_msg(3, "boot loader is %c, residing at %s", i, tmp);
    843       printf("boot loader is %c, residing at %s\n", i, tmp);
    844       finish(0);
    845     }
    846   if (flag_set['L'])
    847     {
    848       bkpinfo->use_lzo = TRUE;
    849       if (run_program_and_log_output ("which lzop", FALSE))
    850     {
    851       retval++;
    852       log_to_screen(
    853            "Please install LZOP. You can't use '-L' until you do.\n");
    854     }
    855     }
    856 
    857   if (!flag_set['o'] && !run_program_and_log_output("cat /etc/issue.net | grep -i suse | grep 64", TRUE))
    858     {
    859       bkpinfo->make_cd_use_lilo = TRUE;
    860       log_to_screen("Forcing you to use LILO. SuSE 9.0 (64-bit) has a broken mkfs.vfat binary.");
    861     }
    862   if (flag_set['o'])
    863     {
    864       bkpinfo->make_cd_use_lilo = TRUE;
    865     }
     851    }
     852    if (flag_set['f']) {
     853        strncpy(bkpinfo->boot_device,
     854                resolve_softlinks_to_get_to_actual_device_file(flag_val
     855                                                               ['f']),
     856                MAX_STR_LEN / 4);
     857    }
     858    if (flag_set['P']) {
     859        strncpy(bkpinfo->postnuke_tarball, flag_val['P'], MAX_STR_LEN);
     860    }
     861    if (flag_set['Q']) {
     862        i = which_boot_loader(tmp);
     863        log_msg(3, "boot loader is %c, residing at %s", i, tmp);
     864        printf("boot loader is %c, residing at %s\n", i, tmp);
     865        finish(0);
     866    }
     867    if (flag_set['L']) {
     868        bkpinfo->use_lzo = TRUE;
     869        if (run_program_and_log_output("which lzop", FALSE)) {
     870            retval++;
     871            log_to_screen
     872                ("Please install LZOP. You can't use '-L' until you do.\n");
     873        }
     874    }
     875
     876    if (!flag_set['o']
     877        &&
     878        !run_program_and_log_output
     879        ("cat /etc/issue.net | grep -i suse | grep 64", TRUE)) {
     880        bkpinfo->make_cd_use_lilo = TRUE;
     881        log_to_screen
     882            ("Forcing you to use LILO. SuSE 9.0 (64-bit) has a broken mkfs.vfat binary.");
     883    }
     884    if (flag_set['o']) {
     885        bkpinfo->make_cd_use_lilo = TRUE;
     886    }
    866887#ifndef __FreeBSD__
    867   else
    868     {
    869       if (!is_this_a_valid_disk_format("vfat"))
    870         {
    871       bkpinfo->make_cd_use_lilo = TRUE;
    872       log_to_screen( "Your kernel appears not to support vfat filesystems. I am therefore");
    873       log_to_screen( "using LILO instead of SYSLINUX as the CD/floppy's boot loader.");
    874         }
    875       if (run_program_and_log_output("which mkfs.vfat", FALSE))
    876         {
    877       bkpinfo->make_cd_use_lilo = TRUE;
     888    else {
     889        if (!is_this_a_valid_disk_format("vfat")) {
     890            bkpinfo->make_cd_use_lilo = TRUE;
     891            log_to_screen
     892                ("Your kernel appears not to support vfat filesystems. I am therefore");
     893            log_to_screen
     894                ("using LILO instead of SYSLINUX as the CD/floppy's boot loader.");
     895        }
     896        if (run_program_and_log_output("which mkfs.vfat", FALSE)) {
     897            bkpinfo->make_cd_use_lilo = TRUE;
    878898#ifdef __IA32__
    879       log_to_screen( "Your filesystem is missing 'mkfs.vfat', so I cannot use SYSLINUX as");
    880       log_to_screen( "your boot loader. I shall therefore use LILO instead.");
     899            log_to_screen
     900                ("Your filesystem is missing 'mkfs.vfat', so I cannot use SYSLINUX as");
     901            log_to_screen
     902                ("your boot loader. I shall therefore use LILO instead.");
    881903#endif
    882904#ifdef __IA64__
    883       log_to_screen( "Your filesystem is missing 'mkfs.vfat', so I cannot prepare the EFI");
    884       log_to_screen( "environment correctly. Please install it.");
    885       fatal_error("Aborting");
     905            log_to_screen
     906                ("Your filesystem is missing 'mkfs.vfat', so I cannot prepare the EFI");
     907            log_to_screen("environment correctly. Please install it.");
     908            fatal_error("Aborting");
    886909#endif
    887     }
     910        }
    888911#ifdef __IA64__
    889       /* We force ELILO usage on IA64 */
    890       bkpinfo->make_cd_use_lilo = TRUE;
     912        /* We force ELILO usage on IA64 */
     913        bkpinfo->make_cd_use_lilo = TRUE;
    891914#endif
    892     }
     915    }
    893916#endif
    894917
    895   if (bkpinfo->make_cd_use_lilo && !does_file_exist("/boot/boot.b"))
    896     {
    897       paranoid_system("touch /boot/boot.b");
    898     }
    899 
    900   i = flag_set['O'] + flag_set['V'];
    901   if (i == 0)
    902     {
    903       retval++;
    904       log_to_screen( "Specify backup (-O), verify (-V) or both (-OV).\n");
    905     }
     918    if (bkpinfo->make_cd_use_lilo && !does_file_exist("/boot/boot.b")) {
     919        paranoid_system("touch /boot/boot.b");
     920    }
     921
     922    i = flag_set['O'] + flag_set['V'];
     923    if (i == 0) {
     924        retval++;
     925        log_to_screen("Specify backup (-O), verify (-V) or both (-OV).\n");
     926    }
    906927
    907928/* and finally... */
    908929
    909   paranoid_free(tmp);
    910   paranoid_free(psz); 
    911   return (retval);
     930    paranoid_free(tmp);
     931    paranoid_free(psz);
     932    return (retval);
    912933}
    913934
     
    926947 */
    927948int
    928 retrieve_switches_from_command_line (int argc, char *argv[],
    929                      char flag_val[128][MAX_STR_LEN],
    930                      bool flag_set[128])
     949retrieve_switches_from_command_line(int argc, char *argv[],
     950                                    char flag_val[128][MAX_STR_LEN],
     951                                    bool flag_set[128])
    931952{
    932     /*@ ints ***/
    933   int opt = 0;
    934   char tmp[MAX_STR_LEN];
    935   int i = 0;
    936   int len;
    937 
    938     /*@ bools ****/
    939   bool bad_switches = FALSE;
    940 
    941   assert(flag_val!=NULL);
    942   assert(flag_set!=NULL);
    943 
    944   for (i = 0; i < 128; i++)
    945     {
    946       flag_val[i][0] = '\0';
    947       flag_set[i] = FALSE;
    948     }
    949   while ((opt =
    950       getopt (argc, argv,
    951           "0123456789A:B:CDE:FHI:J:K:LNOP:QRS:T:VWb:c:d:ef:gik:l:mn:op:rs:tuw:x:")) !=
    952      -1)
    953     {
    954       if (opt == '?')
    955     {
    956       bad_switches = TRUE;
    957       /*log_it("Invalid option: %c\n",optopt); */
    958     }
    959       else
    960     {
    961       if (flag_set[optopt])
    962         {
    963           bad_switches = TRUE;
    964           sprintf(tmp, "Switch -%c previously defined as %s\n", opt,
    965                flag_val[i]);
    966               log_to_screen(tmp);
    967         }
    968       else
    969         {
    970           flag_set[opt] = TRUE;
    971           if (optarg)
    972         {
    973                   len = strlen(optarg);
    974                   if (optarg[0] != '/' && optarg[len-1] == '/')
    975                     {
    976                       optarg[--len] = '\0';
    977               log_to_screen("Warning - param '%s' should not have trailing slash!", optarg);
    978             }
    979                   if (opt=='d')
    980                     {
    981                       if (strchr(flag_val[opt], '/') && flag_val[opt][0]!='/')
    982                         {
    983                           sprintf(tmp, "-%c flag --- must be absolute path --- '%s' isn't absolute", opt, flag_val[opt]);
    984                           log_to_screen(tmp);
    985                           bad_switches = TRUE;
    986                         }
    987             }
    988           strcpy(flag_val[opt], optarg);
    989         }
    990         }
    991     }
    992     }
    993   for (i = optind; i < argc; i++)
    994     {
    995       bad_switches = TRUE;
    996       sprintf(tmp, "Invalid arg -- %s\n", argv[i]);
    997       log_to_screen(tmp);
    998     }
    999   return (bad_switches);
     953    /*@ ints ** */
     954    int opt = 0;
     955    char tmp[MAX_STR_LEN];
     956    int i = 0;
     957    int len;
     958
     959    /*@ bools *** */
     960    bool bad_switches = FALSE;
     961
     962    assert(flag_val != NULL);
     963    assert(flag_set != NULL);
     964
     965    for (i = 0; i < 128; i++) {
     966        flag_val[i][0] = '\0';
     967        flag_set[i] = FALSE;
     968    }
     969    while ((opt =
     970            getopt(argc, argv,
     971                   "0123456789A:B:C:DE:FHI:J:K:LNOP:QRS:T:VWb:c:d:ef:gik:l:mn:op:rs:tuw:x:"))
     972           != -1) {
     973        if (opt == '?') {
     974            bad_switches = TRUE;
     975            /*log_it("Invalid option: %c\n",optopt); */
     976        } else {
     977            if (flag_set[optopt]) {
     978                bad_switches = TRUE;
     979                sprintf(tmp, "Switch -%c previously defined as %s\n", opt,
     980                        flag_val[i]);
     981                log_to_screen(tmp);
     982            } else {
     983                flag_set[opt] = TRUE;
     984                if (optarg) {
     985                    len = strlen(optarg);
     986                    if (optarg[0] != '/' && optarg[len - 1] == '/') {
     987                        optarg[--len] = '\0';
     988                        log_to_screen
     989                            ("Warning - param '%s' should not have trailing slash!",
     990                             optarg);
     991                    }
     992                    if (opt == 'd') {
     993                        if (strchr(flag_val[opt], '/')
     994                            && flag_val[opt][0] != '/') {
     995                            sprintf(tmp,
     996                                    "-%c flag --- must be absolute path --- '%s' isn't absolute",
     997                                    opt, flag_val[opt]);
     998                            log_to_screen(tmp);
     999                            bad_switches = TRUE;
     1000                        }
     1001                    }
     1002                    strcpy(flag_val[opt], optarg);
     1003                }
     1004            }
     1005        }
     1006    }
     1007    for (i = optind; i < argc; i++) {
     1008        bad_switches = TRUE;
     1009        sprintf(tmp, "Invalid arg -- %s\n", argv[i]);
     1010        log_to_screen(tmp);
     1011    }
     1012    return (bad_switches);
    10001013}
    10011014
     
    10061019 * Print a not-so-helpful help message and exit.
    10071020 */
    1008 void
    1009 help_screen ()
     1021void help_screen()
    10101022{
    1011   log_msg(1, "Type 'man mondo-archive' for more information\n");
    1012   exit (1);
     1023    log_msg(1, "Type 'man mondo-archive' for more information\n");
     1024    exit(1);
    10131025}
    10141026
     
    10201032void terminate_daemon(int sig)
    10211033{
    1022   char tmp[64];
    1023   char tmp2 [MAX_STR_LEN];
    1024   //  char command[512];
    1025   //  pid_t pid;
    1026 
    1027   switch(sig)
    1028     {
     1034    char tmp[64];
     1035    char tmp2[MAX_STR_LEN];
     1036    //  char command[512];
     1037    //  pid_t pid;
     1038
     1039    switch (sig) {
    10291040    case SIGINT:
    10301041        sprintf(tmp, "SIGINT");
     
    10331044    case SIGKILL:
    10341045        sprintf(tmp, "SIGKILL");
    1035         strcpy(tmp2, "I seriously have no clue how this signal even got to me. Something's wrong with your system.");
     1046        strcpy(tmp2,
     1047               "I seriously have no clue how this signal even got to me. Something's wrong with your system.");
    10361048        break;
    10371049    case SIGTERM:
    10381050        sprintf(tmp, "SIGTERM");
    1039         strcpy (tmp2, "Got terminate signal");
     1051        strcpy(tmp2, "Got terminate signal");
    10401052        break;
    10411053    case SIGHUP:
    10421054        sprintf(tmp, "SIGHUP");
    1043         strcpy (tmp2, "Hangup on line");
     1055        strcpy(tmp2, "Hangup on line");
    10441056        break;
    10451057    case SIGSEGV:
    10461058        sprintf(tmp, "SIGSEGV");
    1047         strcpy (tmp2, "Internal programming error. Please send a backtrace as well as your log.");
     1059        strcpy(tmp2,
     1060               "Internal programming error. Please send a backtrace as well as your log.");
    10481061        break;
    10491062    case SIGPIPE:
    10501063        sprintf(tmp, "SIGPIPE");
    1051         strcpy (tmp2, "Pipe was broken");
     1064        strcpy(tmp2, "Pipe was broken");
    10521065        break;
    1053     case SIGABRT:
    1054     sprintf (tmp, "SIGABRT");
    1055     sprintf (tmp2, "Abort - probably failed assertion. I'm sleeping for a few seconds so you can read the message.");
    1056     break;
     1066    case SIGABRT:
     1067        sprintf(tmp, "SIGABRT");
     1068        sprintf(tmp2,
     1069                "Abort - probably failed assertion. I'm sleeping for a few seconds so you can read the message.");
     1070        break;
    10571071    default:
    10581072        sprintf(tmp, "(Unknown)");
    1059     }
    1060 
    1061   strcat(tmp, " signal received from OS");
    1062   log_to_screen(tmp);
    1063   log_to_screen (tmp2);
    1064   if (sig == SIGABRT) {
    1065       sleep (10);
    1066   }
    1067   kill_buffer();
    1068   fatal_error("Mondoarchive is terminating in response to a signal from the OS");
    1069   finish(254); // just in case
     1073    }
     1074
     1075    strcat(tmp, " signal received from OS");
     1076    log_to_screen(tmp);
     1077    log_to_screen(tmp2);
     1078    if (sig == SIGABRT) {
     1079        sleep(10);
     1080    }
     1081    kill_buffer();
     1082    fatal_error
     1083        ("Mondoarchive is terminating in response to a signal from the OS");
     1084    finish(254);                // just in case
    10701085}
    10711086
     
    10791094void set_signals(int on)
    10801095{
    1081   int signals[]= { SIGTERM, SIGHUP, SIGTRAP, SIGABRT, SIGINT, SIGKILL, SIGSTOP, 0 };
    1082   int i;
    1083  
    1084   signal(SIGPIPE, sigpipe_occurred);
    1085   for (i=0; signals[i]; i++)
    1086     {
    1087       if (on)
    1088         { signal(signals[i], terminate_daemon); }
    1089       else
    1090         { signal(signals[i], termination_in_progress); }
    1091     }
     1096    int signals[] =
     1097        { SIGTERM, SIGHUP, SIGTRAP, SIGABRT, SIGINT, SIGKILL, SIGSTOP, 0 };
     1098    int i;
     1099
     1100    signal(SIGPIPE, sigpipe_occurred);
     1101    for (i = 0; signals[i]; i++) {
     1102        if (on) {
     1103            signal(signals[i], terminate_daemon);
     1104        } else {
     1105            signal(signals[i], termination_in_progress);
     1106        }
     1107    }
    10921108}
    10931109
     
    11011117void termination_in_progress(int sig)
    11021118{
    1103   log_msg(1, "Termination in progress");
    1104   usleep(1000);
    1105   pthread_exit(0);
     1119    log_msg(1, "Termination in progress");
     1120    usleep(1000);
     1121    pthread_exit(0);
    11061122}
    11071123
Note: See TracChangeset for help on using the changeset viewer.