source: branches/stable/mondo/src/common/libmondo-fork.c @ 1107

Last change on this file since 1107 was 1107, checked in by bruno, 13 years ago

log_msg => mr_msg for common files

  • Property svn:keywords set to Id
File size: 19.8 KB
Line 
1/* libmondo-fork.c
2   $Id: libmondo-fork.c 1107 2007-02-07 23:09:34Z bruno $
3*/
4
5
6#include "my-stuff.h"
7#include "mr_mem.h"
8#include "mondostructures.h"
9#include "libmondo-fork.h"
10#include "libmondo-string-EXT.h"
11#include "libmondo-gui-EXT.h"
12#include "libmondo-files-EXT.h"
13#include "libmondo-tools-EXT.h"
14#include "lib-common-externs.h"
15
16/*@unused@*/
17//static char cvsid[] = "$Id: libmondo-fork.c 1107 2007-02-07 23:09:34Z bruno $";
18
19extern char *g_tmpfs_mountpt;
20extern t_bkptype g_backup_media_type;
21extern bool g_text_mode;
22pid_t g_buffer_pid = 0;
23
24
25/**
26 * Call a program and retrieve its last line of output.
27 * @param call The program to run.
28 * @return The last line of its output.
29 * @note The returned value points to static storage that will be overwritten with each call.
30 */
31char *call_program_and_get_last_line_of_output(char *call)
32{
33    /*@ buffers ***************************************************** */
34    static char result[512];
35    char *tmp;
36
37    /*@ pointers **************************************************** */
38    FILE *fin;
39
40    /*@ initialize data ********************************************* */
41    malloc_string(tmp);
42    result[0] = '\0';
43    tmp[0] = '\0';
44
45    /*@******************************************************************** */
46
47    assert_string_is_neither_NULL_nor_zerolength(call);
48    if ((fin = popen(call, "r"))) {
49        for (fgets(tmp, MAX_STR_LEN, fin); !feof(fin);
50             fgets(tmp, MAX_STR_LEN, fin)) {
51            if (strlen(tmp) > 1) {
52                strcpy(result, tmp);
53            }
54        }
55        paranoid_pclose(fin);
56    } else {
57        log_OS_error("Unable to popen call");
58    }
59    strip_spaces(result);
60    return (result);
61}
62
63
64
65
66
67
68#define MONDO_POPMSG  "Your PC will not retract the CD tray automatically. Please call mondoarchive with the -m (manual CD tray) flag."
69
70/**
71 * Call mkisofs to create an ISO image.
72 * @param bkpinfo The backup information structure. Fields used:
73 * - @c bkpinfo->manual_cd_tray
74 * - @c bkpinfo->backup_media_type
75 * - @c bkpinfo->please_dont_eject_when_restoring
76 * @param basic_call The call to mkisofs. May contain tokens that will be resolved to actual data. The tokens are:
77 * - @c _ISO_ will become the ISO file (@p isofile)
78 * - @c _CD#_ becomes the CD number (@p cd_no)
79 * - @c _ERR_ becomes the logfile (@p g_logfile)
80 * @param isofile Replaces @c _ISO_ in @p basic_call. Should probably be the ISO image to create (-o parameter to mkisofs).
81 * @param cd_no Replaces @c _CD#_ in @p basic_call. Should probably be the CD number.
82 * @param logstub Unused.
83 * @param what_i_am_doing The action taking place (e.g. "Making ISO #1"). Used as the title of the progress dialog.
84 * @return Exit code of @c mkisofs (0 is success, anything else indicates failure).
85 * @bug @p logstub is unused.
86 */
87int
88eval_call_to_make_ISO(struct s_bkpinfo *bkpinfo,
89                      char *basic_call, char *isofile,
90                      int cd_no, char *logstub, char *what_i_am_doing)
91{
92
93    /*@ int's  *** */
94    int retval = 0;
95
96
97    /*@ buffers      *** */
98    char *midway_call, *ultimate_call, *tmp, *command, *incoming,
99        *old_stderr, *cd_number_str;
100    char *p;
101
102/*@***********   End Variables ***************************************/
103
104    mr_msg(3, "Starting");
105    assert(bkpinfo != NULL);
106    assert_string_is_neither_NULL_nor_zerolength(basic_call);
107    assert_string_is_neither_NULL_nor_zerolength(isofile);
108    assert_string_is_neither_NULL_nor_zerolength(logstub);
109    midway_call = mr_malloc(1200);
110    ultimate_call = mr_malloc(1200);
111    tmp = mr_malloc(1200);
112    command = mr_malloc(1200);
113    malloc_string(incoming);
114    malloc_string(old_stderr);
115    malloc_string(cd_number_str);
116
117    incoming[0] = '\0';
118    old_stderr[0] = '\0';
119
120    sprintf(cd_number_str, "%d", cd_no);
121    resolve_naff_tokens(midway_call, basic_call, isofile, "_ISO_");
122    resolve_naff_tokens(tmp, midway_call, cd_number_str, "_CD#_");
123    resolve_naff_tokens(ultimate_call, tmp, MONDO_LOGFILE, "_ERR_");
124    mr_msg(4, "basic call = '%s'", basic_call);
125    mr_msg(4, "midway_call = '%s'", midway_call);
126    mr_msg(4, "tmp = '%s'", tmp);
127    mr_msg(4, "ultimate call = '%s'", ultimate_call);
128    sprintf(command, "%s >> %s", ultimate_call, MONDO_LOGFILE);
129
130    log_to_screen
131        ("Please be patient. Do not be alarmed by on-screen inactivity.");
132    mr_msg(4, "Calling open_evalcall_form() with what_i_am_doing='%s'",
133            what_i_am_doing);
134    strcpy(tmp, command);
135    if (bkpinfo->manual_cd_tray) {
136        p = strstr(tmp, "2>>");
137        if (p) {
138            sprintf(p, "   ");
139            while (*p == ' ') {
140                p++;
141            }
142            for (; *p != ' '; p++) {
143                *p = ' ';
144            }
145        }
146        strcpy(command, tmp);
147#ifndef _XWIN
148        if (!g_text_mode) {
149            newtSuspend();
150        }
151#endif
152        mr_msg(1, "command = '%s'", command);
153        retval += system(command);
154        if (!g_text_mode) {
155            newtResume();
156        }
157        if (retval) {
158            mr_msg(2, "Basic call '%s' returned an error.", basic_call);
159            popup_and_OK("Press ENTER to continue.");
160            popup_and_OK
161                ("mkisofs and/or cdrecord returned an error. CD was not created");
162        }
163    }
164    /* if text mode then do the above & RETURN; if not text mode, do this... */
165    else {
166        mr_msg(3, "command = '%s'", command);
167//      yes_this_is_a_goto:
168        retval =
169            run_external_binary_with_percentage_indicator_NEW
170            (what_i_am_doing, command);
171    }
172
173    mr_free(midway_call);
174    mr_free(ultimate_call);
175    mr_free(tmp);
176    mr_free(command);
177    mr_free(incoming);
178    mr_free(old_stderr);
179    mr_free(cd_number_str);
180/*
181  if (bkpinfo->backup_media_type == dvd && !bkpinfo->please_dont_eject_when_restoring)
182    {
183      mr_msg(3, "Ejecting DVD device");
184      eject_device(bkpinfo->media_device);
185    }
186*/
187    return (retval);
188}
189
190
191
192
193/**
194 * Run a program and log its output (stdout and stderr) to the logfile.
195 * @param program The program to run. Passed to the shell, so you can use pipes etc.
196 * @param debug_level If @p g_loglevel is higher than this, do not log the output.
197 * @return The exit code of @p program (depends on the command, but 0 almost always indicates success).
198 */
199int run_program_and_log_output(char *program, int debug_level)
200{
201    /*@ buffer ****************************************************** */
202    char callstr[MAX_STR_LEN * 2];
203    char incoming[MAX_STR_LEN * 2];
204    char tmp[MAX_STR_LEN * 2];
205    char initial_label[MAX_STR_LEN * 2];
206
207    /*@ int ********************************************************* */
208    int res;
209    int i;
210    int len;
211    bool log_if_failure = FALSE;
212    bool log_if_success = FALSE;
213
214    /*@ pointers *************************************************** */
215    FILE *fin;
216    char *p;
217
218    /*@ end vars *************************************************** */
219
220    assert(program != NULL);
221    if (!program[0]) {
222        mr_msg(2, "Warning - asked to run zerolength program");
223        return (1);
224    }
225//  if (debug_level == TRUE) { debug_level=5; }
226
227    //  assert_string_is_neither_NULL_nor_zerolength(program);
228
229    if (debug_level <= g_loglevel) {
230        log_if_success = TRUE;
231        log_if_failure = TRUE;
232    }
233    sprintf(callstr,
234            "%s > /tmp/mondo-run-prog-thing.tmp 2> /tmp/mondo-run-prog-thing.err",
235            program);
236    while ((p = strchr(callstr, '\r'))) {
237        *p = ' ';
238    }
239    while ((p = strchr(callstr, '\n'))) {
240        *p = ' ';
241    }                           /* single '=' is intentional */
242
243
244    len = (int) strlen(program);
245    for (i = 0; i < 35 - len / 2; i++) {
246        tmp[i] = '-';
247    }
248    tmp[i] = '\0';
249    strcat(tmp, " ");
250    strcat(tmp, program);
251    strcat(tmp, " ");
252    for (i = 0; i < 35 - len / 2; i++) {
253        strcat(tmp, "-");
254    }
255    strcpy(initial_label, tmp);
256    res = system(callstr);
257    if (((res == 0) && log_if_success) || ((res != 0) && log_if_failure)) {
258        mr_msg(0, "running: %s", callstr);
259        mr_msg(0,
260                "--------------------------------start of output-----------------------------");
261    }
262    if (log_if_failure
263        &&
264        system
265        ("cat /tmp/mondo-run-prog-thing.err >> /tmp/mondo-run-prog-thing.tmp 2> /dev/null"))
266    {
267        log_OS_error("Command failed");
268    }
269    unlink("/tmp/mondo-run-prog-thing.err");
270    fin = fopen("/tmp/mondo-run-prog-thing.tmp", "r");
271    if (fin) {
272        for (fgets(incoming, MAX_STR_LEN, fin); !feof(fin);
273             fgets(incoming, MAX_STR_LEN, fin)) {
274            /* patch by Heiko Schlittermann */
275            p = incoming;
276            while (p && *p) {
277                if ((p = strchr(p, '%'))) {
278                    memmove(p, p + 1, strlen(p) + 1);
279                    p += 2;
280                }
281            }
282            /* end of patch */
283            strip_spaces(incoming);
284            if ((res == 0 && log_if_success)
285                || (res != 0 && log_if_failure)) {
286                mr_msg(0, incoming);
287            }
288        }
289        paranoid_fclose(fin);
290    }
291    unlink("/tmp/mondo-run-prog-thing.tmp");
292    if ((res == 0 && log_if_success) || (res != 0 && log_if_failure)) {
293        mr_msg(0,
294                "--------------------------------end of output------------------------------");
295        if (res) {
296            mr_msg(0, "...ran with res=%d", res);
297        } else {
298            mr_msg(0, "...ran just fine. :-)");
299        }
300    }
301//  else
302//    { mr_msg (0, "-------------------------------ran w/ res=%d------------------------------", res); }
303    return (res);
304}
305
306
307
308/**
309 * Run a program and log its output to the screen.
310 * @param basic_call The program to run.
311 * @param what_i_am_doing The title of the evalcall form.
312 * @return The return value of the command (varies, but 0 almost always means success).
313 * @see run_program_and_log_output
314 * @see log_to_screen
315 */
316int run_program_and_log_to_screen(char *basic_call, char *what_i_am_doing)
317{
318    /*@ int ******************************************************** */
319    int retval = 0;
320    int res = 0;
321    int i;
322
323    /*@ pointers **************************************************** */
324    FILE *fin;
325
326    /*@ buffers **************************************************** */
327    char tmp[MAX_STR_LEN * 2];
328    char command[MAX_STR_LEN * 2];
329    char lockfile[MAX_STR_LEN];
330
331    /*@ end vars *************************************************** */
332
333    assert_string_is_neither_NULL_nor_zerolength(basic_call);
334
335    sprintf(lockfile, "/tmp/mojo-jojo.blah.XXXXXX");
336    mkstemp(lockfile);
337    sprintf(command,
338            "echo hi > %s ; %s >> %s 2>> %s; res=$?; sleep 1; rm -f %s; exit $res",
339            lockfile, basic_call, MONDO_LOGFILE, MONDO_LOGFILE, lockfile);
340    open_evalcall_form(what_i_am_doing);
341    sprintf(tmp, "Executing %s", basic_call);
342    mr_msg(2, tmp);
343    if (!(fin = popen(command, "r"))) {
344        log_OS_error("Unable to popen-in command");
345        sprintf(tmp, "Failed utterly to call '%s'", command);
346        log_to_screen(tmp);
347        return (1);
348    }
349    if (!does_file_exist(lockfile)) {
350        log_to_screen("Waiting for external binary to start");
351        for (i = 0; i < 60 && !does_file_exist(lockfile); sleep(1), i++) {
352            mr_msg(3, "Waiting for lockfile %s to exist", lockfile);
353        }
354    }
355#ifdef _XWIN
356    /* This only can update when newline goes into the file,
357       but it's *much* prettier/faster on Qt. */
358    while (does_file_exist(lockfile)) {
359        while (!feof(fin)) {
360            if (!fgets(tmp, 512, fin))
361                break;
362            log_to_screen(tmp);
363        }
364        usleep(500000);
365    }
366#else
367    /* This works on Newt, and it gives quicker updates. */
368    for (; does_file_exist(lockfile); sleep(1)) {
369        log_file_end_to_screen(MONDO_LOGFILE, "");
370        update_evalcall_form(1);
371    }
372#endif
373    /* Evaluate the status returned by pclose to get the exit code of the called program. */
374    errno = 0;
375    res = pclose(fin);
376    /* Log actual pclose errors. */
377    if (errno) mr_msg(5, "pclose err: %d", errno);
378    /* Check if we have a valid status. If we do, extract the called program's exit code. */
379    /* If we don't, highlight this fact by returning -1. */
380    if (WIFEXITED(res)) {
381        retval = WEXITSTATUS(res);
382    } else {
383        retval = -1;
384    }
385    close_evalcall_form();
386    unlink(lockfile);
387    return (retval);
388}
389
390
391
392
393/**
394 * Apparently unused. @bug This has a purpose, but what?
395 */
396#define PIMP_START_SZ "STARTSTARTSTART9ff3kff9a82gv34r7fghbkaBBC2T231hc81h42vws8"
397#define PIMP_END_SZ "ENDENDEND0xBBC10xBBC2T231hc81h42vws89ff3kff9a82gv34r7fghbka"
398
399
400
401
402int copy_from_src_to_dest(FILE * f_orig, FILE * f_archived, char direction)
403{
404// if dir=='w' then copy from orig to archived
405// if dir=='r' then copy from archived to orig
406    char *tmp;
407    char *buf;
408    long int bytes_to_be_read, bytes_read_in, bytes_written_out =
409        0, bufcap, subsliceno = 0;
410    int retval = 0;
411    FILE *fin;
412    FILE *fout;
413    FILE *ftmp;
414
415    mr_msg(5, "Opening.");
416    malloc_string(tmp);
417    tmp[0] = '\0';
418    bufcap = 256L * 1024L;
419    buf = mr_malloc(bufcap);
420
421    if (direction == 'w') {
422        fin = f_orig;
423        fout = f_archived;
424        sprintf(tmp, "%-64s", PIMP_START_SZ);
425        if (fwrite(tmp, 1, 64, fout) != 64) {
426            fatal_error("Can't write the introductory block");
427        }
428        while (1) {
429            bytes_to_be_read = bytes_read_in = fread(buf, 1, bufcap, fin);
430            if (bytes_read_in == 0) {
431                break;
432            }
433            sprintf(tmp, "%-64ld", bytes_read_in);
434            if (fwrite(tmp, 1, 64, fout) != 64) {
435                fatal_error("Cannot write introductory block");
436            }
437            mr_msg(7,
438                    "subslice #%ld --- I have read %ld of %ld bytes in from f_orig",
439                    subsliceno, bytes_read_in, bytes_to_be_read);
440            bytes_written_out += fwrite(buf, 1, bytes_read_in, fout);
441            sprintf(tmp, "%-64ld", subsliceno);
442            if (fwrite(tmp, 1, 64, fout) != 64) {
443                fatal_error("Cannot write post-thingy block");
444            }
445            mr_msg(7, "Subslice #%d written OK", subsliceno);
446            subsliceno++;
447        }
448        sprintf(tmp, "%-64ld", 0L);
449        if (fwrite(tmp, 1, 64L, fout) != 64L) {
450            fatal_error("Cannot write final introductory block");
451        }
452    } else {
453        fin = f_archived;
454        fout = f_orig;
455        if (fread(tmp, 1, 64L, fin) != 64L) {
456            fatal_error("Cannot read the introductory block");
457        }
458        mr_msg(5, "tmp is %s", tmp);
459        if (!strstr(tmp, PIMP_START_SZ)) {
460            fatal_error("Can't find intro blk");
461        }
462        if (fread(tmp, 1, 64L, fin) != 64L) {
463            fatal_error("Cannot read introductory blk");
464        }
465        bytes_to_be_read = atol(tmp);
466        while (bytes_to_be_read > 0) {
467            mr_msg(7, "subslice#%ld, bytes=%ld", subsliceno,
468                    bytes_to_be_read);
469            bytes_read_in = fread(buf, 1, bytes_to_be_read, fin);
470            if (bytes_read_in != bytes_to_be_read) {
471                fatal_error
472                    ("Danger, WIll Robinson. Failed to read whole subvol from archives.");
473            }
474            bytes_written_out += fwrite(buf, 1, bytes_read_in, fout);
475            if (fread(tmp, 1, 64, fin) != 64) {
476                fatal_error("Cannot read post-thingy block");
477            }
478            if (atol(tmp) != subsliceno) {
479                mr_msg(1, "Wanted subslice %ld but got %ld ('%s')",
480                        subsliceno, atol(tmp), tmp);
481            }
482            mr_msg(7, "Subslice #%ld read OK", subsliceno);
483            subsliceno++;
484            if (fread(tmp, 1, 64, fin) != 64) {
485                fatal_error("Cannot read introductory block");
486            }
487            bytes_to_be_read = atol(tmp);
488        }
489    }
490
491//  mr_msg(4, "Written %ld of %ld bytes", bytes_written_out, bytes_read_in);
492
493    if (direction == 'w') {
494        sprintf(tmp, "%-64s", PIMP_END_SZ);
495        if (fwrite(tmp, 1, 64, fout) != 64) {
496            fatal_error("Can't write the final block");
497        }
498    } else {
499        mr_msg(1, "tmpA is %s", tmp);
500        if (!strstr(tmp, PIMP_END_SZ)) {
501            if (fread(tmp, 1, 64, fin) != 64) {
502                fatal_error("Can't read the final block");
503            }
504            mr_msg(5, "tmpB is %s", tmp);
505            if (!strstr(tmp, PIMP_END_SZ)) {
506                ftmp = fopen("/tmp/out.leftover", "w");
507                bytes_read_in = fread(tmp, 1, 64, fin);
508                mr_msg(1, "bytes_read_in = %ld", bytes_read_in);
509//      if (bytes_read_in!=128+64) { fatal_error("Can't read the terminating block"); }
510                fwrite(tmp, 1, bytes_read_in, ftmp);
511                sprintf(tmp, "I am here - %lld", (long long)ftello(fin));
512//    mr_msg(0, tmp);
513                fread(tmp, 1, 512, fin);
514                mr_msg(0, "tmp = '%s'", tmp);
515                fwrite(tmp, 1, 512, ftmp);
516                fclose(ftmp);
517                fatal_error("Missing terminating block");
518            }
519        }
520    }
521
522    mr_free(buf);
523    mr_free(tmp);
524    mr_msg(3, "Successfully copied %ld bytes", bytes_written_out);
525    return (retval);
526}
527
528
529
530
531/**
532 * Feed @p input_device through ntfsclone to @p output_fname.
533 * @param input_device The device to image.
534 * @param output_fname The file to write.
535 * @return 0 for success, nonzero for failure.
536 */
537int feed_into_ntfsprog(char *input_device, char *output_fname)
538{
539// BACKUP
540    int res = -1;
541    char*command;
542
543    if (!does_file_exist(input_device)) {
544        fatal_error("input device does not exist");
545    }
546    if ( !find_home_of_exe("ntfsclone")) {
547        fatal_error("ntfsclone not found");
548    }
549    malloc_string(command);
550    sprintf(command, "ntfsclone --force --save-image --overwrite %s %s", output_fname, input_device);
551    res = run_program_and_log_output(command, 5);
552    mr_free(command);
553    unlink(output_fname);
554    return (res);
555}
556
557
558
559
560
561int run_external_binary_with_percentage_indicator_OLD(char *tt, char *cmd)
562{
563
564    /*@ int *************************************************************** */
565    int res = 0;
566    int percentage = 0;
567    int maxpc = 0;
568    int pcno = 0;
569    int last_pcno = 0;
570
571    /*@ buffers *********************************************************** */
572    char *command;
573    char *tempfile;
574    char *title;
575    /*@ pointers ********************************************************** */
576    FILE *pin;
577
578    malloc_string(title);
579    malloc_string(command);
580    malloc_string(tempfile);
581    assert_string_is_neither_NULL_nor_zerolength(cmd);
582    assert_string_is_neither_NULL_nor_zerolength(title);
583
584    strcpy(title, tt);
585    strcpy(tempfile,
586           call_program_and_get_last_line_of_output
587           ("mktemp -q /tmp/mondo.XXXXXXXX"));
588    sprintf(command, "%s >> %s 2>> %s; rm -f %s", cmd, tempfile, tempfile,
589            tempfile);
590    mr_msg(3, command);
591    open_evalcall_form(title);
592    if (!(pin = popen(command, "r"))) {
593        log_OS_error("fmt err");
594        return (1);
595    }
596    maxpc = 100;
597// OLD OLD OLD OLD OLD OLD OLD OLD OLD OLD OLD OLD
598    for (sleep(1); does_file_exist(tempfile); sleep(1)) {
599        pcno = grab_percentage_from_last_line_of_file(MONDO_LOGFILE);
600        if (pcno < 0 || pcno > 100) {
601            mr_msg(5, "Weird pc#");
602            continue;
603        }
604        percentage = pcno * 100 / maxpc;
605        if (pcno <= 5 && last_pcno > 40) {
606            close_evalcall_form();
607            strcpy(title, "Verifying...");
608            open_evalcall_form(title);
609        }
610        last_pcno = pcno;
611        update_evalcall_form(percentage);
612    }
613// OLD OLD OLD OLD OLD OLD OLD OLD OLD OLD OLD OLD
614    close_evalcall_form();
615    if (pclose(pin)) {
616        res++;
617        log_OS_error("Unable to pclose");
618    }
619    unlink(tempfile);
620    mr_free(command);
621    mr_free(tempfile);
622    mr_free(title);
623    return (res);
624}
625
626
627
628
629void *run_prog_in_bkgd_then_exit(void *info)
630{
631    char *sz_command;
632    static int res = 4444;
633
634    res = 999;
635    sz_command = (char *) info;
636    mr_msg(4, "sz_command = '%s'", sz_command);
637    res = system(sz_command);
638    if (res > 256 && res != 4444) {
639        res = res / 256;
640    }
641    mr_msg(4, "child res = %d", res);
642    sz_command[0] = '\0';
643    pthread_exit((void *) (&res));
644}
645
646
647
648
649int run_external_binary_with_percentage_indicator_NEW(char *tt, char *cmd)
650{
651
652    /*@ int *************************************************************** */
653    int res = 0;
654    int percentage = 0;
655    int maxpc = 100;
656    int pcno = 0;
657    int last_pcno = 0;
658    int counter = 0;
659
660    /*@ buffers *********************************************************** */
661    char *command;
662    char *title;
663    /*@ pointers ********************************************************** */
664    static int chldres = 0;
665    int *pchild_result;
666    pthread_t childthread;
667
668    pchild_result = &chldres;
669    assert_string_is_neither_NULL_nor_zerolength(cmd);
670    assert_string_is_neither_NULL_nor_zerolength(tt);
671    *pchild_result = 999;
672
673    malloc_string(title);
674    malloc_string(command);
675    strcpy(title, tt);
676    sprintf(command, "%s 2>> %s", cmd, MONDO_LOGFILE);
677    mr_msg(3, "command = '%s'", command);
678    if ((res =
679         pthread_create(&childthread, NULL, run_prog_in_bkgd_then_exit,
680                        (void *) command))) {
681        fatal_error("Unable to create an archival thread");
682    }
683
684    mr_msg(8, "Parent running");
685    open_evalcall_form(title);
686    for (sleep(1); command[0] != '\0'; sleep(1)) {
687        pcno = grab_percentage_from_last_line_of_file(MONDO_LOGFILE);
688        if (pcno <= 0 || pcno > 100) {
689            mr_msg(8, "Weird pc#");
690            continue;
691        }
692        percentage = pcno * 100 / maxpc;
693        if (pcno <= 5 && last_pcno >= 40) {
694            close_evalcall_form();
695            strcpy(title, "Verifying...");
696            open_evalcall_form(title);
697        }
698        if (counter++ >= 5) {
699            counter = 0;
700            log_file_end_to_screen(MONDO_LOGFILE, "");
701        }
702        last_pcno = pcno;
703        update_evalcall_form(percentage);
704    }
705    log_file_end_to_screen(MONDO_LOGFILE, "");
706    close_evalcall_form();
707    pthread_join(childthread, (void *) (&pchild_result));
708    if (pchild_result) {
709        res = *pchild_result;
710    } else {
711        res = 666;
712    }
713    mr_msg(3, "Parent res = %d", res);
714    mr_free(command);
715    mr_free(title);
716    return (res);
717}
718
719
720
721
722/**
723 * Feed @p input_fifo through ntfsclone (restore) to @p output_device.
724 * @param input_fifo The ntfsclone file to read.
725 * @param output_device Where to put the output.
726 * @return The return value of ntfsclone (0 for success).
727 */
728int feed_outfrom_ntfsprog(char *output_device, char *input_fifo)
729{
730// RESTORE
731    int res = -1;
732    char *command;
733
734    if ( !find_home_of_exe("ntfsclone")) {
735        fatal_error("ntfsclone not found");
736    }
737    malloc_string(command);
738    sprintf(command, "ntfsclone --force --restore-image --overwrite %s %s", output_device, input_fifo);
739    res = run_program_and_log_output(command, 5);
740    mr_free(command);
741    return (res);
742}
Note: See TracBrowser for help on using the repository browser.