Changeset 300 in MondoRescue for trunk/mondo/mondo

Timestamp:

Jan 11, 2006, 2:20:38 PM (18 years ago)

Author:

bcornec

Message:

merge -r295:299 $SVN_M/branches/2.06

Location:

trunk/mondo/mondo

Files:

• common/libmondo-archive-EXT.h (modified) (1 diff)
• common/libmondo-archive.c (modified) (12 diffs)
• common/libmondo-archive.h (modified) (1 diff)
• common/libmondo-files.c (modified) (4 diffs)
• common/libmondo-fork-EXT.h (modified) (1 diff)
• common/libmondo-fork.c (modified) (5 diffs)
• common/libmondo-fork.h (modified) (1 diff)
• common/libmondo-verify.c (modified) (1 diff)
• common/mondostructures.h (modified) (2 diffs)
• common/my-stuff.h (modified) (2 diffs)
• common/newt-specific.c (modified) (1 diff)
• mondoarchive/main.c (modified) (1 diff)
• mondoarchive/mondo-cli.c (modified) (1 diff)
• mondorestore/mondo-restore.c (modified) (20 diffs)

trunk/mondo/mondo/common/libmondo-archive-EXT.h

@@ -27 +27 @@
 extern int slice_up_file_etc(struct s_bkpinfo *bkpinfo,
                              char *biggie_filename,
-                             char *partimagehack_fifo,
+                             char *ntfsprog_fifo,
                              long biggie_file_number,
                              long noof_biggie_files,
-                             bool use_partimagehack);
+                             bool use_ntfsprog);
 extern int verify_data(struct s_bkpinfo *bkpinfo);
 extern void wipe_archives(char *d);

trunk/mondo/mondo/common/libmondo-archive.c

@@ -1968 +1968 @@
     char *bigfile_fname = NULL;
     char *sz_devfile;
-    char *partimagehack_fifo = NULL;
+    char *ntfsprog_fifo = NULL;
     /*@ long *********************************************** */
     long biggie_file_number = 0;
@@ -1981 +1981 @@
     FILE *ftmp = NULL;
     bool delete_when_done;
-    bool use_partimagehack;
+    bool use_ntfsprog;
     /*@ long long ****************************************** */
     long long biggie_fsize;
@@ -2015 +2015 @@
     for (getline(&bigfile_fname, &n, fin); !feof(fin);
          getline(&bigfile_fname, &n, fin), biggie_file_number++) {
-        use_partimagehack = FALSE;
+        use_ntfsprog = FALSE;
         if (bigfile_fname[strlen(bigfile_fname) - 1] < 32) {
             bigfile_fname[strlen(bigfile_fname) - 1] = '\0';
@@ -2029 +2029 @@
             delete_when_done = TRUE;
         } else {
-            // Call partimagehack if it's a /dev entry (i.e. a partition to be imaged)
+            // Call ntfsclone (formerly partimagehack) if it's a /dev entry (i.e. a partition to be imaged)
             log_msg(2, "bigfile_fname = %s", bigfile_fname);
-            use_partimagehack = FALSE;
+            use_ntfsprog = FALSE;
             if (!strncmp(bigfile_fname, "/dev/", 5)
                 && is_dev_an_NTFS_dev(bigfile_fname)) {
-                use_partimagehack = TRUE;
+                use_ntfsprog = TRUE;
                 log_msg(2,
-                        "Calling partimagehack in background because %s is an NTFS partition",
+                        "Calling ntfsclone in background because %s is an NTFS partition",
                         bigfile_fname);
                 asprintf(&sz_devfile, "/tmp/%d.%d.000",
@@ -2042 +2042 @@
                          (int) (random() % 32768));
                 mkfifo(sz_devfile, 0x770);
-                partimagehack_fifo = sz_devfile;
+                ntfsprog_fifo = sz_devfile;
                 switch (pid = fork()) {
                 case -1:
@@ -2048 +2048 @@
                 case 0:
                     log_msg(2,
-                            "CHILD - fip - calling feed_into_partimage(%s, %s)",
+                            "CHILD - fip - calling feed_into_ntfsprog(%s, %s)",
                             bigfile_fname, sz_devfile);
-                    res = feed_into_partimage(bigfile_fname, sz_devfile);
+                    res = feed_into_ntfsprog(bigfile_fname, sz_devfile);
                     exit(res);
                     break;
                 default:
                     log_msg(2,
-                            "feed_into_partimage() called in background --- pid=%ld",
+                            "feed_into_ntfsprog() called in background --- pid=%ld",
                             (long int) (pid));
 
@@ -2063 +2063 @@
             // Otherwise, use good old 'dd' and 'bzip2'
             else {
-                partimagehack_fifo = NULL;
+                ntfsprog_fifo = NULL;
             }
 
@@ -2072 +2072 @@
             if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
                 write_header_block_to_stream(biggie_fsize, bigfile_fname,
-                                             use_partimagehack ?
+                                             use_ntfsprog ?
                                              BLK_START_A_PIHBIGGIE :
                                              BLK_START_A_NORMBIGGIE);
             }
-            res = slice_up_file_etc(bkpinfo, bigfile_fname,
-                                    partimagehack_fifo, biggie_file_number,
-                                    noof_biggie_files, use_partimagehack);
+            res =
+                slice_up_file_etc(bkpinfo, bigfile_fname,
+                                  ntfsprog_fifo, biggie_file_number,
+                                  noof_biggie_files, use_ntfsprog);
             if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
                 tmp = calc_checksum_of_file(bigfile_fname);
@@ -2996 +2997 @@
  *
  * @param biggie_filename The file to chop up.
- * @param partimagehack_fifo The FIFO to partimagehack if this is an imagedev, NULL otherwise.
+ * @param ntfsprog_fifo The FIFO to ntfsclone if this is an imagedev, NULL otherwise.
  * @param biggie_file_number The sequence number of this biggie file (starting from 0).
  * @param noof_biggie_files The number of biggie files there are total.
@@ -3005 +3006 @@
 int
 slice_up_file_etc(struct s_bkpinfo *bkpinfo, char *biggie_filename,
-                  char *partimagehack_fifo, long biggie_file_number,
-                  long noof_biggie_files, bool use_partimagehack)
+                  char *ntfsprog_fifo, long biggie_file_number,
+                  long noof_biggie_files, bool use_ntfsprog)
 {
 
@@ -3049 +3050 @@
 
     biggiestruct.for_backward_compatibility = '\n';
-    biggiestruct.use_partimagehack = use_partimagehack;
+    biggiestruct.use_ntfsprog = use_ntfsprog;
     optimal_set_size = bkpinfo->optimal_set_size;
     if (is_this_file_compressed(biggie_filename)
@@ -3064 +3065 @@
         fatal_error("bkpinfo->optimal_set_size is insanely small");
     }
-    if (partimagehack_fifo) {
-        file_to_openin = partimagehack_fifo;
+    if (ntfsprog_fifo) {
+        file_to_openin = ntfsprog_fifo;
         asprintf(&checksum_line, "IGNORE");
         log_msg(2,
                 "Not calculating checksum for %s: it would take too long",
                 biggie_filename);
-        totallength = get_phys_size_of_drive(biggie_filename)*1024*1024LL;
+        if ( !find_home_of_exe("ntfsresize")) {
+            fatal_error("ntfsresize not found");
+        }
+        sprintf(command, "ntfsresize --force --info %s|grep '^You might resize at '|cut -d' ' -f5", biggie_filename);
+        log_it("command = %s", command);
+        strcpy (tmp, call_program_and_get_last_line_of_output(command));
+        log_it("res of it = %s", tmp); 
+        totallength = atoll(tmp);
     } else {
         file_to_openin = biggie_filename;

trunk/mondo/mondo/common/libmondo-archive.h

@@ -29 +29 @@
 void set_bit_N_of_array(char *array, int N, bool true_or_false);
 int slice_up_file_etc(struct s_bkpinfo *bkpinfo, char *biggie_filename,
-                      char *partimagehack_fifo,
+                      char *ntfsprog_fifo,
                       long biggie_file_number, long noof_biggie_files,
-                      bool use_partimagehack);
+                      bool use_ntfsprog);
 int verify_data(struct s_bkpinfo *bkpinfo);
 void wipe_archives(char *d);

trunk/mondo/mondo/common/libmondo-files.c

@@ -711 +711 @@
     char *biggielist;
     char *comment;
+    char *tmp;
+    char *command;
 
     /*@ long ******************************************************** */
@@ -722 +724 @@
     /*@ end vars *************************************************** */
 
+    malloc_string(tmp);
+    malloc_string(command);
     log_it("Calculating size of all biggiefiles (in total)");
     asprintf(&biggielist, "%s/biggielist.txt", bkpinfo->tmpdir);
@@ -736 +740 @@
             }
             if (0 == strncmp(fname, "/dev/", 5)) {
-                file_len_K = get_phys_size_of_drive(fname) * 1024L;
+                if (is_dev_an_NTFS_dev(fname)) {
+                    if ( !find_home_of_exe("ntfsresize")) {
+                        fatal_error("ntfsresize not found");
+                    }
+                    sprintf(command, "ntfsresize --force --info %s|grep '^You might resize at '|cut -d' ' -f5", fname);
+                    log_it("command = %s", command);
+                    strcpy (tmp, call_program_and_get_last_line_of_output(command));
+                    log_it("res of it = %s", tmp);
+                    file_len_K = atoll(tmp) / 1024L;
+                } else {
+                    file_len_K = get_phys_size_of_drive(fname) * 1024L;
+                }
             } else {
                 file_len_K = (long) (length_of_file(fname) / 1024);
@@ -761 +776 @@
     paranoid_fclose(fin);
     log_it("Finished calculating total size of all biggiefiles");
+    paranoid_free(tmp);
+    paranoid_free(command);
     return (scratchL);
 }

trunk/mondo/mondo/common/libmondo-fork-EXT.h

@@ -14 +14 @@
                                                              char *cmd);
 extern int copy_from_src_to_dest(FILE *, FILE *, char);
-extern int feed_into_partimage(char *input_device, char *output_fname);
-extern int feed_outfrom_partimage(char *output_device, char *input_fifo);
+extern int feed_into_ntfsprog(char *input_device, char *output_fname);
+extern int feed_outfrom_ntfsprog(char *output_device, char *input_fifo);

trunk/mondo/mondo/common/libmondo-fork.c

@@ -1 @@
-/* $Id$
-  subroutines for handling forking/pthreads/etc.
+/* libmondo-fork.c
+   $Id$
+
+- subroutines for handling forking/pthreads/etc.
+
+
+01/20/2006
+- replaced partimagehack with ntfsclone
+
+06/20/2004
+- create fifo /var/log/partimagehack-debug.log and empty it
+  to keep ramdisk from filling up
+
+04/13/2004
+- >= should be <= g_loglevel
+
+11/15/2003
+- changed a few []s to char*s
+  
+10/12
+- rewrote partimagehack handling (multiple fifos, chunks, etc.)
+
+10/11
+- partimagehack now has debug level of N (set in my-stuff.h)
+
+10/08
+- call to partimagehack when restoring will now log errors to /var/log/....log
+
+10/06
+- cleaned up logging a bit
+
+09/30
+- line 735 - missing char* cmd in sprintf()
+
+09/28
+- added run_external_binary_with_percentage_indicator()
+- rewritten eval_call_to_make_ISO()
+
+09/18
+- call mkstemp instead of mktemp
+
+09/13
+- major NTFS hackage
+
+09/12
+- paranoid_system("rm -f /tmp/ *PARTIMAGE*") before calling partimagehack
+
+09/11
+- forward-ported unbroken feed_*_partimage() subroutines
+  from early August 2003
+
+09/08
+- detect & use partimagehack if it exists
+
+09/05
+- finally finished partimagehack hack :)
+
+07/04
+- added subroutines to wrap around partimagehack
+
+04/27
+- don't echo (...res=%d...) at end of log_it()
+  unnecessarily
+- replace newtFinished() and newtInit() with
+  newtSuspend() and newtResume()
+
+04/24
+- added some assert()'s and log_OS_error()'s
+
+04/09
+- cleaned up run_program_and_log_output()
+
+04/07
+- cleaned up code a bit
+- let run_program_and_log_output() accept -1 (only log if _no error_)
+
+01/02/2003
+- in eval_call_to_make_ISO(), append output to MONDO_LOGFILE
+  instead of a temporary stderr text file
+
+12/10
+- patch by Heiko Schlittermann to handle % chars in issue.net
+
+11/18
+- if mkisofs in eval_call_to_make_ISO() returns an error then return it,
+  whether ISO was created or not
+
+10/30
+- if mkisofs in eval_call_to_make_ISO() returns an error then find out if
+  the output (ISO) file has been created; if it has then return 0 anyway
+
+08/01 - 09/30
+- run_program_and_log_output() now takes boolean operator to specify
+  whether it will log its activities in the event of _success_
+- system() now includes 2>/dev/null
+- enlarged some tmp[]'s
+- added run_program_and_log_to_screen() and run_program_and_log_output()
+
+07/24
+- created
 */
 
@@ -370 +468 @@
 
 /**
- * Thread callback to run a command (partimage) in the background.
- * @param xfb A transfer block of @c char, containing:
- * - xfb:[0] A marker, should be set to 2. Decremented to 1 while the command is running and 0 when it's finished.
- * - xfb:[1] The command's return value, if xfb:[0] is 0.
- * - xfb+2:  A <tt>NULL</tt>-terminated string containing the command to be run.
- * @return NULL to pthread_join.
- */
-void *call_partimage_in_bkgd(void *xfb)
-{
-    char *transfer_block;
-    int retval = 0;
-
-    g_buffer_pid = getpid();
-    unlink("/tmp/null");
-    log_msg(1, "starting");
-    transfer_block = (char *) xfb;
-    transfer_block[0]--;        // should now be 1
-    retval = system(transfer_block + 2);
-    if (retval) {
-        log_OS_error("partimage returned an error");
-    }
-    transfer_block[1] = retval;
-    transfer_block[0]--;        // should now be 0
-    g_buffer_pid = 0;
-    log_msg(1, "returning");
-    pthread_exit(NULL);
-}
-
-
-/**
- * File to touch if we want partimage to wait for us.
- */
-#define PAUSE_PARTIMAGE_FNAME "/tmp/PAUSE-PARTIMAGE-FOR-MONDO"
-
-/**
  * Apparently used. @bug This has a purpose, but what?
  */
@@ -410 +473 @@
 #define PIMP_END_SZ "ENDENDEND0xBBC10xBBC2T231hc81h42vws89ff3kff9a82gv34r7fghbka"
 
-/**
- * Marker to start the next subvolume for Partimage.
- */
-#define NEXT_SUBVOL_PLEASE "I-grew-up-on-the-crime-side,-the-New-York-Times-side,-where-staying-alive-was-no-jive"
-
-/**
- * Marker to end the partimage file.
- */
-#define NO_MORE_SUBVOLS "On-second-hand,momma-bounced-on-old-man,-and-so-we-moved-to-Shaolin-Land."
+
+
 
 int copy_from_src_to_dest(FILE * f_orig, FILE * f_archived, char direction)
@@ -559 +615 @@
 }
 
-
 /**
- * Call partimage from @p input_device to @p output_fname.
- * @param input_device The device to read.
- * @param output_fname The file to write.
- * @return 0 for success, nonzero for failure.
- */
-int dynamically_create_pipes_and_copy_from_them_to_output_file(char
-                                                               *input_device, char
-                                                               *output_fname)
-{
-    char *curr_fifo;
-    char *prev_fifo = NULL;
-    char *next_fifo;
-    char *command;
-    char *sz_call_to_partimage;
-    int fifo_number = 0;
-    struct stat buf;
-    pthread_t partimage_thread;
-    int res = 0;
-    char *tmpstub;
-    FILE *fout;
-    FILE *fin;
-    char *tmp;
-
-    log_msg(1, "g_tmpfs_mountpt = %s", g_tmpfs_mountpt);
-    if (g_tmpfs_mountpt && g_tmpfs_mountpt[0]
-        && does_file_exist(g_tmpfs_mountpt)) {
-        asprintf(&tmpstub, g_tmpfs_mountpt);
-    } else {
-        asprintf(&tmpstub, "/tmp");
-    }
-    paranoid_system("rm -f /tmp/*PARTIMAGE*");
-    asprintf(&command, "rm -Rf %s/pih-fifo-*", tmpstub);
-    paranoid_system(command);
-    paranoid_free(command);
-
-    asprintf(&tmp, "%s/pih-fifo-%ld", tmpstub, (long int) random());
-    paranoid_free(tmpstub);
-    tmpstub = tmp;
-    paranoid_free(tmp);
-
-    mkfifo(tmpstub, S_IRWXU | S_IRWXG); // never used, though...
-    asprintf(&curr_fifo, "%s.%03d", tmpstub, fifo_number);
-    asprintf(&next_fifo, "%s.%03d", tmpstub, fifo_number + 1);
-    mkfifo(curr_fifo, S_IRWXU | S_IRWXG);
-    mkfifo(next_fifo, S_IRWXU | S_IRWXG);   // make sure _next_ fifo already exists before we call partimage
-    asprintf(&sz_call_to_partimage,
-            "%c%cpartimagehack " PARTIMAGE_PARAMS
-            " save %s %s > /tmp/stdout 2> /tmp/stderr", 2, 0, input_device,
-            tmpstub);
-    log_msg(5, "curr_fifo   = %s", curr_fifo);
-    log_msg(5, "next_fifo   = %s", next_fifo);
-    log_msg(5, "sz_call_to_partimage call is '%s'",
-            sz_call_to_partimage + 2);
-    if (!lstat(output_fname, &buf) && S_ISREG(buf.st_mode)) {
-        log_msg(5, "Deleting %s", output_fname);
-        unlink(output_fname);
-    }
-    if (!(fout = fopen(output_fname, "w"))) {
-        fatal_error("Unable to openout to output_fname");
-    }
-    res =
-        pthread_create(&partimage_thread, NULL, call_partimage_in_bkgd,
-                       (void *) sz_call_to_partimage);
-    if (res) {
-        fatal_error("Failed to create thread to call partimage");
-    }
-    log_msg(1, "Running fore/back at same time");
-    log_to_screen("Working with partimagehack...");
-    while (sz_call_to_partimage[0] > 0) {
-        asprintf(&tmp, "%s\n", NEXT_SUBVOL_PLEASE);
-        if (fwrite(tmp, 1, 128, fout) != 128) {
-            fatal_error("Cannot write interim block");
-        }
-        paranoid_free(tmp);
-
-        log_msg(5, "fifo_number=%d", fifo_number);
-        log_msg(4, "Cat'ting %s", curr_fifo);
-        if (!(fin = fopen(curr_fifo, "r"))) {
-            fatal_error("Unable to openin from fifo");
-        }
-        if (prev_fifo !=  NULL) {
-            log_msg(5, "Deleting %s", prev_fifo);
-            unlink(prev_fifo);      // just in case
-            paranoid_free(prev_fifo);
-        }
-        copy_from_src_to_dest(fin, fout, 'w');
-        paranoid_fclose(fin);
-        fifo_number++;
-
-        prev_fifo = curr_fifo;
-        curr_fifo = next_fifo;
-        log_msg(5, "Creating %s", next_fifo);
-        asprintf(&next_fifo, "%s.%03d", tmpstub, fifo_number + 1);
-        mkfifo(next_fifo, S_IRWXU | S_IRWXG);   // make sure _next_ fifo exists before we cat this one
-        system("sync");
-        sleep(5);
-    }
-    asprintf(&tmp, "%s\n", NO_MORE_SUBVOLS);
-    if (fwrite(tmp, 1, 128, fout) != 128) {
-        fatal_error("Cannot write interim block");
-    }
-    if (fwrite(tmp, 1, 128, fout) != 128) {
-        fatal_error("Cannot write interim block");
-    }
-    if (fwrite(tmp, 1, 128, fout) != 128) {
-        fatal_error("Cannot write interim block");
-    }
-    if (fwrite(tmp, 1, 128, fout) != 128) {
-        fatal_error("Cannot write interim block");
-    }
-    paranoid_free(tmp);
-    paranoid_fclose(fout);
-    log_to_screen("Cleaning up after partimagehack...");
-    log_msg(3, "Final fifo_number=%d", fifo_number);
-    paranoid_system("sync");
-    unlink(next_fifo);
-    paranoid_free(next_fifo);
-
-    unlink(curr_fifo);
-    paranoid_free(curr_fifo);
-
-    unlink(prev_fifo);
-    paranoid_free(prev_fifo);
-
-    log_to_screen("Finished cleaning up.");
-
-//  if (!lstat(sz_wait_for_this_file, &statbuf))
-//    { log_msg(3, "WARNING! %s was not processed.", sz_wait_for_this_file); }
-    log_msg(2, "Waiting for pthread_join() to join.");
-    pthread_join(partimage_thread, NULL);
-    res = sz_call_to_partimage[1];
-    paranoid_free(sz_call_to_partimage);
-    log_msg(2, "pthread_join() joined OK.");
-    log_msg(1, "Partimagehack(save) returned %d", res);
-    unlink(tmpstub);
-    paranoid_free(tmpstub);
-
-    return (res);
-}
-
-
-/**
- * Feed @p input_device through partimage to @p output_fname.
+ * Feed @p input_device through ntfsclone to @p output_fname.
  * @param input_device The device to image.
  * @param output_fname The file to write.
  * @return 0 for success, nonzero for failure.
  */
-int feed_into_partimage(char *input_device, char *output_fname)
+int feed_into_ntfsprog(char *input_device, char *output_fname)
 {
 // BACKUP
-    int res;
+    int res = -1;
+    char*command;
 
     if (!does_file_exist(input_device)) {
         fatal_error("input device does not exist");
     }
-    if (!find_home_of_exe("partimagehack")) {
-        fatal_error("partimagehack not found");
-    }
-    res =
-        dynamically_create_pipes_and_copy_from_them_to_output_file
-        (input_device, output_fname);
+    if ( !find_home_of_exe("ntfsclone")) {
+        fatal_error("ntfsclone not found");
+    }
+    malloc_string(command);
+    sprintf(command, "ntfsclone --force --save-image --overwrite %s %s", output_fname, input_device);
+    res = run_program_and_log_output(command, 5);
+    paranoid_free(command);
     return (res);
 }
@@ -871 +786 @@
 }
 
-#define PIH_LOG "/var/log/partimage-debug.log"
 
 /**
- * Feed @p input_fifo through partimage (restore) to @p output_device.
- * @param input_fifo The partimage file to read.
+ * Feed @p input_fifo through ntfsclone (restore) to @p output_device.
+ * @param input_fifo The ntfsclone file to read.
  * @param output_device Where to put the output.
- * @return The return value of partimagehack (0 for success).
- * @bug Probably unnecessary, as the partimage is just a sparse file. We could use @c dd to restore it.
+ * @return The return value of ntfsclone (0 for success).
  */
-int feed_outfrom_partimage(char *output_device, char *input_fifo)
+int feed_outfrom_ntfsprog(char *output_device, char *input_fifo)
 {
 // RESTORE
-    char *tmp;
-    char *stuff;
-    char *sz_call_to_partimage;
-    pthread_t partimage_thread;
-    int res;
-    char *curr_fifo;
-    char *prev_fifo = NULL;
-    char *oldest_fifo = NULL;
-    char *next_fifo;
-    char *afternxt_fifo;
-    int fifo_number = 0;
-    char *tmpstub;
-    FILE *fin;
-    FILE *fout;
-
-    log_msg(1, "output_device=%s", output_device);
-    log_msg(1, "input_fifo=%s", input_fifo);
-    asprintf(&tmpstub, "/tmp");
-
-    log_msg(1, "tmpstub was %s", tmpstub);
-    asprintf(&stuff, tmpstub);
-    paranoid_free(tmpstub);
-
-    asprintf(&tmpstub, "%s/pih-fifo-%ld", stuff, (long int) random());
-    paranoid_free(stuff);
-
-    log_msg(1, "tmpstub is now %s", tmpstub);
-    unlink("/tmp/PARTIMAGEHACK-POSITION");
-    unlink(PAUSE_PARTIMAGE_FNAME);
-    paranoid_system("rm -f /tmp/*PARTIMAGE*");
-    asprintf(&curr_fifo, "%s.%03d", tmpstub, fifo_number);
-    asprintf(&next_fifo, "%s.%03d", tmpstub, fifo_number + 1);
-    asprintf(&afternxt_fifo, "%s.%03d", tmpstub, fifo_number + 2);
-    mkfifo(PIH_LOG, S_IRWXU | S_IRWXG);
-    mkfifo(curr_fifo, S_IRWXU | S_IRWXG);
-    mkfifo(next_fifo, S_IRWXU | S_IRWXG);   // make sure _next_ fifo already exists before we call partimage
-    mkfifo(afternxt_fifo, S_IRWXU | S_IRWXG);
-    system("cat " PIH_LOG " > /dev/null &");
-    log_msg(3, "curr_fifo   = %s", curr_fifo);
-    log_msg(3, "next_fifo   = %s", next_fifo);
-    if (!does_file_exist(input_fifo)) {
-        fatal_error("input fifo does not exist");
-    }
-    if (!(fin = fopen(input_fifo, "r"))) {
-        fatal_error("Unable to openin from input_fifo");
-    }
-    if (!find_home_of_exe("partimagehack")) {
-        fatal_error("partimagehack not found");
-    }
-    asprintf(&sz_call_to_partimage,
-            "%c%cpartimagehack " PARTIMAGE_PARAMS
-            " restore %s %s > /dev/null 2>> %s", 2, 0, output_device, curr_fifo,
-            MONDO_LOGFILE);
-    log_msg(1, "output_device = %s", output_device);
-    log_msg(1, "curr_fifo = %s", curr_fifo);
-    log_msg(1, "sz_call_to_partimage+2 = %s", sz_call_to_partimage + 2);
-    res =
-        pthread_create(&partimage_thread, NULL, call_partimage_in_bkgd,
-                       (void *) sz_call_to_partimage);
-    if (res) {
-        fatal_error("Failed to create thread to call partimage");
-    }
-    log_msg(1, "Running fore/back at same time");
-    log_msg(2, " Trying to openin %s", input_fifo);
-    if (!does_file_exist(input_fifo)) {
-        log_msg(2, "Warning - %s does not exist", input_fifo);
-    }
-    while (!does_file_exist("/tmp/PARTIMAGEHACK-POSITION")) {
-        log_msg(6, "Waiting for partimagehack (restore) to start");
-        sleep(1);
-    }
-
-    if (!(tmp = malloc(128))) {
-        fatal_error("Failed to malloc() tmp");
-    }
-    while (sz_call_to_partimage[0] > 0) {
-        if (fread(tmp, 1, 128, fin) != 128) {
-            fatal_error("Cannot read introductory block");
-        }
-        if (strstr(tmp, NEXT_SUBVOL_PLEASE)) {
-            log_msg(2, "Great. Next subvol coming up.");
-        } else if (strstr(tmp, NO_MORE_SUBVOLS)) {
-            log_msg(2, "Great. That was the last subvol.");
-            break;
-        } else {
-            log_msg(2, "WTF is this? '%s'", tmp);
-            fatal_error("Unknown interim block");
-        }
-        if (feof(fin)) {
-            log_msg(1, "Eof(fin) detected. Breaking.");
-            break;
-        }
-        log_msg(3, "Processing subvol %d", fifo_number);
-        log_msg(5, "fifo_number=%d", fifo_number);
-        if (!(fout = fopen(curr_fifo, "w"))) {
-            fatal_error("Cannot openout to curr_fifo");
-        }
-        copy_from_src_to_dest(fout, fin, 'r');
-        paranoid_fclose(fout);
-        fifo_number++;
-        if (oldest_fifo != NULL) {
-            log_msg(6, "Deleting %s", oldest_fifo);
-            unlink(oldest_fifo);    // just in case
-            paranoid_free(oldest_fifo);
-        }
-        oldest_fifo = prev_fifo;
-        prev_fifo = curr_fifo;
-        curr_fifo = next_fifo;
-        next_fifo = afternxt_fifo;
-        asprintf(&afternxt_fifo, "%s.%03d", tmpstub, fifo_number + 2);
-        log_msg(6, "Creating %s", afternxt_fifo);
-        mkfifo(afternxt_fifo, S_IRWXU | S_IRWXG);   // make sure _next_ fifo already exists before we access current fifo
-        fflush(fin);
-//      system("sync");
-        usleep(1000L * 100L);
-    }
-    paranoid_free(tmp);
-    paranoid_free(tmpstub);
-
-    paranoid_fclose(fin);
-    paranoid_system("sync");
-    log_msg(1, "Partimagehack has finished. Great. Fin-closing.");
-    log_msg(1, "Waiting for pthread_join");
-    pthread_join(partimage_thread, NULL);
-    res = sz_call_to_partimage[1];
-    paranoid_free(sz_call_to_partimage);
-
-    log_msg(1, "Yay. Partimagehack (restore) returned %d", res);
-    unlink(prev_fifo);
-    paranoid_free(prev_fifo);
-
-    unlink(curr_fifo);
-    paranoid_free(curr_fifo);
-
-    unlink(next_fifo);
-    paranoid_free(next_fifo);
-
-    unlink(afternxt_fifo);
-    paranoid_free(afternxt_fifo);
-
-    unlink(PIH_LOG);
-    /* BERLIOS : pas de unlink(oldest_fifo) ??? */
-    paranoid_free(oldest_fifo);
-
+    int res = -1;
+    char *command;
+
+    if ( !find_home_of_exe("ntfsclone")) {
+        fatal_error("ntfsclone not found");
+    }
+    asprintf(&command, "ntfsclone --force --restore-image --overwrite %s %s", output_device, input_fifo);
+    res = run_program_and_log_output(command, 5);
+    paranoid_free(command);
     return (res);
 }

trunk/mondo/mondo/common/libmondo-fork.h

@@ -15 +15 @@
 int run_external_binary_with_percentage_indicator_NEW(char *tt, char *cmd);
 int copy_from_src_to_dest(FILE *, FILE *, char);
-int feed_into_partimage(char *input_device, char *output_fname);
-int feed_outfrom_partimage(char *output_device, char *input_fifo);
+int feed_into_ntfsprog(char *input_device, char *output_fname);
+int feed_outfrom_ntfsprog(char *output_device, char *input_fifo);

trunk/mondo/mondo/common/libmondo-verify.c

@@ -339 +339 @@
                 if (res && !strncmp(biggiestruct.filename, " /dev/", 5)) {
                     log_msg(3,
-                            "Ignoring differences between %s and live filesystem because it's a device and therefore the archives are stored via partimagehack, not dd.",
+                            "Ignoring differences between %s and live filesystem because it's a device and therefore the archives are stored via ntfsclone, not dd.",
                             biggiestruct.filename);
                     log_msg(3,

trunk/mondo/mondo/common/mondostructures.h

@@ -342 +342 @@
    *
    * This is useful for backing up NTFS partitions.
-   * @c partimage is used to back up only the used sectors, so the space tradeoff is not bad.
+   * @c ntfsclone is used to back up only the used sectors, so the space tradeoff is not bad.
    * However, several caveats apply to such a partition:
    * - It must not be mounted during the backup
-   * - It must be in a format that partimage knows how to handle
+   * - It must be in a format that ntfsclone knows how to handle, i.e. NTFS
    * - It cannot be verified during the verify or compare phase
    * - It may not be resized or selectively restored at restore-time (all or nothing)
@@ -661 +661 @@
      */
     struct stat properties;
-    bool use_partimagehack;
+    bool use_ntfsprog;
 };
 

trunk/mondo/mondo/common/my-stuff.h

@@ -151 +151 @@
 #define BLK_STOP_BIGGIEFILES    39  ///< Marker block: stop the biggiefile section.
 #define BLK_START_A_NORMBIGGIE  40  ///< Marker block: start a normal biggiefile.
-#define BLK_START_A_PIHBIGGIE   41  ///< Marker block: start a partimagehack'd biggiefile
+#define BLK_START_A_PIHBIGGIE   41  ///< Marker block: start a ntfsprog'd biggiefile
 #define BLK_START_EXTENDED_ATTRIBUTES 45    ///< Marker block: start xattr/acl info
 #define BLK_STOP_EXTENDED_ATTRIBUTES 46 ///< Marker block: stop xattr/acl info
@@ -389 +389 @@
 #define DEFAULT_DEBUG_LEVEL 4   ///< By default, don't log messages with a loglevel higher than this.
 
-#define SZ_PARTIMAGE_VOLSIZE "1048576"  // was 4096
-#define PARTIMAGE_PARAMS "-z0 -V" SZ_PARTIMAGE_VOLSIZE " -o -b -d -g1"
+#define SZ_NTFSPROG_VOLSIZE "1048576"   // was 4096
+#define NTFSPROG_PARAMS "-z0 -V" SZ_NTFSPROG_VOLSIZE " -o -b -d -g1"
 
 #define MNT_CDROM "/mnt/cdrom"

trunk/mondo/mondo/common/newt-specific.c

@@ -281 +281 @@
         kill_anything_like_this("/mondo/do-not");
         kill_anything_like_this("tmp.mondo");
-        kill_anything_like_this("partimagehack");
+        kill_anything_like_this("ntfsclone");
         sync();
         asprintf(&tmp, "umount %s", g_tmpfs_mountpt);

trunk/mondo/mondo/mondoarchive/main.c

@@ -157 +157 @@
 
     diffs = 0;
-    unlink("/var/log/partimagehack-debug.log");
     printf("Initializing...\n");
     if (!(bkpinfo = malloc(sizeof(struct s_bkpinfo)))) {

trunk/mondo/mondo/mondoarchive/mondo-cli.c

@@ -572 +572 @@
         asprintf(&tmp, flag_val['x']);
         bkpinfo->image_devs = tmp;
-        if (run_program_and_log_output("which partimagehack", 2)) {
-            fatal_error("Please install partimagehack RPM/tarball.");
+        if (run_program_and_log_output("which ntfsclone", 2)) {
+            fatal_error("Please install ntfsprogs package/tarball.");
         }
     }

trunk/mondo/mondo/mondorestore/mondo-restore.c

@@ -1368 +1368 @@
   /** malloc ***/
     char *checksum, *outfile_fname, *tmp, *bzip2_command,
-        *partimagehack_command, *suffix, *sz_devfile;
+        *ntfsprog_command, *suffix, *sz_devfile;
     char *bigblk;
     char *p;
@@ -1375 +1375 @@
     long sliceno;
     long siz;
-    char partimagehack_fifo[MAX_STR_LEN];
+    char ntfsprog_fifo[MAX_STR_LEN];
     char *file_to_openout = NULL;
     struct s_filename_and_lstat_info biggiestruct;
     struct utimbuf the_utime_buf, *ubuf;
-    bool use_partimage_hack = FALSE;
+    bool use_ntfsprog_hack = FALSE;
     pid_t pid;
     int res = 0;
@@ -1394 +1394 @@
     malloc_string(tmp);
     malloc_string(bzip2_command);
-    malloc_string(partimagehack_command);
+    malloc_string(ntfsprog_command);
     malloc_string(suffix);
     malloc_string(sz_devfile);
@@ -1451 +1451 @@
 
     log_msg(1, "DEFINITELY restoring %s", biggiestruct.filename);
-    if (biggiestruct.use_partimagehack) {
+    if (biggiestruct.use_ntfsprog) {
         if (strncmp(biggiestruct.filename, "/dev/", 5)) {
             log_msg(1,
-                    "I was in error when I set biggiestruct.use_partimagehack to TRUE.");
+                    "I was in error when I set biggiestruct.use_ntfsprog to TRUE.");
             log_msg(1, "%s isn't even in /dev", biggiestruct.filename);
-            biggiestruct.use_partimagehack = FALSE;
-        }
-    }
-
-    if (biggiestruct.use_partimagehack) // if it's an NTFS device
+            biggiestruct.use_ntfsprog = FALSE;
+        }
+    }
+
+    if (biggiestruct.use_ntfsprog)  // if it's an NTFS device
 //  if (!strncmp ( biggiestruct.filename, "/dev/", 5))
     {
         g_loglevel = 4;
-        use_partimage_hack = TRUE;
+        use_ntfsprog_hack = TRUE;
         log_msg(2,
-                "Calling partimagehack in background because %s is an NTFS /dev entry",
+                "Calling ntfsclone in background because %s is an NTFS /dev entry",
                 outfile_fname);
         sprintf(sz_devfile, "/tmp/%d.%d.000", (int) (random() % 32768),
                 (int) (random() % 32768));
         mkfifo(sz_devfile, 0x770);
-        strcpy(partimagehack_fifo, sz_devfile);
-        file_to_openout = partimagehack_fifo;
+        strcpy(ntfsprog_fifo, sz_devfile);
+        file_to_openout = ntfsprog_fifo;
         switch (pid = fork()) {
         case -1:
@@ -1478 +1478 @@
         case 0:
             log_msg(3,
-                    "CHILD - fip - calling feed_outfrom_partimage(%s, %s)",
-                    biggiestruct.filename, partimagehack_fifo);
+                    "CHILD - fip - calling feed_outfrom_ntfsprog(%s, %s)",
+                    biggiestruct.filename, ntfsprog_fifo);
             res =
-                feed_outfrom_partimage(biggiestruct.filename,
-                                       partimagehack_fifo);
+                feed_outfrom_ntfsprog(biggiestruct.filename,
+                                       ntfsprog_fifo);
 //          log_msg(3, "CHILD - fip - exiting");
             exit(res);
@@ -1488 +1488 @@
         default:
             log_msg(3,
-                    "feed_into_partimage() called in background --- pid=%ld",
+                    "feed_into_ntfsprog() called in background --- pid=%ld",
                     (long int) (pid));
         }
     } else {
-        use_partimage_hack = FALSE;
-        partimagehack_fifo[0] = '\0';
+        use_ntfsprog_hack = FALSE;
+        ntfsprog_fifo[0] = '\0';
         file_to_openout = outfile_fname;
         if (!does_file_exist(outfile_fname))    // yes, it looks weird with the '!' but it's correct that way
@@ -1520 +1520 @@
         return (1);
     }
-    log_msg(3, "Opened out to %s", outfile_fname);  // CD/DVD --> mondorestore --> partimagehack --> hard disk itself
+    log_msg(3, "Opened out to %s", outfile_fname);  // CD/DVD --> mondorestore --> ntfsclone --> hard disk itself
 
     for (sliceno = 1, finished = FALSE; !finished;) {
@@ -1629 +1629 @@
     g_loglevel = old_loglevel;
 
-    if (use_partimage_hack) {
-        log_msg(3, "Waiting for partimage to finish");
+    if (use_ntfsprog_hack) {
+        log_msg(3, "Waiting for ntfsclone to finish");
         sprintf(tmp,
-                " ps ax | grep \" partimagehack \" | grep -v grep > /dev/null 2> /dev/null");
+                " ps ax | grep \" ntfsclone \" | grep -v grep > /dev/null 2> /dev/null");
         while (system(tmp) == 0) {
             sleep(1);
         }
-        log_it("OK, partimage has really finished");
+        log_it("OK, ntfsclone has really finished");
     }
 
@@ -1652 +1652 @@
     paranoid_free(tmp);
     paranoid_free(bzip2_command);
-    paranoid_free(partimagehack_command);
+    paranoid_free(ntfsprog_command);
     paranoid_free(suffix);
     paranoid_free(sz_devfile);
@@ -1682 +1682 @@
                                      long long biggiefile_size, //UNUSED
                                      struct s_node *filelist,
-                                     int use_partimagehack,
+                                     int use_ntfsprog,
                                      char *pathname_of_last_file_restored)
 {
@@ -1692 +1692 @@
     char *command;
     char *outfile_fname;
-    char *partimagehack_command;
+    char *ntfsprog_command;
     char *sz_devfile;
-    char *partimagehack_fifo;
+    char *ntfsprog_fifo;
     char *file_to_openout = NULL;
 
@@ -1706 +1706 @@
     long long slice_siz;
     bool dummy_restore = FALSE;
-    bool use_partimage_hack = FALSE;
+    bool use_ntfsprog_hack = FALSE;
     pid_t pid;
     struct s_filename_and_lstat_info biggiestruct;
@@ -1713 +1713 @@
 
     malloc_string(tmp);
-    malloc_string(partimagehack_fifo);
+    malloc_string(ntfsprog_fifo);
     malloc_string(outfile_fname);
     malloc_string(command);
     malloc_string(sz_devfile);
-    malloc_string(partimagehack_command);
+    malloc_string(ntfsprog_command);
     old_loglevel = g_loglevel;
     assert(bkpinfo != NULL);
@@ -1724 +1724 @@
 
     pathname_of_last_file_restored[0] = '\0';
-    if (use_partimagehack == BLK_START_A_PIHBIGGIE) {
-        use_partimagehack = 1;
+    if (use_ntfsprog == BLK_START_A_PIHBIGGIE) {
+        use_ntfsprog = 1;
         log_msg(1, "%s --- pih=YES", orig_bf_fname);
-    } else if (use_partimagehack == BLK_START_A_NORMBIGGIE) {
-        use_partimagehack = 0;
+    } else if (use_ntfsprog == BLK_START_A_NORMBIGGIE) {
+        use_ntfsprog = 0;
         log_msg(1, "%s --- pih=NO", orig_bf_fname);
     } else {
-        use_partimagehack = 0;
+        use_ntfsprog = 0;
         log_msg(1, "%s --- pih=NO (weird marker though)", orig_bf_fname);
     }
@@ -1757 +1757 @@
     }
 
-    if (use_partimagehack) {
+    if (use_ntfsprog) {
         if (strncmp(orig_bf_fname, "/dev/", 5)) {
             log_msg(1,
-                    "I was in error when I set use_partimagehack to TRUE.");
+                    "I was in error when I set use_ntfsprog to TRUE.");
             log_msg(1, "%s isn't even in /dev", orig_bf_fname);
-            use_partimagehack = FALSE;
-        }
-    }
-
-    if (use_partimagehack) {
+            use_ntfsprog = FALSE;
+        }
+    }
+
+    if (use_ntfsprog) {
         g_loglevel = 4;
         strcpy(outfile_fname, orig_bf_fname);
-        use_partimage_hack = TRUE;
+        use_ntfsprog_hack = TRUE;
         log_msg(2,
-                "Calling partimagehack in background because %s is a /dev entry",
+                "Calling ntfsclone in background because %s is a /dev entry",
                 outfile_fname);
         sprintf(sz_devfile, "/tmp/%d.%d.000", (int) (random() % 32768),
                 (int) (random() % 32768));
         mkfifo(sz_devfile, 0x770);
-        strcpy(partimagehack_fifo, sz_devfile);
-        file_to_openout = partimagehack_fifo;
+        strcpy(ntfsprog_fifo, sz_devfile);
+        file_to_openout = ntfsprog_fifo;
         switch (pid = fork()) {
         case -1:
@@ -1783 +1783 @@
         case 0:
             log_msg(3,
-                    "CHILD - fip - calling feed_outfrom_partimage(%s, %s)",
-                    outfile_fname, partimagehack_fifo);
+                    "CHILD - fip - calling feed_outfrom_ntfsprog(%s, %s)",
+                    outfile_fname, ntfsprog_fifo);
             res =
-                feed_outfrom_partimage(outfile_fname, partimagehack_fifo);
+                feed_outfrom_ntfsprog(outfile_fname, ntfsprog_fifo);
 //          log_msg(3, "CHILD - fip - exiting");
             exit(res);
@@ -1792 +1792 @@
         default:
             log_msg(3,
-                    "feed_into_partimage() called in background --- pid=%ld",
+                    "feed_into_ntfsprog() called in background --- pid=%ld",
                     (long int) (pid));
         }
@@ -1804 +1804 @@
                     orig_bf_fname);
         }
-        use_partimage_hack = FALSE;
-        partimagehack_fifo[0] = '\0';
+        use_ntfsprog_hack = FALSE;
+        ntfsprog_fifo[0] = '\0';
         file_to_openout = outfile_fname;
         if (!does_file_exist(outfile_fname))    // yes, it looks weird with the '!' but it's correct that way
@@ -1882 +1882 @@
             pathname_of_last_file_restored);
 
-    if (use_partimage_hack) {
-        log_msg(3, "Waiting for partimage to finish");
+    if (use_ntfsprog_hack) {
+        log_msg(3, "Waiting for ntfsclone to finish");
         sprintf(tmp,
-                " ps ax | grep \" partimagehack \" | grep -v grep > /dev/null 2> /dev/null");
+                " ps ax | grep \" ntfsclone \" | grep -v grep > /dev/null 2> /dev/null");
         while (system(tmp) == 0) {
             sleep(1);
         }
-        log_msg(3, "OK, partimage has really finished");
+        log_msg(3, "OK, ntfsclone has really finished");
     }
 
@@ -1906 +1906 @@
     paranoid_free(outfile_fname);
     paranoid_free(command);
-    paranoid_free(partimagehack_command);
+    paranoid_free(ntfsprog_command);
     paranoid_free(sz_devfile);
-    paranoid_free(partimagehack_fifo);
+    paranoid_free(ntfsprog_fifo);
     g_loglevel = old_loglevel;
     return (retval);