Changeset 296 in MondoRescue

Timestamp:

Jan 11, 2006, 10:10:31 AM (19 years ago)

Author:

andree

Message:

Replaced partimagehack with ntfsclone from ntfsprogs package. Replaced
all occurrences of strings 'partimagehack' and 'partimage' with 'ntfsprog'.

Location:

branches/2.06/mondo

Files:

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

branches/2.06/mondo/ChangeLog

@@ -12 +12 @@
 - Abort|Warn when one of the include|exclude dirs (-I|-E) does not exist 
   (Bruno Cornec/Jeffs)
+- Replaced partimagehack with ntfsclone from ntfsprogs package.
+  (Andree Leidenfrost)
 
 v2.06 (2005-12-23)

branches/2.06/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);

branches/2.06/mondo/mondo/common/libmondo-archive.c

@@ -2162 +2162 @@
     char *bigfile_fname;
     char *sz_devfile;
-    char *partimagehack_fifo = NULL;
+    char *ntfsprog_fifo = NULL;
     /*@ long *********************************************** */
     long biggie_file_number = 0;
@@ -2174 +2174 @@
     FILE *ftmp = NULL;
     bool delete_when_done;
-    bool use_partimagehack;
+    bool use_ntfsprog;
     /*@ long long ****************************************** */
     long long biggie_fsize;
@@ -2209 +2209 @@
     for (fgets(bigfile_fname, MAX_STR_LEN, fin); !feof(fin);
          fgets(bigfile_fname, MAX_STR_LEN, 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';
@@ -2223 +2223 @@
             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);
                 sprintf(sz_devfile, "/tmp/%d.%d.000",
@@ -2236 +2236 @@
                         (int) (random() % 32768));
                 mkfifo(sz_devfile, 0x770);
-                partimagehack_fifo = sz_devfile;
+                ntfsprog_fifo = sz_devfile;
                 switch (pid = fork()) {
                 case -1:
@@ -2242 +2242 @@
                 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));
                 }
@@ -2256 +2256 @@
             else {
                 sz_devfile[0] = '\0';
-                partimagehack_fifo = NULL;
+                ntfsprog_fifo = NULL;
             }
 
@@ -2265 +2265 @@
             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);
@@ -2271 +2271 @@
             res =
                 slice_up_file_etc(bkpinfo, bigfile_fname,
-                                  partimagehack_fifo, biggie_file_number,
-                                  noof_biggie_files, use_partimagehack);
+                                  ntfsprog_fifo, biggie_file_number,
+                                  noof_biggie_files, use_ntfsprog);
             if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
                 write_header_block_to_stream(0,
@@ -3270 +3270 @@
  *
  * @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.
@@ -3279 +3279 @@
 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)
 {
 
@@ -3329 +3329 @@
 
     biggiestruct.for_backward_compatibility = '\n';
-    biggiestruct.use_partimagehack = use_partimagehack;
+    biggiestruct.use_ntfsprog = use_ntfsprog;
     if (!(tempblock = (char *) malloc(256 * 1024))) {
         fatal_error("malloc error 256*1024");
@@ -3347 +3347 @@
         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;
         strcpy(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;

branches/2.06/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);

branches/2.06/mondo/mondo/common/libmondo-files.c

@@ -865 +865 @@
     char *biggielist;
     char *comment;
+    char *tmp;
+    char *command;
 
     /*@ long ******************************************************** */
@@ -878 +880 @@
     malloc_string(biggielist);
     malloc_string(comment);
+    malloc_string(tmp);
+    malloc_string(command);
     log_it("Calculating size of all biggiefiles (in total)");
     sprintf(biggielist, "%s/biggielist.txt", bkpinfo->tmpdir);
@@ -892 +896 @@
             }
             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);
@@ -915 +930 @@
     paranoid_free(biggielist);
     paranoid_free(comment);
+    paranoid_free(tmp);
+    paranoid_free(command);
     return (scratchL);
 }

branches/2.06/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);

branches/2.06/mondo/mondo/common/libmondo-fork.c

@@ -4 +4 @@
 - subroutines for handling forking/pthreads/etc.
 
+
+01/20/2006
+- replaced partimagehack with ntfsclone
 
 06/20/2004
@@ -493 +496 @@
 
 
-
-/**
- * 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 unused. @bug This has a purpose, but what?
@@ -535 +502 @@
 #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)
@@ -674 +634 @@
 
 
+
+
 /**
- * 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;
-    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;
-
-    malloc_string(tmpstub);
-    malloc_string(curr_fifo);
-    malloc_string(prev_fifo);
-    malloc_string(next_fifo);
-    malloc_string(command);
-    malloc_string(sz_call_to_partimage);
-    malloc_string(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)) {
-        strcpy(tmpstub, g_tmpfs_mountpt);
-    } else {
-        strcpy(tmpstub, "/tmp");
-    }
-    paranoid_system("rm -f /tmp/*PARTIMAGE*");
-    sprintf(command, "rm -Rf %s/pih-fifo-*", tmpstub);
-    paranoid_system(command);
-    sprintf(tmpstub + strlen(tmpstub), "/pih-fifo-%ld",
-            (long int) random());
-    mkfifo(tmpstub, S_IRWXU | S_IRWXG); // never used, though...
-    sprintf(curr_fifo, "%s.%03d", tmpstub, fifo_number);
-    sprintf(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
-    sz_call_to_partimage[0] = 2;
-    sz_call_to_partimage[1] = 0;
-    sprintf(sz_call_to_partimage + 2,
-            "partimagehack " PARTIMAGE_PARAMS
-            " save %s %s > /tmp/stdout 2> /tmp/stderr", 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) {
-        sprintf(tmp, "%s\n", NEXT_SUBVOL_PLEASE);
-        if (fwrite(tmp, 1, 128, fout) != 128) {
-            fatal_error("Cannot write interim block");
-        }
-        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 (!sz_call_to_partimage[0]) { break; }
-        log_msg(5, "Deleting %s", prev_fifo);
-        unlink(prev_fifo);      // just in case
-        copy_from_src_to_dest(fin, fout, 'w');
-        paranoid_fclose(fin);
-        fifo_number++;
-        strcpy(prev_fifo, curr_fifo);
-        strcpy(curr_fifo, next_fifo);
-        log_msg(5, "Creating %s", next_fifo);
-        sprintf(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);
-    }
-    sprintf(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_fclose(fout);
-    log_to_screen("Cleaning up after partimagehack...");
-    log_msg(3, "Final fifo_number=%d", fifo_number);
-    paranoid_system("sync");
-    unlink(next_fifo);
-    unlink(curr_fifo);
-    unlink(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];
-    log_msg(2, "pthread_join() joined OK.");
-    log_msg(1, "Partimagehack(save) returned %d", res);
-    unlink(tmpstub);
-    paranoid_free(curr_fifo);
-    paranoid_free(prev_fifo);
-    paranoid_free(next_fifo);
-    paranoid_free(tmpstub);
-    paranoid_free(tmp);
-    paranoid_free(command);
-    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);
 }
@@ -1000 +825 @@
 
 
-#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 *command;
-    char *stuff;
-    char *sz_call_to_partimage;
-    pthread_t partimage_thread;
-    int res;
-    char *curr_fifo;
-    char *prev_fifo;
-    char *oldest_fifo;
-    char *next_fifo;
-    char *afternxt_fifo;
-    int fifo_number = 0;
-    char *tmpstub;
-    FILE *fin;
-    FILE *fout;
-
-    malloc_string(curr_fifo);
-    malloc_string(prev_fifo);
-    malloc_string(next_fifo);
-    malloc_string(afternxt_fifo);
-    malloc_string(oldest_fifo);
-    malloc_string(tmp);
-    sz_call_to_partimage = malloc(1000);
-    malloc_string(stuff);
-    malloc_string(tmpstub);
-
-    log_msg(1, "output_device=%s", output_device);
-    log_msg(1, "input_fifo=%s", input_fifo);
-/* I don't trust g_tmpfs_mountpt
-  if (g_tmpfs_mountpt[0])
-    {
-      strcpy(tmpstub, g_tmpfs_mountpt);
-    }
-  else
-    {
-*/
-    strcpy(tmpstub, "/tmp");
-//    }
-    log_msg(1, "tmpstub was %s", tmpstub);
-    strcpy(stuff, tmpstub);
-    sprintf(tmpstub, "%s/pih-fifo-%ld", stuff, (long int) random());
-    log_msg(1, "tmpstub is now %s", tmpstub);
-    unlink("/tmp/PARTIMAGEHACK-POSITION");
-    unlink(PAUSE_PARTIMAGE_FNAME);
-    paranoid_system("rm -f /tmp/*PARTIMAGE*");
-    sprintf(curr_fifo, "%s.%03d", tmpstub, fifo_number);
-    sprintf(next_fifo, "%s.%03d", tmpstub, fifo_number + 1);
-    sprintf(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");
-    }
-    sz_call_to_partimage[0] = 2;
-    sz_call_to_partimage[1] = 0;
-    sprintf(sz_call_to_partimage + 2,
-            "partimagehack " PARTIMAGE_PARAMS
-            " restore %s %s > /dev/null 2>> %s", 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);
-    }
-    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");
-        }
-        log_msg(6, "Deleting %s", oldest_fifo);
-        copy_from_src_to_dest(fout, fin, 'r');
-        paranoid_fclose(fout);
-        fifo_number++;
-        unlink(oldest_fifo);    // just in case
-        strcpy(oldest_fifo, prev_fifo);
-        strcpy(prev_fifo, curr_fifo);
-        strcpy(curr_fifo, next_fifo);
-        strcpy(next_fifo, afternxt_fifo);
-        sprintf(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_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];
-    log_msg(1, "Yay. Partimagehack (restore) returned %d", res);
-    unlink(prev_fifo);
-    unlink(curr_fifo);
-    unlink(next_fifo);
-    unlink(afternxt_fifo);
-    unlink(PIH_LOG);
-    paranoid_free(tmp);
-    paranoid_free(sz_call_to_partimage);
-    paranoid_free(stuff);
-    paranoid_free(prev_fifo);
-    paranoid_free(curr_fifo);
-    paranoid_free(next_fifo);
-    paranoid_free(afternxt_fifo);
-    paranoid_free(oldest_fifo);
-    paranoid_free(tmpstub);
+    int res = -1;
+    char *command;
+
+    if ( !find_home_of_exe("ntfsclone")) {
+        fatal_error("ntfsclone not found");
+    }
+    malloc_string(command);
+    sprintf(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);
 }

branches/2.06/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);

branches/2.06/mondo/mondo/common/libmondo-verify.c

@@ -433 +433 @@
                 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,

branches/2.06/mondo/mondo/common/mondostructures.h

@@ -359 +359 @@
    *
    * 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)
@@ -678 +678 @@
      */
     struct stat properties;
-    bool use_partimagehack;
+    bool use_ntfsprog;
 };
 

branches/2.06/mondo/mondo/common/my-stuff.h

@@ -277 +277 @@
 #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
@@ -518 +518 @@
 #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"

branches/2.06/mondo/mondo/common/newt-specific.c

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

branches/2.06/mondo/mondo/mondoarchive/main.c

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

branches/2.06/mondo/mondo/mondoarchive/mondo-cli.c

@@ -711 +711 @@
     if (flag_set['x']) {
         strncpy(bkpinfo->image_devs, flag_val['x'], MAX_STR_LEN / 4);
-        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.");
         }
     }

branches/2.06/mondo/mondo/mondorestore/mondo-restore.c

@@ -1365 +1365 @@
   /** malloc ***/
     char *checksum, *outfile_fname, *tmp, *bzip2_command,
-        *partimagehack_command, *suffix, *sz_devfile;
+        *ntfsprog_command, *suffix, *sz_devfile;
     char *bigblk;
     char *p;
@@ -1372 +1372 @@
     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;
@@ -1391 +1391 @@
     malloc_string(tmp);
     malloc_string(bzip2_command);
-    malloc_string(partimagehack_command);
+    malloc_string(ntfsprog_command);
     malloc_string(suffix);
     malloc_string(sz_devfile);
@@ -1448 +1448 @@
 
     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:
@@ -1475 +1475 @@
         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);
@@ -1485 +1485 @@
         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
@@ -1517 +1517 @@
         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;) {
@@ -1626 +1626 @@
     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");
     }
 
@@ -1649 +1649 @@
     paranoid_free(tmp);
     paranoid_free(bzip2_command);
-    paranoid_free(partimagehack_command);
+    paranoid_free(ntfsprog_command);
     paranoid_free(suffix);
     paranoid_free(sz_devfile);
@@ -1679 +1679 @@
                                      long long biggiefile_size, //UNUSED
                                      struct s_node *filelist,
-                                     int use_partimagehack,
+                                     int use_ntfsprog,
                                      char *pathname_of_last_file_restored)
 {
@@ -1689 +1689 @@
     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;
 
@@ -1703 +1703 @@
     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;
@@ -1710 +1710 @@
 
     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);
@@ -1721 +1721 @@
 
     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);
     }
@@ -1754 +1754 @@
     }
 
-    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:
@@ -1780 +1780 @@
         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);
@@ -1789 +1789 @@
         default:
             log_msg(3,
-                    "feed_into_partimage() called in background --- pid=%ld",
+                    "feed_into_ntfsprog() called in background --- pid=%ld",
                     (long int) (pid));
         }
@@ -1801 +1801 @@
                     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
@@ -1879 +1879 @@
             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");
     }
 
@@ -1903 +1903 @@
     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);