Ignore:
Timestamp:
Oct 11, 2005, 1:34:31 AM (14 years ago)
Author:
bcornec
Message:

Trunk: indent on all source files

File:
1 edited

Legend:

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

    r30 r59  
    11/* libmondo-files.c                                  file manipulation
    2    $Id: libmondo-files.c,v 1.5 2004/06/10 15:29:12 hugo Exp $
     2   $Id$
    33.
    44
     
    9797
    9898/*@unused@*/
    99 //static char cvsid[] = "$Id: libmondo-files.c,v 1.5 2004/06/10 15:29:12 hugo Exp $";
     99//static char cvsid[] = "$Id$";
    100100
    101101extern char err_log_lines[NOOF_ERR_LINES][MAX_STR_LEN];
     
    114114 * @note The returned string points to static storage that will be overwritten with each call.
    115115 */
    116 char *
    117 calc_checksum_of_file (char *filename)
    118 {
    119     /*@ buffers ******************************************************/
    120   static char output[MAX_STR_LEN];
    121   char command[MAX_STR_LEN*2];
    122   char tmp[MAX_STR_LEN];
    123 
    124     /*@ pointers *****************************************************/
    125   char *p;
    126   FILE *fin;
    127 
    128     /*@ initialize pointers ******************************************/
    129 
    130   p = output;
    131 
    132     /*@***************************************************************/
    133 
    134   assert_string_is_neither_NULL_nor_zerolength(filename);
    135   if (does_file_exist (filename))
    136     {
    137       sprintf (command, "md5sum \"%s\"", filename);
    138       fin = popen (command, "r");
    139       if (fin)
    140     {
    141       (void) fgets (output, MAX_STR_LEN, fin);
    142       p = strchr (output, ' ');
    143       paranoid_pclose (fin);
    144     }
    145     }
    146   else
    147     {
    148       sprintf (tmp, "File '%s' not found; cannot calc checksum", filename);
    149       log_it (tmp);
    150     }
    151   if (p)
    152     {
    153       *p = '\0';
    154     }
    155   return (output);
     116char *calc_checksum_of_file(char *filename)
     117{
     118    /*@ buffers ***************************************************** */
     119    static char output[MAX_STR_LEN];
     120    char command[MAX_STR_LEN * 2];
     121    char tmp[MAX_STR_LEN];
     122
     123    /*@ pointers **************************************************** */
     124    char *p;
     125    FILE *fin;
     126
     127    /*@ initialize pointers ***************************************** */
     128
     129    p = output;
     130
     131    /*@************************************************************** */
     132
     133    assert_string_is_neither_NULL_nor_zerolength(filename);
     134    if (does_file_exist(filename)) {
     135        sprintf(command, "md5sum \"%s\"", filename);
     136        fin = popen(command, "r");
     137        if (fin) {
     138            (void) fgets(output, MAX_STR_LEN, fin);
     139            p = strchr(output, ' ');
     140            paranoid_pclose(fin);
     141        }
     142    } else {
     143        sprintf(tmp, "File '%s' not found; cannot calc checksum",
     144                filename);
     145        log_it(tmp);
     146    }
     147    if (p) {
     148        *p = '\0';
     149    }
     150    return (output);
    156151}
    157152
     
    164159 * @note The returned string points to static storage that will be overwritten with each call.
    165160 */
    166 char *
    167 calc_file_ugly_minichecksum (char *curr_fname)
    168 {
    169 
    170     /*@ buffers ******************************************************/
    171   static char curr_cksum[1000];
    172 
    173     /*@ pointers *****************************************************/
    174 
    175     /*@ structures ***************************************************/
    176   struct stat buf;
    177 
    178   /*@ initialize data ****************************************************/
    179   curr_cksum[0] = '\0';
    180 
    181     /*@***************************************************************/
    182 
    183   assert_string_is_neither_NULL_nor_zerolength(curr_fname);
    184   if (lstat (curr_fname, &buf))
    185     {
    186       return (curr_cksum); // empty
    187     }
    188 
    189   sprintf (curr_cksum, "%ld-%ld-%ld", (long) (buf.st_size),
    190        (long) (buf.st_mtime), (long) (buf.st_ctime));
    191   return (curr_cksum);
     161char *calc_file_ugly_minichecksum(char *curr_fname)
     162{
     163
     164    /*@ buffers ***************************************************** */
     165    static char curr_cksum[1000];
     166
     167    /*@ pointers **************************************************** */
     168
     169    /*@ structures ************************************************** */
     170    struct stat buf;
     171
     172    /*@ initialize data *************************************************** */
     173    curr_cksum[0] = '\0';
     174
     175    /*@************************************************************** */
     176
     177    assert_string_is_neither_NULL_nor_zerolength(curr_fname);
     178    if (lstat(curr_fname, &buf)) {
     179        return (curr_cksum);    // empty
     180    }
     181
     182    sprintf(curr_cksum, "%ld-%ld-%ld", (long) (buf.st_size),
     183            (long) (buf.st_mtime), (long) (buf.st_ctime));
     184    return (curr_cksum);
    192185}
    193186
     
    200193 * @bug This function uses the shell and "wc -l"; it should probably be rewritten in C.
    201194 */
    202 long
    203 count_lines_in_file (char *filename)
    204 {
    205 
    206     /*@ buffers ******************************************************/
    207   char command[MAX_STR_LEN*2];
    208   char incoming[MAX_STR_LEN];
    209   char tmp[MAX_STR_LEN];
    210 
    211     /*@ long *********************************************************/
    212   long noof_lines = -1L;
    213 
    214     /*@ pointers *****************************************************/
    215   FILE *fin;
    216 
    217   /*@ initialize [0] to null *********************************************/
    218   incoming[0] = '\0';
    219 
    220   assert_string_is_neither_NULL_nor_zerolength(filename);
    221   if (!does_file_exist (filename))
    222     {
    223       sprintf (tmp,
    224            "%s does not exist, so I cannot found the number of lines in it",
    225            filename);
    226       log_it (tmp);
    227       return (0);
    228     }
    229   sprintf (command, "cat %s | wc -l", filename);
    230   if (!does_file_exist(filename)) { return(-1); }
    231   fin = popen (command, "r");
    232   if (fin)
    233     {
    234       if (feof (fin))
    235     {
    236       noof_lines = 0;
    237     }
    238       else
    239     {
    240       (void) fgets (incoming, MAX_STR_LEN - 1, fin);
    241       while (strlen (incoming) > 0
    242          && incoming[strlen (incoming) - 1] < 32)
    243         {
    244           incoming[strlen (incoming) - 1] = '\0';
    245         }
    246       noof_lines = atol (incoming);
    247     }
    248       paranoid_pclose (fin);
    249     }
    250   return (noof_lines);
     195long count_lines_in_file(char *filename)
     196{
     197
     198    /*@ buffers ***************************************************** */
     199    char command[MAX_STR_LEN * 2];
     200    char incoming[MAX_STR_LEN];
     201    char tmp[MAX_STR_LEN];
     202
     203    /*@ long ******************************************************** */
     204    long noof_lines = -1L;
     205
     206    /*@ pointers **************************************************** */
     207    FILE *fin;
     208
     209    /*@ initialize [0] to null ******************************************** */
     210    incoming[0] = '\0';
     211
     212    assert_string_is_neither_NULL_nor_zerolength(filename);
     213    if (!does_file_exist(filename)) {
     214        sprintf(tmp,
     215                "%s does not exist, so I cannot found the number of lines in it",
     216                filename);
     217        log_it(tmp);
     218        return (0);
     219    }
     220    sprintf(command, "cat %s | wc -l", filename);
     221    if (!does_file_exist(filename)) {
     222        return (-1);
     223    }
     224    fin = popen(command, "r");
     225    if (fin) {
     226        if (feof(fin)) {
     227            noof_lines = 0;
     228        } else {
     229            (void) fgets(incoming, MAX_STR_LEN - 1, fin);
     230            while (strlen(incoming) > 0
     231                   && incoming[strlen(incoming) - 1] < 32) {
     232                incoming[strlen(incoming) - 1] = '\0';
     233            }
     234            noof_lines = atol(incoming);
     235        }
     236        paranoid_pclose(fin);
     237    }
     238    return (noof_lines);
    251239}
    252240
     
    257245 * @return TRUE if it exists, FALSE otherwise.
    258246 */
    259 bool
    260 does_file_exist (char *filename)
    261 {
    262 
    263     /*@ structures ***************************************************/
    264   struct stat buf;
    265 
    266     /*@***************************************************************/
    267 
    268   assert(filename!=NULL);
    269   //  assert_string_is_neither_NULL_nor_zerolength(filename);
    270   if (lstat (filename, &buf))
    271     {
    272       log_msg(20, "%s does not exist", filename);
    273       return (FALSE);
    274     }
    275   else
    276     {
    277       log_msg(20, "%s exists", filename);
    278       return (TRUE);
    279     }
     247bool does_file_exist(char *filename)
     248{
     249
     250    /*@ structures ************************************************** */
     251    struct stat buf;
     252
     253    /*@************************************************************** */
     254
     255    assert(filename != NULL);
     256    //  assert_string_is_neither_NULL_nor_zerolength(filename);
     257    if (lstat(filename, &buf)) {
     258        log_msg(20, "%s does not exist", filename);
     259        return (FALSE);
     260    } else {
     261        log_msg(20, "%s exists", filename);
     262        return (TRUE);
     263    }
    280264}
    281265
     
    292276 * while the modification is in progress.
    293277 */
    294 void
    295 exclude_nonexistent_files (char *inout)
    296 {
    297   char infname[MAX_STR_LEN];
    298   char outfname[MAX_STR_LEN];
    299   char tmp[MAX_STR_LEN];
    300   char incoming[MAX_STR_LEN];
    301 
    302     /*@ int **********************************************************/
    303   int i;
    304 
    305     /*@ pointers *****************************************************/
    306   FILE *fin, *fout;
    307 
    308 
    309  /*@ end vars ************************************************************/
    310 
    311   assert_string_is_neither_NULL_nor_zerolength(inout);
    312   sprintf (infname, "%s.in", inout);
    313   sprintf (outfname, "%s", inout);
    314   sprintf (tmp, "cp -f %s %s", inout, infname);
    315   run_program_and_log_output (tmp, FALSE);
    316   if (!(fin = fopen (infname, "r"))) { log_OS_error("Unable to openin infname"); return; }
    317   if (!(fout = fopen (outfname, "w"))){log_OS_error("Unable to openout outfname"); return; }
    318   for (fgets (incoming, MAX_STR_LEN, fin); !feof (fin);
    319        fgets (incoming, MAX_STR_LEN, fin))
    320     {
    321       i = strlen (incoming) - 1;
    322       if (i >= 0 && incoming[i] < 32)
    323     {
    324       incoming[i] = '\0';
    325     }
    326       if (does_file_exist (incoming))
    327     {
    328       fprintf (fout, "%s\n", incoming);
    329     }
    330       else
    331     {
    332       sprintf (tmp, "Excluding '%s'-nonexistent\n", incoming);
    333       log_it (tmp);
    334     }
    335     }
    336   paranoid_fclose (fout);
    337   paranoid_fclose (fin);
    338   unlink (infname);
     278void exclude_nonexistent_files(char *inout)
     279{
     280    char infname[MAX_STR_LEN];
     281    char outfname[MAX_STR_LEN];
     282    char tmp[MAX_STR_LEN];
     283    char incoming[MAX_STR_LEN];
     284
     285    /*@ int ********************************************************* */
     286    int i;
     287
     288    /*@ pointers **************************************************** */
     289    FILE *fin, *fout;
     290
     291
     292    /*@ end vars *********************************************************** */
     293
     294    assert_string_is_neither_NULL_nor_zerolength(inout);
     295    sprintf(infname, "%s.in", inout);
     296    sprintf(outfname, "%s", inout);
     297    sprintf(tmp, "cp -f %s %s", inout, infname);
     298    run_program_and_log_output(tmp, FALSE);
     299    if (!(fin = fopen(infname, "r"))) {
     300        log_OS_error("Unable to openin infname");
     301        return;
     302    }
     303    if (!(fout = fopen(outfname, "w"))) {
     304        log_OS_error("Unable to openout outfname");
     305        return;
     306    }
     307    for (fgets(incoming, MAX_STR_LEN, fin); !feof(fin);
     308         fgets(incoming, MAX_STR_LEN, fin)) {
     309        i = strlen(incoming) - 1;
     310        if (i >= 0 && incoming[i] < 32) {
     311            incoming[i] = '\0';
     312        }
     313        if (does_file_exist(incoming)) {
     314            fprintf(fout, "%s\n", incoming);
     315        } else {
     316            sprintf(tmp, "Excluding '%s'-nonexistent\n", incoming);
     317            log_it(tmp);
     318        }
     319    }
     320    paranoid_fclose(fout);
     321    paranoid_fclose(fin);
     322    unlink(infname);
    339323}
    340324
     
    354338 * @return 0 for success, 1 for failure.
    355339 */
    356 int figure_out_kernel_path_interactively_if_necessary(char*kernel)
    357 {
    358   char tmp[MAX_STR_LEN];
    359 
    360       if (!kernel[0])
    361         { strcpy(kernel, call_program_and_get_last_line_of_output("mindi --findkernel 2> /dev/null")); }
    362       log_it("Calling Mindi with kernel path of '%s'", kernel);
    363       while(!kernel[0])
    364         {
    365           if (!ask_me_yes_or_no("Kernel not found or invalid. Choose another?"))
    366             { return(1); }
    367           if (!popup_and_get_string("Kernel path", "What is the full path and filename of your kernel, please?", kernel, MAX_STR_LEN/4))
    368             { fatal_error("Kernel not found. Please specify with the '-k' flag."); }
    369           sprintf(tmp, "User says kernel is at %s", kernel);
    370           log_it(tmp);
    371         }
    372       return(0);
     340int figure_out_kernel_path_interactively_if_necessary(char *kernel)
     341{
     342    char tmp[MAX_STR_LEN];
     343
     344    if (!kernel[0]) {
     345        strcpy(kernel,
     346               call_program_and_get_last_line_of_output
     347               ("mindi --findkernel 2> /dev/null"));
     348    }
     349    log_it("Calling Mindi with kernel path of '%s'", kernel);
     350    while (!kernel[0]) {
     351        if (!ask_me_yes_or_no
     352            ("Kernel not found or invalid. Choose another?")) {
     353            return (1);
     354        }
     355        if (!popup_and_get_string
     356            ("Kernel path",
     357             "What is the full path and filename of your kernel, please?",
     358             kernel, MAX_STR_LEN / 4)) {
     359            fatal_error
     360                ("Kernel not found. Please specify with the '-k' flag.");
     361        }
     362        sprintf(tmp, "User says kernel is at %s", kernel);
     363        log_it(tmp);
     364    }
     365    return (0);
    373366}
    374367
     
    387380 * to nothing.
    388381 */
    389 char *
    390 find_home_of_exe (char *fname)
    391 {
    392     /*@ buffers **********************/
    393   static char output[MAX_STR_LEN];
    394   char *incoming;
    395   char *command;
    396 
    397   malloc_string(incoming);
    398   malloc_string(command);
    399   incoming[0] = '\0';
    400  /*@********************************/
    401 
    402   assert_string_is_neither_NULL_nor_zerolength(fname);
    403   sprintf (command, "which %s 2> /dev/null", fname);
    404   strcpy (incoming, call_program_and_get_last_line_of_output (command));
    405   if (incoming[0] == '\0')
    406     {
    407       if (system("which file > /dev/null 2> /dev/null"))
     382char *find_home_of_exe(char *fname)
     383{
     384    /*@ buffers ********************* */
     385    static char output[MAX_STR_LEN];
     386    char *incoming;
     387    char *command;
     388
     389    malloc_string(incoming);
     390    malloc_string(command);
     391    incoming[0] = '\0';
     392    /*@******************************* */
     393
     394    assert_string_is_neither_NULL_nor_zerolength(fname);
     395    sprintf(command, "which %s 2> /dev/null", fname);
     396    strcpy(incoming, call_program_and_get_last_line_of_output(command));
     397    if (incoming[0] == '\0') {
     398        if (system("which file > /dev/null 2> /dev/null")) {
     399            paranoid_free(incoming);
     400            paranoid_free(command);
     401            output[0] = '\0';
     402            return (NULL);      // forget it :)
     403        }
     404        sprintf(command,
     405                "file %s 2> /dev/null | cut -d':' -f1 2> /dev/null",
     406                incoming);
     407        strcpy(incoming,
     408               call_program_and_get_last_line_of_output(command));
     409    }
     410    if (incoming[0] == '\0')    // yes, it is == '\0' twice, not once :)
    408411    {
    409       paranoid_free(incoming);
    410       paranoid_free(command);
    411       output[0] = '\0'; return(NULL); // forget it :)
    412     }
    413       sprintf (command, "file %s 2> /dev/null | cut -d':' -f1 2> /dev/null", incoming);
    414       strcpy (incoming, call_program_and_get_last_line_of_output (command));
    415     }
    416   if (incoming[0] == '\0') // yes, it is == '\0' twice, not once :)
    417     {
    418       sprintf (command, "dirname %s 2> /dev/null", incoming);
    419       strcpy (incoming, call_program_and_get_last_line_of_output (command));
    420     }
    421   strcpy (output, incoming);
    422   if (output[0] != '\0' && does_file_exist(output))
    423     { log_msg(4, "find_home_of_exe () --- Found %s at %s", fname, incoming); }
    424   else
    425     { output[0]='\0'; log_msg(4, "find_home_of_exe() --- Could not find %s", fname); }
    426   paranoid_free(incoming);
    427   paranoid_free(command);
    428   if (!output[0]) { return(NULL); } else { return (output); }
     412        sprintf(command, "dirname %s 2> /dev/null", incoming);
     413        strcpy(incoming,
     414               call_program_and_get_last_line_of_output(command));
     415    }
     416    strcpy(output, incoming);
     417    if (output[0] != '\0' && does_file_exist(output)) {
     418        log_msg(4, "find_home_of_exe () --- Found %s at %s", fname,
     419                incoming);
     420    } else {
     421        output[0] = '\0';
     422        log_msg(4, "find_home_of_exe() --- Could not find %s", fname);
     423    }
     424    paranoid_free(incoming);
     425    paranoid_free(command);
     426    if (!output[0]) {
     427        return (NULL);
     428    } else {
     429        return (output);
     430    }
    429431}
    430432
     
    442444 * @return The number found, or 0 if none.
    443445 */
    444 int
    445 get_trackno_from_logfile (char *logfile)
    446 {
    447 
    448     /*@ pointers **********************************************************/
    449   FILE *fin;
    450 
    451     /*@ int ***************************************************************/
    452   int trackno   = 0;
    453   size_t len    = 0;
    454 
    455     /*@ buffer *************************************************************/
    456   char datablock[32701];
    457 
    458   assert_string_is_neither_NULL_nor_zerolength(logfile);
    459   if (!(fin = fopen (logfile, "r"))) { log_OS_error("Unable to open logfile"); fatal_error("Unable to open logfile to read trackno"); }
    460   len = fread (datablock, 1, 32700, fin);
    461   paranoid_fclose (fin);
    462   if (len <= 0)
    463     {
    464       return (0);
    465     }
    466   for (; len > 0 && !isdigit (datablock[len - 1]); len--);
    467   datablock[len--] = '\0';
    468   for (; len > 0 && isdigit (datablock[len - 1]); len--);
    469   trackno = atoi (datablock + len);
    470   /*
    471      sprintf(tmp,"datablock=%s; trackno=%d",datablock+len, trackno);
    472      log_it(tmp);
    473    */
    474   return (trackno);
     446int get_trackno_from_logfile(char *logfile)
     447{
     448
     449    /*@ pointers ********************************************************* */
     450    FILE *fin;
     451
     452    /*@ int ************************************************************** */
     453    int trackno = 0;
     454    size_t len = 0;
     455
     456    /*@ buffer ************************************************************ */
     457    char datablock[32701];
     458
     459    assert_string_is_neither_NULL_nor_zerolength(logfile);
     460    if (!(fin = fopen(logfile, "r"))) {
     461        log_OS_error("Unable to open logfile");
     462        fatal_error("Unable to open logfile to read trackno");
     463    }
     464    len = fread(datablock, 1, 32700, fin);
     465    paranoid_fclose(fin);
     466    if (len <= 0) {
     467        return (0);
     468    }
     469    for (; len > 0 && !isdigit(datablock[len - 1]); len--);
     470    datablock[len--] = '\0';
     471    for (; len > 0 && isdigit(datablock[len - 1]); len--);
     472    trackno = atoi(datablock + len);
     473    /*
     474       sprintf(tmp,"datablock=%s; trackno=%d",datablock+len, trackno);
     475       log_it(tmp);
     476     */
     477    return (trackno);
    475478}
    476479
     
    487490 * @return The percentage found, or 0 for error.
    488491 */
    489 int
    490 grab_percentage_from_last_line_of_file (char *filename)
    491 {
    492 
    493     /*@ buffers ******************************************************/
    494   char tmp[MAX_STR_LEN];
    495   char lastline[MAX_STR_LEN];
    496   char command[MAX_STR_LEN];
    497     /*@ pointers *****************************************************/
    498   char *p;
    499 
    500     /*@ int's ********************************************************/
    501   int i;
    502 
    503   for(i=NOOF_ERR_LINES-1; i>=0 && !strstr(err_log_lines[i], "% Done") && !strstr(err_log_lines[i], "% done"); i--);
    504   if (i<0)
    505     {
    506       sprintf(command, "tail -n3 %s | fgrep -i \"%c\" | tail -n1 | awk '{print $0;}'", filename, '%');
    507       strcpy(lastline, call_program_and_get_last_line_of_output(command));
    508       if (!lastline[0])
    509     {
    510       return(0);
    511     }
    512     }
    513   else
    514     {
    515       strcpy(lastline, err_log_lines[i]);
    516     }
    517 
    518   p = strrchr(lastline, '%');
    519   if (p) { *p='\0'; }
     492int grab_percentage_from_last_line_of_file(char *filename)
     493{
     494
     495    /*@ buffers ***************************************************** */
     496    char tmp[MAX_STR_LEN];
     497    char lastline[MAX_STR_LEN];
     498    char command[MAX_STR_LEN];
     499    /*@ pointers **************************************************** */
     500    char *p;
     501
     502    /*@ int's ******************************************************* */
     503    int i;
     504
     505    for (i = NOOF_ERR_LINES - 1;
     506         i >= 0 && !strstr(err_log_lines[i], "% Done")
     507         && !strstr(err_log_lines[i], "% done"); i--);
     508    if (i < 0) {
     509        sprintf(command,
     510                "tail -n3 %s | fgrep -i \"%c\" | tail -n1 | awk '{print $0;}'",
     511                filename, '%');
     512        strcpy(lastline,
     513               call_program_and_get_last_line_of_output(command));
     514        if (!lastline[0]) {
     515            return (0);
     516        }
     517    } else {
     518        strcpy(lastline, err_log_lines[i]);
     519    }
     520
     521    p = strrchr(lastline, '%');
     522    if (p) {
     523        *p = '\0';
     524    }
    520525//  log_msg(2, "lastline='%s', ", p, lastline);
    521   if (!p)
    522     {
    523       return (0);
    524     }
    525   *p = '\0';
    526   for (p --; *p != ' ' && p != lastline; p--);
    527   if (p != lastline)
    528     {
    529       p++;
    530     }
    531   i = atoi (p);
    532 
    533      sprintf(tmp,"'%s' --> %d",p,i);
     526    if (!p) {
     527        return (0);
     528    }
     529    *p = '\0';
     530    for (p--; *p != ' ' && p != lastline; p--);
     531    if (p != lastline) {
     532        p++;
     533    }
     534    i = atoi(p);
     535
     536    sprintf(tmp, "'%s' --> %d", p, i);
    534537//     log_to_screen(tmp);
    535538
    536   return (i);
     539    return (i);
    537540}
    538541
     
    547550 * @note The returned string points to static storage that will be overwritten with each call.
    548551 */
    549 char *
    550 last_line_of_file (char *filename)
    551 {
    552     /*@ buffers ******************************************************/
    553   static char output[MAX_STR_LEN];
    554   static char command[MAX_STR_LEN*2];
    555   static char tmp[MAX_STR_LEN];
    556 
    557     /*@ pointers *****************************************************/
    558   FILE *fin;
    559 
    560     /*@ end vars *****************************************************/
    561 
    562   if (!does_file_exist (filename))
    563     {
    564       sprintf (tmp, "Tring to get last line of nonexistent file (%s)",
    565            filename);
    566       log_it (tmp);
    567       output[0] = '\0';
    568       return (output);
    569     }
    570   sprintf (command, "cat %s | tail -n1", filename);
    571   fin = popen (command, "r");
    572   (void) fgets (output, MAX_STR_LEN, fin);
    573   paranoid_pclose (fin);
    574   while (strlen (output) > 0 && output[strlen (output) - 1] < 32)
    575     {
    576       output[strlen (output) - 1] = '\0';
    577     }
    578   return (output);
     552char *last_line_of_file(char *filename)
     553{
     554    /*@ buffers ***************************************************** */
     555    static char output[MAX_STR_LEN];
     556    static char command[MAX_STR_LEN * 2];
     557    static char tmp[MAX_STR_LEN];
     558
     559    /*@ pointers **************************************************** */
     560    FILE *fin;
     561
     562    /*@ end vars **************************************************** */
     563
     564    if (!does_file_exist(filename)) {
     565        sprintf(tmp, "Tring to get last line of nonexistent file (%s)",
     566                filename);
     567        log_it(tmp);
     568        output[0] = '\0';
     569        return (output);
     570    }
     571    sprintf(command, "cat %s | tail -n1", filename);
     572    fin = popen(command, "r");
     573    (void) fgets(output, MAX_STR_LEN, fin);
     574    paranoid_pclose(fin);
     575    while (strlen(output) > 0 && output[strlen(output) - 1] < 32) {
     576        output[strlen(output) - 1] = '\0';
     577    }
     578    return (output);
    579579}
    580580
     
    584584 * @return The length of the file, or -1 for error.
    585585 */
    586 long long
    587 length_of_file (char *filename)
    588 {
    589     /*@ pointers ****************************************************/
    590   FILE *fin;
    591 
    592     /*@ long long **************************************************/
    593   long long length;
    594 
    595   fin = fopen (filename, "r");
    596   if (!fin)
    597     {
    598       log_it("filename=%s", filename);
    599       log_OS_error("Unable to openin filename");
    600       return (-1);
    601     }
    602   fseek (fin, 0, SEEK_END);
    603   length = ftell (fin);
    604   paranoid_fclose (fin);
    605   return (length);
     586long long length_of_file(char *filename)
     587{
     588    /*@ pointers *************************************************** */
     589    FILE *fin;
     590
     591    /*@ long long ************************************************* */
     592    long long length;
     593
     594    fin = fopen(filename, "r");
     595    if (!fin) {
     596        log_it("filename=%s", filename);
     597        log_OS_error("Unable to openin filename");
     598        return (-1);
     599    }
     600    fseek(fin, 0, SEEK_END);
     601    length = ftell(fin);
     602    paranoid_fclose(fin);
     603    return (length);
    606604}
    607605
     
    613611 */
    614612int
    615 make_checksum_list_file (char *filelist, char *cksumlist, char *comppath)
    616 {
    617     /*@ pointers *****************************************************/
    618   FILE *fin;
    619   FILE *fout;
    620 
    621     /*@ int   ********************************************************/
    622   int percentage;
    623   int i;
    624   int counter = 0;
    625 
    626     /*@ buffer *******************************************************/
    627   char stub_fname[1000];
    628   char curr_fname[1000];
    629   char curr_cksum[1000];
    630   char tmp[1000];
    631 
    632         /*@ long [long] **************************************************/
    633   long long filelist_length;
    634   long curr_pos;
    635   long start_time;
    636   long current_time;
    637   long time_taken;
    638   long time_remaining;
    639 
    640     /*@ end vars ****************************************************/
    641 
    642   start_time = get_time ();
    643   filelist_length = length_of_file (filelist);
    644   sprintf (tmp, "filelist = %s; cksumlist = %s", filelist, cksumlist);
    645   log_it (tmp);
    646   fin = fopen (filelist, "r");
    647   if (fin == NULL)
    648     {
    649       log_OS_error ("Unable to fopen-in filelist");
    650       log_to_screen ("Can't open filelist");
    651       return (1);
    652     }
    653   fout = fopen (cksumlist, "w");
    654   if (fout == NULL)
    655     {
    656       log_OS_error ("Unable to openout cksumlist");
    657       paranoid_fclose (fin);
    658       log_to_screen ("Can't open checksum list");
    659       return (1);
    660     }
    661   for (fgets (stub_fname, 999, fin); !feof (fin);
    662        fgets (stub_fname, 999, fin))
    663     {
    664       if (stub_fname[(i = strlen (stub_fname) - 1)] < 32)
    665     {
    666       stub_fname[i] = '\0';
    667     }
    668       sprintf (tmp, "%s%s", comppath, stub_fname);
    669       strcpy (curr_fname, tmp + 1);
    670       strcpy (curr_cksum, calc_file_ugly_minichecksum (curr_fname));
    671       fprintf (fout, "%s\t%s\n", curr_fname, curr_cksum);
    672       if (counter++ > 12)
    673     {
    674       current_time = get_time ();
    675       counter = 0;
    676       curr_fname[37] = '\0';
    677       curr_pos = ftell (fin) / 1024;
    678       percentage = (int) (curr_pos * 100 / filelist_length);
    679       time_taken = current_time - start_time;
    680       if (percentage == 0)
    681         {
    682           /*              printf("%0d%% done      \r",percentage); */
    683         }
    684       else
    685         {
    686           time_remaining =
    687         time_taken * 100 / (long) (percentage) - time_taken;
    688           sprintf (tmp,
    689                "%02d%% done   %02d:%02d taken   %02d:%02d remaining  %-37s\r",
    690                percentage, (int) (time_taken / 60),
    691                (int) (time_taken % 60), (int) (time_remaining / 60),
    692                (int) (time_remaining % 60), curr_fname);
    693           log_to_screen (tmp);
    694         }
    695       sync ();
    696     }
    697     }
    698   paranoid_fclose (fout);
    699   paranoid_fclose (fin);
    700   log_it ("Done.");
    701   return (0);
     613make_checksum_list_file(char *filelist, char *cksumlist, char *comppath)
     614{
     615    /*@ pointers **************************************************** */
     616    FILE *fin;
     617    FILE *fout;
     618
     619    /*@ int   ******************************************************* */
     620    int percentage;
     621    int i;
     622    int counter = 0;
     623
     624    /*@ buffer ****************************************************** */
     625    char stub_fname[1000];
     626    char curr_fname[1000];
     627    char curr_cksum[1000];
     628    char tmp[1000];
     629
     630    /*@ long [long] ************************************************* */
     631    long long filelist_length;
     632    long curr_pos;
     633    long start_time;
     634    long current_time;
     635    long time_taken;
     636    long time_remaining;
     637
     638    /*@ end vars *************************************************** */
     639
     640    start_time = get_time();
     641    filelist_length = length_of_file(filelist);
     642    sprintf(tmp, "filelist = %s; cksumlist = %s", filelist, cksumlist);
     643    log_it(tmp);
     644    fin = fopen(filelist, "r");
     645    if (fin == NULL) {
     646        log_OS_error("Unable to fopen-in filelist");
     647        log_to_screen("Can't open filelist");
     648        return (1);
     649    }
     650    fout = fopen(cksumlist, "w");
     651    if (fout == NULL) {
     652        log_OS_error("Unable to openout cksumlist");
     653        paranoid_fclose(fin);
     654        log_to_screen("Can't open checksum list");
     655        return (1);
     656    }
     657    for (fgets(stub_fname, 999, fin); !feof(fin);
     658         fgets(stub_fname, 999, fin)) {
     659        if (stub_fname[(i = strlen(stub_fname) - 1)] < 32) {
     660            stub_fname[i] = '\0';
     661        }
     662        sprintf(tmp, "%s%s", comppath, stub_fname);
     663        strcpy(curr_fname, tmp + 1);
     664        strcpy(curr_cksum, calc_file_ugly_minichecksum(curr_fname));
     665        fprintf(fout, "%s\t%s\n", curr_fname, curr_cksum);
     666        if (counter++ > 12) {
     667            current_time = get_time();
     668            counter = 0;
     669            curr_fname[37] = '\0';
     670            curr_pos = ftell(fin) / 1024;
     671            percentage = (int) (curr_pos * 100 / filelist_length);
     672            time_taken = current_time - start_time;
     673            if (percentage == 0) {
     674                /*              printf("%0d%% done      \r",percentage); */
     675            } else {
     676                time_remaining =
     677                    time_taken * 100 / (long) (percentage) - time_taken;
     678                sprintf(tmp,
     679                        "%02d%% done   %02d:%02d taken   %02d:%02d remaining  %-37s\r",
     680                        percentage, (int) (time_taken / 60),
     681                        (int) (time_taken % 60),
     682                        (int) (time_remaining / 60),
     683                        (int) (time_remaining % 60), curr_fname);
     684                log_to_screen(tmp);
     685            }
     686            sync();
     687        }
     688    }
     689    paranoid_fclose(fout);
     690    paranoid_fclose(fin);
     691    log_it("Done.");
     692    return (0);
    702693}
    703694
     
    708699 * @return The return value of @c mkdir.
    709700 */
    710 int make_hole_for_dir (char*outdir_fname)
    711 {
    712   char tmp[MAX_STR_LEN*2];
    713   int res=0;
    714 
    715   assert_string_is_neither_NULL_nor_zerolength(outdir_fname);
    716   sprintf(tmp, "mkdir -p %s", outdir_fname);
    717   res = system(tmp);
    718   return(res);
     701int make_hole_for_dir(char *outdir_fname)
     702{
     703    char tmp[MAX_STR_LEN * 2];
     704    int res = 0;
     705
     706    assert_string_is_neither_NULL_nor_zerolength(outdir_fname);
     707    sprintf(tmp, "mkdir -p %s", outdir_fname);
     708    res = system(tmp);
     709    return (res);
    719710}
    720711
     
    726717 * @bug Return value unnecessary.
    727718 */
    728 int
    729 make_hole_for_file (char *outfile_fname)
    730 {
    731     /*@ buffer *******************************************************/
    732   char command[MAX_STR_LEN*2];
    733 
    734     /*@ int  *********************************************************/
    735   int res = 0;
    736 
    737     /*@ end vars ****************************************************/
    738 
    739   assert_string_is_neither_NULL_nor_zerolength(outfile_fname);
    740   assert(!strstr(outfile_fname, MNT_CDROM));
    741   assert(!strstr(outfile_fname, "/dev/cdrom"));
    742   sprintf (command, "mkdir -p \"%s\" 2> /dev/null", outfile_fname);
    743   res += system (command);
    744   sprintf (command, "rmdir \"%s\" 2> /dev/null", outfile_fname);
    745   res += system (command);
    746       sprintf (command, "rm -f \"%s\" 2> /dev/null", outfile_fname);
    747   res += system (command);
    748   unlink (outfile_fname);
    749   return (0);
     719int make_hole_for_file(char *outfile_fname)
     720{
     721    /*@ buffer ****************************************************** */
     722    char command[MAX_STR_LEN * 2];
     723
     724    /*@ int  ******************************************************** */
     725    int res = 0;
     726
     727    /*@ end vars *************************************************** */
     728
     729    assert_string_is_neither_NULL_nor_zerolength(outfile_fname);
     730    assert(!strstr(outfile_fname, MNT_CDROM));
     731    assert(!strstr(outfile_fname, "/dev/cdrom"));
     732    sprintf(command, "mkdir -p \"%s\" 2> /dev/null", outfile_fname);
     733    res += system(command);
     734    sprintf(command, "rmdir \"%s\" 2> /dev/null", outfile_fname);
     735    res += system(command);
     736    sprintf(command, "rm -f \"%s\" 2> /dev/null", outfile_fname);
     737    res += system(command);
     738    unlink(outfile_fname);
     739    return (0);
    750740}
    751741
     
    759749 * @return The number of lines matched.
    760750 */
    761 long
    762 noof_lines_that_match_wildcard (char *filelist_fname, char *wildcard)
    763 {
    764     /*@ long ********************************************************/
    765   long matches = 0;
    766 
    767     /*@ pointers ****************************************************/
    768   FILE *fin;
    769 
    770     /*@ buffers *****************************************************/
    771   char incoming[MAX_STR_LEN];
    772 
    773     /*@ end vars ****************************************************/
    774 
    775 
    776   fin = fopen (filelist_fname, "r");
    777 
    778   if (!fin)
    779     {
    780       log_OS_error("Unable to openin filelist_fname");
    781       return (0);
    782     }
    783   (void) fgets (incoming, MAX_STR_LEN - 1, fin);
    784   while (!feof (fin))
    785     {
    786       if (strstr (incoming, wildcard))
    787     {
    788       matches++;
    789     }
    790       (void) fgets (incoming, MAX_STR_LEN - 1, fin);
    791     }
    792   paranoid_fclose (fin);
    793   return (matches);
     751long noof_lines_that_match_wildcard(char *filelist_fname, char *wildcard)
     752{
     753    /*@ long ******************************************************* */
     754    long matches = 0;
     755
     756    /*@ pointers *************************************************** */
     757    FILE *fin;
     758
     759    /*@ buffers **************************************************** */
     760    char incoming[MAX_STR_LEN];
     761
     762    /*@ end vars *************************************************** */
     763
     764
     765    fin = fopen(filelist_fname, "r");
     766
     767    if (!fin) {
     768        log_OS_error("Unable to openin filelist_fname");
     769        return (0);
     770    }
     771    (void) fgets(incoming, MAX_STR_LEN - 1, fin);
     772    while (!feof(fin)) {
     773        if (strstr(incoming, wildcard)) {
     774            matches++;
     775        }
     776        (void) fgets(incoming, MAX_STR_LEN - 1, fin);
     777    }
     778    paranoid_fclose(fin);
     779    return (matches);
    794780}
    795781
     
    804790 * @note This function does not provide support against multiple instances, unless you check for that yourself.
    805791 */
    806 void register_pid(pid_t pid, char*name_str)
    807 {
    808   char tmp[MAX_STR_LEN+1], lockfile_fname[MAX_STR_LEN+1];
    809   int res;
    810   FILE*fin;
    811 
    812   sprintf(lockfile_fname, "/var/run/monitas-%s.pid", name_str);
    813   if (!pid)
    814     {
    815       log_it("Unregistering PID");
    816       if (unlink(lockfile_fname)) { log_it( "Error unregistering PID"); }
    817       return;
    818     }
    819   if (does_file_exist(lockfile_fname))
    820     {
    821       tmp[0]='\0';
    822       if ((fin=fopen(lockfile_fname,"r"))) { (void) fgets(tmp, MAX_STR_LEN, fin); paranoid_fclose(fin); }
    823       else { log_OS_error("Unable to openin lockfile_fname"); }
    824       pid = (pid_t) atol(tmp);
    825       sprintf(tmp, "ps %ld > /dev/null 2> /dev/null", (long int)pid);
    826       res = system(tmp);
    827       if (!res)
    828         {
    829           log_it ("I believe the daemon is already running. If it isn't, please delete %s and try again.", lockfile_fname);
    830         }
    831     }
    832   sprintf(tmp, "echo %ld > %s 2> /dev/null", (long int)getpid(), lockfile_fname);
    833   if (system(tmp)) { fatal_error( "Cannot register PID"); }
     792void register_pid(pid_t pid, char *name_str)
     793{
     794    char tmp[MAX_STR_LEN + 1], lockfile_fname[MAX_STR_LEN + 1];
     795    int res;
     796    FILE *fin;
     797
     798    sprintf(lockfile_fname, "/var/run/monitas-%s.pid", name_str);
     799    if (!pid) {
     800        log_it("Unregistering PID");
     801        if (unlink(lockfile_fname)) {
     802            log_it("Error unregistering PID");
     803        }
     804        return;
     805    }
     806    if (does_file_exist(lockfile_fname)) {
     807        tmp[0] = '\0';
     808        if ((fin = fopen(lockfile_fname, "r"))) {
     809            (void) fgets(tmp, MAX_STR_LEN, fin);
     810            paranoid_fclose(fin);
     811        } else {
     812            log_OS_error("Unable to openin lockfile_fname");
     813        }
     814        pid = (pid_t) atol(tmp);
     815        sprintf(tmp, "ps %ld > /dev/null 2> /dev/null", (long int) pid);
     816        res = system(tmp);
     817        if (!res) {
     818            log_it
     819                ("I believe the daemon is already running. If it isn't, please delete %s and try again.",
     820                 lockfile_fname);
     821        }
     822    }
     823    sprintf(tmp, "echo %ld > %s 2> /dev/null", (long int) getpid(),
     824            lockfile_fname);
     825    if (system(tmp)) {
     826        fatal_error("Cannot register PID");
     827    }
    834828}
    835829
     
    842836 * @return The size of the partition in KB.
    843837 */
    844 long size_of_partition_in_mountlist_K(char*tmpdir, char*dev)
    845 {
    846     char command[MAX_STR_LEN];
    847     char mountlist[MAX_STR_LEN];
    848     char sz_res[MAX_STR_LEN];
    849     long file_len_K;
    850            
    851     sprintf(mountlist, "%s/mountlist.txt", tmpdir);
    852     sprintf (command,
    853        "cat %s/mountlist.txt | grep \"%s \" | head -n1 | awk '{print $4;}'",
    854       tmpdir, dev);
    855     log_it (command);
    856     strcpy (sz_res, call_program_and_get_last_line_of_output (command));
    857     file_len_K = atol (sz_res);
    858     log_msg(4, "%s --> %s --> %ld", command, sz_res, file_len_K);
    859     return(file_len_K);
     838long size_of_partition_in_mountlist_K(char *tmpdir, char *dev)
     839{
     840    char command[MAX_STR_LEN];
     841    char mountlist[MAX_STR_LEN];
     842    char sz_res[MAX_STR_LEN];
     843    long file_len_K;
     844
     845    sprintf(mountlist, "%s/mountlist.txt", tmpdir);
     846    sprintf(command,
     847            "cat %s/mountlist.txt | grep \"%s \" | head -n1 | awk '{print $4;}'",
     848            tmpdir, dev);
     849    log_it(command);
     850    strcpy(sz_res, call_program_and_get_last_line_of_output(command));
     851    file_len_K = atol(sz_res);
     852    log_msg(4, "%s --> %s --> %ld", command, sz_res, file_len_K);
     853    return (file_len_K);
    860854}
    861855
     
    865859 * @return The total size of all biggiefiles in KB.
    866860 */
    867 long
    868 size_of_all_biggiefiles_K (struct s_bkpinfo *bkpinfo)
    869 {
    870     /*@ buffers ******************************************************/
    871   char *fname;
    872   char *biggielist;
    873   char *comment;
    874 
    875     /*@ long *********************************************************/
    876   long scratchL = 0;
    877   long file_len_K;
    878 
    879     /*@ pointers ****************************************************/
    880   FILE *fin=NULL;
    881 
    882     /*@ end vars ****************************************************/
    883 
    884   malloc_string(fname);
    885   malloc_string(biggielist);
    886   malloc_string(comment);
    887   log_it ("Calculating size of all biggiefiles (in total)");
    888   sprintf (biggielist, "%s/biggielist.txt", bkpinfo->tmpdir);
    889   log_it("biggielist = %s", biggielist);
    890   if (!(fin = fopen (biggielist, "r")))
    891     {
    892       log_OS_error
    893     ("Cannot open biggielist. OK, so estimate is based on filesets only.");
    894     }
    895   else
    896     {
    897       log_msg(4, "Reading it...");
    898       for (fgets (fname, MAX_STR_LEN, fin); !feof (fin);
    899        fgets (fname, MAX_STR_LEN, fin))
    900     {
    901       if (fname[strlen(fname)-1]<=32) { fname[strlen(fname)-1]='\0'; }
    902       if (0 == strncmp (fname, "/dev/", 5))
    903         {
    904           file_len_K = get_phys_size_of_drive(fname)*1024L;
    905         }
    906       else
    907         {
    908           file_len_K = (long) (length_of_file (fname) / 1024);
    909         }
    910           if (file_len_K > 0)
    911         {
    912           scratchL += file_len_K;
    913           log_msg(4, "%s --> %ld K", fname, file_len_K);
    914         }
    915       sprintf (comment, "After adding %s, scratchL+%ld now equals %ld",
    916            fname, file_len_K, scratchL);
    917       log_msg(4, comment);
    918           if (feof(fin)) { break; }
    919     }
    920     }
    921   log_it ("Closing...");
    922   paranoid_fclose (fin);
    923   log_it ("Finished calculating total size of all biggiefiles");
    924   paranoid_free(fname);
    925   paranoid_free(biggielist);
    926   paranoid_free(comment);
    927   return (scratchL);
     861long size_of_all_biggiefiles_K(struct s_bkpinfo *bkpinfo)
     862{
     863    /*@ buffers ***************************************************** */
     864    char *fname;
     865    char *biggielist;
     866    char *comment;
     867
     868    /*@ long ******************************************************** */
     869    long scratchL = 0;
     870    long file_len_K;
     871
     872    /*@ pointers *************************************************** */
     873    FILE *fin = NULL;
     874
     875    /*@ end vars *************************************************** */
     876
     877    malloc_string(fname);
     878    malloc_string(biggielist);
     879    malloc_string(comment);
     880    log_it("Calculating size of all biggiefiles (in total)");
     881    sprintf(biggielist, "%s/biggielist.txt", bkpinfo->tmpdir);
     882    log_it("biggielist = %s", biggielist);
     883    if (!(fin = fopen(biggielist, "r"))) {
     884        log_OS_error
     885            ("Cannot open biggielist. OK, so estimate is based on filesets only.");
     886    } else {
     887        log_msg(4, "Reading it...");
     888        for (fgets(fname, MAX_STR_LEN, fin); !feof(fin);
     889             fgets(fname, MAX_STR_LEN, fin)) {
     890            if (fname[strlen(fname) - 1] <= 32) {
     891                fname[strlen(fname) - 1] = '\0';
     892            }
     893            if (0 == strncmp(fname, "/dev/", 5)) {
     894                file_len_K = get_phys_size_of_drive(fname) * 1024L;
     895            } else {
     896                file_len_K = (long) (length_of_file(fname) / 1024);
     897            }
     898            if (file_len_K > 0) {
     899                scratchL += file_len_K;
     900                log_msg(4, "%s --> %ld K", fname, file_len_K);
     901            }
     902            sprintf(comment,
     903                    "After adding %s, scratchL+%ld now equals %ld", fname,
     904                    file_len_K, scratchL);
     905            log_msg(4, comment);
     906            if (feof(fin)) {
     907                break;
     908            }
     909        }
     910    }
     911    log_it("Closing...");
     912    paranoid_fclose(fin);
     913    log_it("Finished calculating total size of all biggiefiles");
     914    paranoid_free(fname);
     915    paranoid_free(biggielist);
     916    paranoid_free(comment);
     917    return (scratchL);
    928918}
    929919
     
    934924 * @return The amount of space occupied in KB.
    935925 */
    936 long long
    937 space_occupied_by_cd (char *mountpt)
    938 {
    939     /*@ buffer *******************************************************/
    940   char tmp[MAX_STR_LEN];
    941   char command[MAX_STR_LEN*2];
    942   long long llres;
    943     /*@ pointers *****************************************************/
    944   char *p;
    945   FILE *fin;
    946 
    947     /*@ end vars ****************************************************/
    948 
    949   sprintf (command, "du -sk %s", mountpt);
    950   fin = popen (command, "r");
    951   (void) fgets (tmp, MAX_STR_LEN, fin);
    952   paranoid_pclose (fin);
    953   p = strchr (tmp, '\t');
    954   if (p)
    955     {
    956       *p = '\0';
    957     }
    958   for(p=tmp,llres=0; *p!='\0'; p++)
    959     {
    960       llres*=10;
    961       llres+=(int)(*p - '0');
    962     }
    963   return (llres);
     926long long space_occupied_by_cd(char *mountpt)
     927{
     928    /*@ buffer ****************************************************** */
     929    char tmp[MAX_STR_LEN];
     930    char command[MAX_STR_LEN * 2];
     931    long long llres;
     932    /*@ pointers **************************************************** */
     933    char *p;
     934    FILE *fin;
     935
     936    /*@ end vars *************************************************** */
     937
     938    sprintf(command, "du -sk %s", mountpt);
     939    fin = popen(command, "r");
     940    (void) fgets(tmp, MAX_STR_LEN, fin);
     941    paranoid_pclose(fin);
     942    p = strchr(tmp, '\t');
     943    if (p) {
     944        *p = '\0';
     945    }
     946    for (p = tmp, llres = 0; *p != '\0'; p++) {
     947        llres *= 10;
     948        llres += (int) (*p - '0');
     949    }
     950    return (llres);
    964951}
    965952
     
    972959 * @ingroup utilityGroup
    973960 */
    974 unsigned int
    975 updcrc (unsigned int crc, unsigned int c)
    976 {
    977   unsigned int tmp;
    978   tmp = (crc >> 8) ^ c;
    979   crc = (crc << 8) ^ crctttab[tmp & 255];
    980   return crc;
     961unsigned int updcrc(unsigned int crc, unsigned int c)
     962{
     963    unsigned int tmp;
     964    tmp = (crc >> 8) ^ c;
     965    crc = (crc << 8) ^ crctttab[tmp & 255];
     966    return crc;
    981967}
    982968
     
    988974 * @ingroup utilityGroup
    989975 */
    990 unsigned int
    991 updcrcr (unsigned int crc, unsigned int c)
    992 {
    993   unsigned int tmp;
    994   tmp = crc ^ c;
    995   crc = (crc >> 8) ^ crc16tab[tmp & 0xff];
    996   return crc;
     976unsigned int updcrcr(unsigned int crc, unsigned int c)
     977{
     978    unsigned int tmp;
     979    tmp = crc ^ c;
     980    crc = (crc >> 8) ^ crc16tab[tmp & 0xff];
     981    return crc;
    997982}
    998983
     
    1006991 * @return 0 if it's found, nonzero if not.
    1007992 */
    1008 int
    1009 whine_if_not_found (char *fname)
    1010 {
    1011     /*@ buffers ****/
    1012   char command[MAX_STR_LEN*2];
    1013   char errorstr[MAX_STR_LEN];
    1014 
    1015 
    1016   sprintf (command, "which %s > /dev/null 2> /dev/null", fname);
    1017   sprintf (errorstr, "Please install '%s'. I cannot find it on your system.",
    1018        fname);
    1019   if (system (command))
    1020     {
    1021       log_to_screen (errorstr);
    1022       log_to_screen
    1023     ("There may be hyperlink at http://www.mondorescue.com which");
    1024       log_to_screen ("will take you to the relevant (missing) package.");
    1025       return (1);
    1026     }
    1027   else
    1028     {
    1029       return (0);
    1030     }
     993int whine_if_not_found(char *fname)
     994{
     995    /*@ buffers *** */
     996    char command[MAX_STR_LEN * 2];
     997    char errorstr[MAX_STR_LEN];
     998
     999
     1000    sprintf(command, "which %s > /dev/null 2> /dev/null", fname);
     1001    sprintf(errorstr,
     1002            "Please install '%s'. I cannot find it on your system.",
     1003            fname);
     1004    if (system(command)) {
     1005        log_to_screen(errorstr);
     1006        log_to_screen
     1007            ("There may be hyperlink at http://www.mondorescue.com which");
     1008        log_to_screen("will take you to the relevant (missing) package.");
     1009        return (1);
     1010    } else {
     1011        return (0);
     1012    }
    10311013}
    10321014
     
    10431025 * @return 0 for success, 1 for failure.
    10441026 */
    1045 int
    1046 write_one_liner_data_file (char *fname, char *contents)
    1047 {
    1048     /*@ pointers ****************************************************/
    1049   FILE *fout;
    1050   int res=0;
    1051 
    1052     /*@ end vars ****************************************************/
    1053 
    1054   assert_string_is_neither_NULL_nor_zerolength(fname);
    1055   if (!contents) { log_it("%d: Warning - writing NULL to %s", __LINE__, fname); }
    1056   if (!(fout = fopen (fname, "w")))
    1057     {
    1058       log_it("fname=%s");
    1059       log_OS_error("Unable to openout fname");
    1060       return (1);
    1061     }
    1062   fprintf (fout, "%s\n", contents);
    1063   paranoid_fclose (fout);
    1064   return (res);
     1027int write_one_liner_data_file(char *fname, char *contents)
     1028{
     1029    /*@ pointers *************************************************** */
     1030    FILE *fout;
     1031    int res = 0;
     1032
     1033    /*@ end vars *************************************************** */
     1034
     1035    assert_string_is_neither_NULL_nor_zerolength(fname);
     1036    if (!contents) {
     1037        log_it("%d: Warning - writing NULL to %s", __LINE__, fname);
     1038    }
     1039    if (!(fout = fopen(fname, "w"))) {
     1040        log_it("fname=%s");
     1041        log_OS_error("Unable to openout fname");
     1042        return (1);
     1043    }
     1044    fprintf(fout, "%s\n", contents);
     1045    paranoid_fclose(fout);
     1046    return (res);
    10651047}
    10661048
     
    10731055 * @return 0 for success, nonzero for failure.
    10741056 */
    1075 int
    1076 read_one_liner_data_file (char *fname, char *contents)
    1077 {
    1078     /*@ pointers ****************************************************/
    1079   FILE *fin;
    1080   int res=0;
    1081   int i;
    1082 
    1083     /*@ end vars ****************************************************/
    1084 
    1085   assert_string_is_neither_NULL_nor_zerolength(fname);
    1086   if (!contents) { log_it("%d: Warning - reading NULL from %s", __LINE__, fname); }
    1087   if (!(fin = fopen (fname, "r")))
    1088     {
    1089       log_it("fname=%s", fname);
    1090       log_OS_error("Unable to openin fname");
    1091       return (1);
    1092     }
    1093   fscanf (fin, "%s\n", contents);
    1094   i = strlen(contents);
    1095   if (i>0 && contents[i-1] < 32) { contents[i-1] = '\0'; }
    1096   paranoid_fclose (fin);
    1097   return (res);
     1057int read_one_liner_data_file(char *fname, char *contents)
     1058{
     1059    /*@ pointers *************************************************** */
     1060    FILE *fin;
     1061    int res = 0;
     1062    int i;
     1063
     1064    /*@ end vars *************************************************** */
     1065
     1066    assert_string_is_neither_NULL_nor_zerolength(fname);
     1067    if (!contents) {
     1068        log_it("%d: Warning - reading NULL from %s", __LINE__, fname);
     1069    }
     1070    if (!(fin = fopen(fname, "r"))) {
     1071        log_it("fname=%s", fname);
     1072        log_OS_error("Unable to openin fname");
     1073        return (1);
     1074    }
     1075    fscanf(fin, "%s\n", contents);
     1076    i = strlen(contents);
     1077    if (i > 0 && contents[i - 1] < 32) {
     1078        contents[i - 1] = '\0';
     1079    }
     1080    paranoid_fclose(fin);
     1081    return (res);
    10981082}
    10991083
     
    11161100 * - @c bkpinfo->tmpdir
    11171101 */
    1118 void
    1119 copy_mondo_and_mindi_stuff_to_scratchdir (struct s_bkpinfo *bkpinfo)
    1120 {
    1121     /*@ Char buffers ***/
    1122   char command[MAX_STR_LEN*2];
    1123   char tmp[MAX_STR_LEN];
    1124   char old_pwd[MAX_STR_LEN];
    1125 
    1126   mvaddstr_and_log_it (g_currentY, 0,
    1127                "Copying Mondo's core files to the scratch directory");
    1128 
    1129   log_msg(4, "g_mondo_home='%s'", g_mondo_home);
    1130   if (strlen(g_mondo_home)<2)
    1131     { find_and_store_mondoarchives_home(g_mondo_home); }
    1132   sprintf (command, CP_BIN " --parents -pRdf %s %s", g_mondo_home,
    1133        bkpinfo->scratchdir);
    1134 
    1135   log_msg(4, "command = %s", command);
    1136   if (run_program_and_log_output (command, 1))
    1137     {
    1138       fatal_error ("Failed to copy Mondo's stuff to scratchdir");
    1139     }
    1140 
    1141   sprintf(tmp, "%s/payload.tgz", g_mondo_home);
    1142   if (does_file_exist(tmp))
    1143     {
    1144       log_it("Untarring payload %s to scratchdir %s", tmp, bkpinfo->scratchdir);
    1145       (void) getcwd (old_pwd, MAX_STR_LEN -1);
    1146       chdir (bkpinfo->scratchdir);
    1147       sprintf(command, "tar -zxvf %s", tmp);
    1148       if (run_program_and_log_output(command, FALSE))
    1149         { fatal_error ("Failed to untar payload"); }
    1150       chdir (old_pwd);
    1151     }
    1152 
    1153   sprintf (command, "cp -f %s/LAST-FILELIST-NUMBER %s", bkpinfo->tmpdir,
    1154        bkpinfo->scratchdir);
    1155 
    1156   if (run_program_and_log_output (command, FALSE))
    1157     {
    1158       fatal_error ("Failed to copy LAST-FILELIST-NUMBER to scratchdir");
    1159     }
    1160 
    1161   strcpy (tmp,
    1162       call_program_and_get_last_line_of_output ("which mondorestore"));
    1163   if (!tmp[0]) { fatal_error("'which mondorestore' returned null. Where's your mondorestore? `which` can't find it. That's odd. Did you install mondorestore?"); }
    1164   sprintf (command, "cp -f %s %s", tmp, bkpinfo->tmpdir);
    1165   if (run_program_and_log_output (command, FALSE))
    1166     {
    1167       fatal_error ("Failed to copy mondorestore to tmpdir");
    1168     }
    1169 
    1170   sprintf (command, "hostname > %s/HOSTNAME", bkpinfo->scratchdir);
    1171   paranoid_system (command);
    1172 
    1173   if (bkpinfo->postnuke_tarball[0])
    1174     {
    1175       sprintf (command, "cp -f %s %s/post-nuke.tgz", bkpinfo->postnuke_tarball, bkpinfo->tmpdir);
    1176       if (run_program_and_log_output (command, FALSE))
    1177         { fatal_error("Unable to copy post-nuke tarball to tmpdir"); }
    1178     }
    1179 
    1180 
    1181   mvaddstr_and_log_it (g_currentY++, 74, "Done.");
     1102void copy_mondo_and_mindi_stuff_to_scratchdir(struct s_bkpinfo *bkpinfo)
     1103{
     1104    /*@ Char buffers ** */
     1105    char command[MAX_STR_LEN * 2];
     1106    char tmp[MAX_STR_LEN];
     1107    char old_pwd[MAX_STR_LEN];
     1108
     1109    mvaddstr_and_log_it(g_currentY, 0,
     1110                        "Copying Mondo's core files to the scratch directory");
     1111
     1112    log_msg(4, "g_mondo_home='%s'", g_mondo_home);
     1113    if (strlen(g_mondo_home) < 2) {
     1114        find_and_store_mondoarchives_home(g_mondo_home);
     1115    }
     1116    sprintf(command, CP_BIN " --parents -pRdf %s %s", g_mondo_home,
     1117            bkpinfo->scratchdir);
     1118
     1119    log_msg(4, "command = %s", command);
     1120    if (run_program_and_log_output(command, 1)) {
     1121        fatal_error("Failed to copy Mondo's stuff to scratchdir");
     1122    }
     1123
     1124    sprintf(tmp, "%s/payload.tgz", g_mondo_home);
     1125    if (does_file_exist(tmp)) {
     1126        log_it("Untarring payload %s to scratchdir %s", tmp,
     1127               bkpinfo->scratchdir);
     1128        (void) getcwd(old_pwd, MAX_STR_LEN - 1);
     1129        chdir(bkpinfo->scratchdir);
     1130        sprintf(command, "tar -zxvf %s", tmp);
     1131        if (run_program_and_log_output(command, FALSE)) {
     1132            fatal_error("Failed to untar payload");
     1133        }
     1134        chdir(old_pwd);
     1135    }
     1136
     1137    sprintf(command, "cp -f %s/LAST-FILELIST-NUMBER %s", bkpinfo->tmpdir,
     1138            bkpinfo->scratchdir);
     1139
     1140    if (run_program_and_log_output(command, FALSE)) {
     1141        fatal_error("Failed to copy LAST-FILELIST-NUMBER to scratchdir");
     1142    }
     1143
     1144    strcpy(tmp,
     1145           call_program_and_get_last_line_of_output("which mondorestore"));
     1146    if (!tmp[0]) {
     1147        fatal_error
     1148            ("'which mondorestore' returned null. Where's your mondorestore? `which` can't find it. That's odd. Did you install mondorestore?");
     1149    }
     1150    sprintf(command, "cp -f %s %s", tmp, bkpinfo->tmpdir);
     1151    if (run_program_and_log_output(command, FALSE)) {
     1152        fatal_error("Failed to copy mondorestore to tmpdir");
     1153    }
     1154
     1155    sprintf(command, "hostname > %s/HOSTNAME", bkpinfo->scratchdir);
     1156    paranoid_system(command);
     1157
     1158    if (bkpinfo->postnuke_tarball[0]) {
     1159        sprintf(command, "cp -f %s %s/post-nuke.tgz",
     1160                bkpinfo->postnuke_tarball, bkpinfo->tmpdir);
     1161        if (run_program_and_log_output(command, FALSE)) {
     1162            fatal_error("Unable to copy post-nuke tarball to tmpdir");
     1163        }
     1164    }
     1165
     1166
     1167    mvaddstr_and_log_it(g_currentY++, 74, "Done.");
    11821168}
    11831169
     
    11941180 * - @c tmpdir
    11951181 */
    1196 void
    1197 store_nfs_config (struct s_bkpinfo *bkpinfo)
    1198 {
    1199 
    1200     /*@ buffers *********/
    1201   char outfile[MAX_STR_LEN];
    1202   char nfs_dev[MAX_STR_LEN];
    1203   char nfs_mount[MAX_STR_LEN];
    1204   char nfs_client_ipaddr[MAX_STR_LEN];
    1205   char nfs_server_ipaddr[MAX_STR_LEN];
    1206   char tmp[MAX_STR_LEN];
    1207   char command[MAX_STR_LEN*2];
    1208 
    1209     /*@ pointers ******/
    1210   char *p;
    1211   FILE *fout;
    1212 
    1213 
    1214 
    1215   log_it ("Storing NFS configuration");
    1216   strcpy (tmp, bkpinfo->nfs_mount);
    1217   p = strchr (tmp, ':');
    1218   if (!p)
    1219     {
    1220       fatal_error
    1221     ("NFS mount doesn't have a colon in it, e.g. 192.168.1.4:/home/nfs");
    1222     }
    1223   *(p++) = '\0';
    1224   strcpy (nfs_server_ipaddr, tmp);
    1225   strcpy (nfs_mount, p);
    1226   sprintf (command,
    1227        "ifconfig | tr '\n' '#' | sed s/##// | tr '#' ' ' | tr '' '\n' | head -n1 | cut -d' ' -f1");
    1228   strcpy (nfs_dev, call_program_and_get_last_line_of_output (command));
    1229   sprintf (command,
    1230        "ifconfig | tr '\n' '#' | sed s/##// | tr '#' ' ' | tr '' '\\n' | head -n1 | tr -s '\t' ' ' | cut -d' ' -f7 | cut -d':' -f2");
    1231   strcpy (nfs_client_ipaddr,
    1232       call_program_and_get_last_line_of_output (command));
    1233   sprintf (tmp, "nfs_client_ipaddr=%s; nfs_server_ipaddr=%s; nfs_mount=%s",
    1234        nfs_client_ipaddr, nfs_server_ipaddr, nfs_mount);
    1235   if (strlen (nfs_dev) < 2)
    1236     {
    1237       fatal_error
    1238     ("Unable to find ethN (eth0, eth1, ...) adapter via NFS mount you specified.");
    1239     }
    1240   sprintf (outfile, "%s/start-nfs", bkpinfo->tmpdir);
    1241   sprintf (tmp, "outfile = %s", outfile);
    1242   log_it (tmp);
    1243   if (!(fout = fopen (outfile, "w")))
    1244     {
    1245       fatal_error ("Cannot store NFS config");
    1246     }
    1247   fprintf (fout, "ifconfig lo 127.0.0.1  # config loopback\n");
    1248   fprintf (fout, "ifconfig %s %s; # config client\n", nfs_dev,
    1249        nfs_client_ipaddr);
    1250   fprintf (fout, "ping -c1 %s; # ping server\n", nfs_server_ipaddr);
    1251   fprintf (fout, "mount -t nfs -o nolock %s /tmp/isodir\n", bkpinfo->nfs_mount);
    1252   fprintf (fout, "exit 0\n");
    1253   paranoid_fclose (fout);
    1254   chmod (outfile, 0777);
    1255   make_hole_for_dir( "/var/cache/mondo-archive");
     1182void store_nfs_config(struct s_bkpinfo *bkpinfo)
     1183{
     1184
     1185    /*@ buffers ******** */
     1186    char outfile[MAX_STR_LEN];
     1187    char nfs_dev[MAX_STR_LEN];
     1188    char nfs_mount[MAX_STR_LEN];
     1189    char nfs_client_ipaddr[MAX_STR_LEN];
     1190    char nfs_server_ipaddr[MAX_STR_LEN];
     1191    char tmp[MAX_STR_LEN];
     1192    char command[MAX_STR_LEN * 2];
     1193
     1194    /*@ pointers ***** */
     1195    char *p;
     1196    FILE *fout;
     1197
     1198
     1199
     1200    log_it("Storing NFS configuration");
     1201    strcpy(tmp, bkpinfo->nfs_mount);
     1202    p = strchr(tmp, ':');
     1203    if (!p) {
     1204        fatal_error
     1205            ("NFS mount doesn't have a colon in it, e.g. 192.168.1.4:/home/nfs");
     1206    }
     1207    *(p++) = '\0';
     1208    strcpy(nfs_server_ipaddr, tmp);
     1209    strcpy(nfs_mount, p);
     1210    sprintf(command,
     1211            "ifconfig | tr '\n' '#' | sed s/##// | tr '#' ' ' | tr '' '\n' | head -n1 | cut -d' ' -f1");
     1212    strcpy(nfs_dev, call_program_and_get_last_line_of_output(command));
     1213    sprintf(command,
     1214            "ifconfig | tr '\n' '#' | sed s/##// | tr '#' ' ' | tr '' '\\n' | head -n1 | tr -s '\t' ' ' | cut -d' ' -f7 | cut -d':' -f2");
     1215    strcpy(nfs_client_ipaddr,
     1216           call_program_and_get_last_line_of_output(command));
     1217    sprintf(tmp,
     1218            "nfs_client_ipaddr=%s; nfs_server_ipaddr=%s; nfs_mount=%s",
     1219            nfs_client_ipaddr, nfs_server_ipaddr, nfs_mount);
     1220    if (strlen(nfs_dev) < 2) {
     1221        fatal_error
     1222            ("Unable to find ethN (eth0, eth1, ...) adapter via NFS mount you specified.");
     1223    }
     1224    sprintf(outfile, "%s/start-nfs", bkpinfo->tmpdir);
     1225    sprintf(tmp, "outfile = %s", outfile);
     1226    log_it(tmp);
     1227    if (!(fout = fopen(outfile, "w"))) {
     1228        fatal_error("Cannot store NFS config");
     1229    }
     1230    fprintf(fout, "ifconfig lo 127.0.0.1  # config loopback\n");
     1231    fprintf(fout, "ifconfig %s %s; # config client\n", nfs_dev,
     1232            nfs_client_ipaddr);
     1233    fprintf(fout, "ping -c1 %s; # ping server\n", nfs_server_ipaddr);
     1234    fprintf(fout, "mount -t nfs -o nolock %s /tmp/isodir\n",
     1235            bkpinfo->nfs_mount);
     1236    fprintf(fout, "exit 0\n");
     1237    paranoid_fclose(fout);
     1238    chmod(outfile, 0777);
     1239    make_hole_for_dir("/var/cache/mondo-archive");
    12561240
    12571241//  paranoid_system ("mkdir -p /var/cache/mondo-archive 2> /dev/null");
    12581242
    1259   sprintf (tmp, "cp -f %s /var/cache/mondo-archive", outfile);
    1260   run_program_and_log_output(tmp, FALSE);
    1261 
    1262   sprintf (tmp, "%s/NFS-DEV", bkpinfo->tmpdir);
    1263   write_one_liner_data_file (tmp, nfs_dev);
    1264 
    1265   sprintf (tmp, "%s/NFS-CLIENT-IPADDR", bkpinfo->tmpdir);
    1266   write_one_liner_data_file (tmp, nfs_client_ipaddr);
    1267   sprintf (tmp, "%s/NFS-SERVER-IPADDR", bkpinfo->tmpdir);
    1268   write_one_liner_data_file (tmp, nfs_server_ipaddr);
    1269   sprintf (tmp, "%s/NFS-SERVER-MOUNT", bkpinfo->tmpdir);
    1270   write_one_liner_data_file (tmp, bkpinfo->nfs_mount);
    1271   sprintf (tmp, "%s/NFS-SERVER-PATH", bkpinfo->tmpdir);
    1272   write_one_liner_data_file (tmp, bkpinfo->nfs_remote_dir);
    1273   log_it ("Finished storing NFS configuration");
     1243    sprintf(tmp, "cp -f %s /var/cache/mondo-archive", outfile);
     1244    run_program_and_log_output(tmp, FALSE);
     1245
     1246    sprintf(tmp, "%s/NFS-DEV", bkpinfo->tmpdir);
     1247    write_one_liner_data_file(tmp, nfs_dev);
     1248
     1249    sprintf(tmp, "%s/NFS-CLIENT-IPADDR", bkpinfo->tmpdir);
     1250    write_one_liner_data_file(tmp, nfs_client_ipaddr);
     1251    sprintf(tmp, "%s/NFS-SERVER-IPADDR", bkpinfo->tmpdir);
     1252    write_one_liner_data_file(tmp, nfs_server_ipaddr);
     1253    sprintf(tmp, "%s/NFS-SERVER-MOUNT", bkpinfo->tmpdir);
     1254    write_one_liner_data_file(tmp, bkpinfo->nfs_mount);
     1255    sprintf(tmp, "%s/NFS-SERVER-PATH", bkpinfo->tmpdir);
     1256    write_one_liner_data_file(tmp, bkpinfo->nfs_remote_dir);
     1257    log_it("Finished storing NFS configuration");
    12741258}
    12751259
     
    12961280 */
    12971281void
    1298 estimate_noof_media_required (struct s_bkpinfo *bkpinfo, long noof_sets)
    1299 {
    1300     /*@ buffers ****************/
    1301   char tmp[MAX_STR_LEN];
    1302 
    1303     /*@ long long **************/
    1304   long long scratchLL;
    1305 
    1306   if (bkpinfo->media_size[1]<=0 || bkpinfo->backup_media_type == nfs)
    1307     {
    1308       log_to_screen("Number of media required: UNKNOWN");
    1309       return;
    1310     }
    1311 
    1312   log_it ("Estimating number of media required...");
    1313   scratchLL = (long long)(noof_sets) * (long long)(bkpinfo->optimal_set_size)
    1314     + (long long)(size_of_all_biggiefiles_K (bkpinfo));
    1315   scratchLL = (scratchLL / 1024) / bkpinfo->media_size[1];
    1316   scratchLL++;
    1317   if (bkpinfo->use_lzo)
    1318     {
    1319       scratchLL = (scratchLL * 2) / 3;
    1320     }
    1321   else
    1322     {
    1323       scratchLL = scratchLL / 2;
    1324     }
    1325   if (!scratchLL)
    1326     {
    1327       scratchLL++;
    1328     }
    1329   if (scratchLL <= 1)
    1330     {
    1331       sprintf (tmp,
    1332            "Your backup will probably occupy a single CD/tape/ISO. Maybe two.");
    1333     }
    1334   else if (scratchLL > 4)
    1335     {
    1336       sprintf(tmp, "Your backup will occupy one meeeeellion media! (maybe %s)",
    1337            number_to_text ((int) (scratchLL + 1)));
    1338     }
    1339   else
    1340     {
    1341       sprintf (tmp, "Your backup will occupy approximately %s media.",
    1342            number_to_text ((int) (scratchLL + 1)));
    1343     }
    1344   if (!bkpinfo->image_devs[0] && (scratchLL<50))
    1345     {
    1346       log_to_screen (tmp);
    1347     }
     1282estimate_noof_media_required(struct s_bkpinfo *bkpinfo, long noof_sets)
     1283{
     1284    /*@ buffers *************** */
     1285    char tmp[MAX_STR_LEN];
     1286
     1287    /*@ long long ************* */
     1288    long long scratchLL;
     1289
     1290    if (bkpinfo->media_size[1] <= 0 || bkpinfo->backup_media_type == nfs) {
     1291        log_to_screen("Number of media required: UNKNOWN");
     1292        return;
     1293    }
     1294
     1295    log_it("Estimating number of media required...");
     1296    scratchLL =
     1297        (long long) (noof_sets) * (long long) (bkpinfo->optimal_set_size)
     1298        + (long long) (size_of_all_biggiefiles_K(bkpinfo));
     1299    scratchLL = (scratchLL / 1024) / bkpinfo->media_size[1];
     1300    scratchLL++;
     1301    if (bkpinfo->use_lzo) {
     1302        scratchLL = (scratchLL * 2) / 3;
     1303    } else {
     1304        scratchLL = scratchLL / 2;
     1305    }
     1306    if (!scratchLL) {
     1307        scratchLL++;
     1308    }
     1309    if (scratchLL <= 1) {
     1310        sprintf(tmp,
     1311                "Your backup will probably occupy a single CD/tape/ISO. Maybe two.");
     1312    } else if (scratchLL > 4) {
     1313        sprintf(tmp,
     1314                "Your backup will occupy one meeeeellion media! (maybe %s)",
     1315                number_to_text((int) (scratchLL + 1)));
     1316    } else {
     1317        sprintf(tmp, "Your backup will occupy approximately %s media.",
     1318                number_to_text((int) (scratchLL + 1)));
     1319    }
     1320    if (!bkpinfo->image_devs[0] && (scratchLL < 50)) {
     1321        log_to_screen(tmp);
     1322    }
    13481323}
    13491324
     
    13561331 * @note The returned string points to static storage that will be overwritten with each call.
    13571332 */
    1358 char*sz_last_suffix(char*instr)
    1359 {
    1360   static char outstr[MAX_STR_LEN];
    1361   char *p;
    1362 
    1363   p = strrchr(instr,'.');
    1364   if (!p)
    1365     {
    1366       outstr[0]='\0';
    1367     }
    1368   else
    1369     {
    1370       strcpy(outstr, p);
    1371     }
    1372   return(outstr);
     1333char *sz_last_suffix(char *instr)
     1334{
     1335    static char outstr[MAX_STR_LEN];
     1336    char *p;
     1337
     1338    p = strrchr(instr, '.');
     1339    if (!p) {
     1340        outstr[0] = '\0';
     1341    } else {
     1342        strcpy(outstr, p);
     1343    }
     1344    return (outstr);
    13731345}
    13741346
     
    13801352 * @return TRUE if it's compressed, FALSE if not.
    13811353 */
    1382 bool is_this_file_compressed(char*filename)
    1383 {
    1384   char do_not_compress_these[MAX_STR_LEN];
    1385   char tmp[MAX_STR_LEN];
    1386   char *p;
    1387 
    1388   sprintf(tmp, "%s/do-not-compress-these", g_mondo_home);
    1389   if (!does_file_exist(tmp)) { return(FALSE); }
    1390   strcpy(do_not_compress_these, last_line_of_file(tmp));
    1391   for(p=do_not_compress_these; p!=NULL; p++)
    1392     {
    1393       strcpy(tmp, p);
    1394       if (strchr(tmp, ' ')) { *(strchr(tmp, ' ')) ='\0'; }
    1395       if (!strcmp(sz_last_suffix(filename), tmp))
    1396     { /*printf("MATCH\n");*/ return(TRUE); }
    1397       if (!(p = strchr(p, ' '))) { break; }
    1398     }
    1399   return(FALSE);
    1400 }
    1401 
    1402 
    1403 
    1404 int mode_of_file(char*fname)
    1405 {
    1406   struct stat buf;
    1407 
    1408   if (lstat(fname, &buf))
    1409     { return(-1); } // error
    1410   else
    1411     { return(buf.st_mode); }
     1354bool is_this_file_compressed(char *filename)
     1355{
     1356    char do_not_compress_these[MAX_STR_LEN];
     1357    char tmp[MAX_STR_LEN];
     1358    char *p;
     1359
     1360    sprintf(tmp, "%s/do-not-compress-these", g_mondo_home);
     1361    if (!does_file_exist(tmp)) {
     1362        return (FALSE);
     1363    }
     1364    strcpy(do_not_compress_these, last_line_of_file(tmp));
     1365    for (p = do_not_compress_these; p != NULL; p++) {
     1366        strcpy(tmp, p);
     1367        if (strchr(tmp, ' ')) {
     1368            *(strchr(tmp, ' ')) = '\0';
     1369        }
     1370        if (!strcmp(sz_last_suffix(filename), tmp)) {   /*printf("MATCH\n"); */
     1371            return (TRUE);
     1372        }
     1373        if (!(p = strchr(p, ' '))) {
     1374            break;
     1375        }
     1376    }
     1377    return (FALSE);
     1378}
     1379
     1380
     1381
     1382int mode_of_file(char *fname)
     1383{
     1384    struct stat buf;
     1385
     1386    if (lstat(fname, &buf)) {
     1387        return (-1);
     1388    }                           // error
     1389    else {
     1390        return (buf.st_mode);
     1391    }
    14121392}
    14131393
     
    14201400 * @return 0 for success, 1 for failure.
    14211401 */
    1422 int make_grub_install_scriptlet(char*outfile)
    1423 {
    1424   FILE*fout;
    1425   char *tmp;
    1426   int retval=0;
    1427 
    1428   malloc_string(tmp);
    1429   if ((fout = fopen( outfile, "w")))
    1430     {
    1431       fprintf(fout, "#!/bin/sh\n\nmount /boot > /dev/null 2> /dev/null\ngrub-install $@\nres=$?\nsync;sync;sync\nexit $res\n");
    1432       paranoid_fclose(fout);
    1433       log_msg(2, "Created %s", outfile);
    1434       sprintf(tmp, "chmod +x %s", outfile);
    1435       paranoid_system(tmp);
    1436       retval=0;
    1437         }
    1438   else
    1439         {
    1440       retval=1;
    1441     }
    1442   paranoid_free(tmp);
    1443   return(retval);
     1402int make_grub_install_scriptlet(char *outfile)
     1403{
     1404    FILE *fout;
     1405    char *tmp;
     1406    int retval = 0;
     1407
     1408    malloc_string(tmp);
     1409    if ((fout = fopen(outfile, "w"))) {
     1410        fprintf(fout,
     1411                "#!/bin/sh\n\nmount /boot > /dev/null 2> /dev/null\ngrub-install $@\nres=$?\nsync;sync;sync\nexit $res\n");
     1412        paranoid_fclose(fout);
     1413        log_msg(2, "Created %s", outfile);
     1414        sprintf(tmp, "chmod +x %s", outfile);
     1415        paranoid_system(tmp);
     1416        retval = 0;
     1417    } else {
     1418        retval = 1;
     1419    }
     1420    paranoid_free(tmp);
     1421    return (retval);
    14441422}
    14451423
Note: See TracChangeset for help on using the changeset viewer.