source: branches/2.04_berlios/mondo/mondo/mondorestore/mondo-restore.c @ 2708

Last change on this file since 2708 was 2708, checked in by bruno, 8 years ago

r4184@localhost: bruno | 2011-01-27 15:52:51 +0100

  • Adds support for hpsa driver (new HP Smart Array driver)
  • Property svn:keywords set to Id
File size: 119.5 KB
Line 
1/***************************************************************************
2       mondo-restore.c  -  restores mondoarchive data
3                             -------------------
4    begin                : Fri May 19 2000
5    copyright            : (C) 2000 by Hugo Rabson
6    email                : Hugo Rabson <hugorabson@msn.com>
7    cvsid                : $Id: mondo-restore.c 2708 2011-01-27 18:31:44Z bruno $
8***************************************************************************/
9
10/***************************************************************************
11 *                                                                         *
12 *   This program is free software; you can redistribute it and/or modify  *
13 *   it under the terms of the GNU General Public License as published by  *
14 *   the Free Software Foundation; either version 2 of the License, or     *
15 *   (at your option) any later version.                                   *
16 *                                                                         *
17 ***************************************************************************/
18
19/***************************************************************************
20 *                         Change Log                                      *
21 ***************************************************************************
22.
23
24
2507/26
26- workaround - if not /dev then don't call partimagehack
27
2807/21
29- if switch to Interactive Mode during nuke then don't nuke twice :) just once
30
3107/18
32- better support of users who boot from LVM CD and nuke-restore non-LVM backups
33
3407/10
35- when using 'star', exclude all 'not removed.' messages from log (misleading, they are)
36- try w/ ACLs, then w/o ACLs if star fails w/ ACLs
37- added ACL, xattr support for afio
38
3906/26
40- remove make_relevant_partition_bootable(); roll into mondo-prep.c
41- changed various newtDrawRootText() calls to use g_noof_rows instead of
42  integers
43
4406/19
45- don't try to access biggiestruct before it is populated w/ data relating
46  to biggiefile; instead, use control char to find out if biggiefile is
47  to be restored w/ partimagehack or not
48- added AUX_VER
49
5006/15
51- read_cfg_file_into_bkpinfo() --- use user-supplied 'isodir' instead of
52  archive's 'isodir' if different
53  Conor Daly <conor.daly@met.ie>
54
5506/17
56- restore with partimagehack if NTFS device; dd, if non-NTFS device
57
5806/14
59- unmount all; remount, run grub-mr; unmount again
60
6104/09
62- fixed subset restoration bug introduced when I added 'star' support
63
6404/04
65- cleaned up restore_a_tarball_from_stream()
66
6704/03
68- added star support
69- pause for 3s between partitioning and formatting (if in Nuke Mode)
70
7103/28
72- check that g_mountlist_fname was correcfly set; abort if it wasn't
73
7403/25
75- removed dev_null code
76
7703/22/04
78- added mode_of_file()
79- added code to check for unauthorised modification of /dev/null
80  by afio (for instance)
81
8212/27/03
83- check /tmp/cmdline instead of /proc/cmdline if on FreeBSD
84
8511/15
86- added g_fprep
87- "Switch to interactive mode?" msg is now more informative
88
8911/05
90- after 'Are you sure?' when user specifies / as restore path, set
91  restore_path[] to "" so that files are restored to [blank]/file/name :)
92
9310/29
94- moved "No restoring or comparing will take place today" block
95  up to before iso_fiddly_bits (if iso) is called - fix bug
96  if you're in ISO Mode and you say "exit to shell"
97
9810/22
99- swapped calls to chmod() and chown() after restoration
100  of big files (Jens)
101
10210/21
103- changed "/mnt/cdrom" to MNT_CDROM
104
10510/19
106- restore biggiefiles selectively from CD properly
107- use find_my_editor() to find pico/vi/whatever
108- better use of call_program_and_get_last_line_of_output() to
109  scan /proc/cmdline
110
11110/18
112- don't report 'missing compressor' if no compressor used at all
113
11410/14
115- log afio's error messages to /var/log/mondo-archive.log
116  when restoring :)
117- call vi if pico is not available
118
11910/09
120- better logging if fatal error (cannot openout bigfile)
121- better GUI feedback when restoring big files
122- restore_everything() now uses s_node* instead of char*
123- ditto restore_all_*_from_*()
124
12510/02
126- succinct msg instead of pop-ups, if used -H
127
12809/27
129- tweaked restore-time gui
130
13109/26
132- proper reporting of DVD/CDR/etc. type in displayed dialogs
133
13409/23
135- malloc/free global strings in new subroutines - malloc_libmondo_global_strings()
136  and free_libmondo_global_strings() - which are in libmondo-tools.c
137
13809/21
139- trying to fix "mondorestore <no params>" segfault
140
14109/18
142- better remounting of /
143- cleaned up run_grub()
144- sensible command-line handling in Live Mode
145
14609/17
147- cleaned up GRUB installer script a bit
148
14909/15
150- remount / as r/w if in disaster recovery mode;
151  helps for b0rken distros
152
15309/13
154- major NTFS hackage
155
15609/12
157- changed some in-sub var decl'ns to malloc()'s
158
15909/05
160- don't let me run unless I'm root
161- finished NTFS/partimagehack support (CD only); working on tape now
162
16309/01
164- fixed cosmetic bug in biggiefile restore window
165
16606/01 - 08/31
167- added code to main() to make sure NFS
168  (backup) share is mounted in Nuke and Compare Modes
169- added code to run_grub() to mount /boot before running grub-install
170- fixed some stray assert()'s in restore_a_biggiefile_from_stream()
171- fixed bugs in extract_config_file_from_ramdisk()
172  and get_cfg_file_from_archive() which
173  stopped fape+floppy users from being able to
174  boot from floppy and leave floppy in drive :)
175- added hooks to partimage for doing imagedevs
176- fixed calls to popup_and_get_string()
177
17805/01 - 05/31
179- fixed biggiefile atime/utime dates restoration bug, I think
180- added misc clean-up (Steve Hindle)
181- fixed support for subdir-within-NFS-mount
182- if nuke mode fails & user reverts to interactive mode _and succeeds_,
183  don't claim nuke mode aborted :)
184- unmount_all_devices() uses mountlist->el[lino].mountpt
185  instead of mountlist->el[lino].device where possible
186- added Joshua Oreman's FreeBSD patches
187- copied missing paragraph from 1.6x's read_cfg_file_into_bkpinfo()
188  to 1.7x's; affected tape streamer users (badly!)
189- cleaned up some paranoid assert()'s
190- use which("post-nuke") instead of find_home_of_exe("post-nuke")
191- fixed "Don't eject while restoring" mode
192- get_cfg_file_from_archive() --- also recovers mountlist.txt now :)
193- don't eject if 'donteject' is in kernel's command line
194- added 'don't panic' msg to start of log
195
19604/01 - 04/30
197- added text mode (cat /proc/cmdline; if textonly then text mode is on)
198- delete /var/lock/subsys/ * when nuking
199- don't resize mountlist if "noresize" present in /proc/cmdline
200- changed from chmod -R 1777 tmp to chmod 1777 tmp
201- replace newtFinished() and newtInit() with
202  newtSuspend() and newtResume()
203- get_cfg_file_from_archive() returns 1 instead of aborting now
204- read_cfg_file_into_bkpinfo) --- if autorun CD but its config
205  file indicates a non-CD backup media then ask, just in case
206- sped up restore_a_tarball_from_CD() a bit
207- line 4469 --- if post-nuke not found then don't run it :)
208- replaced "/mnt/RESTORING" with MNT_RESTORING (#define'd)
209- moved compare_*() into mondorestore/mondo-rstr-compare.c
210- moved some RAID subroutines into common/libmondo-raid.c
211- fixed some iso live compare problems
212- replaced FILELIST_FULL with g_filelist_full and FILELIST_FULL_STUB;
213  g_filelist_full being the full path of the filelist.full text file and
214  FILELIST_FULL_STUB being "tmp/filelist.full" (relative path);
215- ditto BIGGIELIST_TXT, MONDO_CFG_FILE
216- added lots of assert()'s and log_OS_error()'s
217- in Nuke Mode, check mountlist's sanity before doing anything else;
218  if it fails sanity test, offer to revert to Interactive Mode (or abort)
219- copy log to /mnt/RESTORING/root at end
220- read_cfg_file_into_bkpinfo() --- read iso-dev and isodir if bkptype==iso
221- line 1701 --- delete ramdisk file after extracting config info
222- moved call to make_relevant_partitions_bootable() from
223  within run_boot_loader() to within interactive_mode() and
224  nuke_mode(), after unmounting disks
225- if editing fstab or *.conf, try to use pico if available
226- better calling of make-me-bootable
227- don't sort mountlist anywhere anymore except _locally_ in
228  mount_all_devices() and unmount_all_devices()
229- edit fstab, grub.conf _after_ stabgrub-me if it fails
230- run_boot_loader() --- backup all crucial files to /etc/ *.pristine first
231- added iso_fiddly_bits()
232- fixed ISO mode support
233- mount_cdrom() only searches for device if NOT in disaster recovery mode
234- changed lost of system()'s into run_program_and_log_output()'s
235- don't eject if bkpinfo->please_dont_eject_when_restoring
236- cleaned up post-nuke handling code
237- always eject CD at end, unless bkpinfo->please_dont_...
238- misc clean-up (Tom Mortell)
239- afio uses -c (1024L*1024L)/TAPE_BLOCK_SIZE now
240  instead of -c 1024
241
24201/01 - 03/31/2003
243- commented out sort_... line (BB)
244- clean-up (Stan Benoit)
245- added code for LVM and SW Raid (Brian Borgeson)
246- line 814 - added -p to 'mkdir -p tmp'
247- mount_cdrom() - calls find_cdrom_device() if
248  bkpinfo->media_device is blank (to fill it)
249
25011/01 - 12/31/2002
251- mount_cdrom() better at handling multiple CD drives
252- minor clean-up in restore_a_tarball_from_CD()
253- if --live-from-cd then assume restoring live from CD
254- tweaked it to run better w/ ArkLinux
255- create /mnt/RESTORING/mnt/.boot.d for Gentoo users
256  after restoring
257- cleaned up iso_mode(); no longer asks for NFS info 3 times
258- mount_cdrom() was trying to mount /mnt/isodir/%s/%d.iso;
259  is now just %s/%d.iso
260- mount/unmount /boot if necessary (Gentoo)
261- added RAW MBR support; added run_raw_mbr() for the purpose
262- unmount & remount supermounts at start/end of live restore
263- copy /tmp/mountlist.txt to /tmp/mountlist.txt.orig at start
264- cleaned up string-handling in get_cfg_info_from_archives()
265- fixed run_grub() to call new stabgrub-me script
266- popup list of changed files after Compare Mode
267- permit mondorestore --edit-mountlist even if live mode
268- create a repaired copy of grub-install which is RAID-friendly;
269  use it when initializing boot sector with run_grub()
270- use grub-MR instead of grub-install
271- fixed read_cfg_file_into_bkpinfo() to ignore cfg file's backup_media_type
272  if user has already specified a backup media type interactively
273
27410/01 - 10/31
275- run_grub() will let you specify the boot device as well as edit the system
276  files, if grub-install fails
277- fixed bug in fwrite() call in restore_biggiefile_from_CD()
278- fixed bug affecting restoration of bigfiles from CD's w/0 compression
279- run_grub() will run 'grub-install {boot device}' instead of
280  'grub-install (hd0)'
281
28209/01 - 09/30
283- use /tmp/tmpfs/mondo.tmp instead of /tmp/mondo.tmp
284- initialize MOUNTLIST_FNAME at start of main()
285- differential-related cleanup
286- better handling of CD-ROM drives which aren't /dev/cdrom :)
287- run_program_and_log_output() now takes boolean operator to specify
288  whether it will log its activities in the event of _success_
289- always load config file from archive before operating on it
290- moved some subroutines around; now closer to alphabetical order
291- changed mount.mindi to mount.bootisk
292- mount disks readonly if in Compare Mode
293- set /dev/null's permissions to 777, just in case it somehow gets mangled
294  ...which apparently happen with some devfs-based Linux distributions
295- remove /var/run/ *.pid after restoring
296- move spurious lockfiles from /home/ * to /home/ * /.disabled
297- if Interactive Mode then ask user which media, etc. (i.e. catchall mode
298  is now same as Interactive Mode)
299
30008/01 - 08/30
301- use data structure to store the fname, checksum, mods & perms of each bigfile
302  ... biggiestruct :)
303- if a filelist is tiny (2 bytes or less) then ignore it
304- insist_on_this_cd_number() --- now takes 2 params, not 1
305- re-enabled 'g_current_media_number = 1' in restore_everything()
306- added same to compare_mode()
307- replaced lots of global char[]'s with malloc()'s
308- if differential backup then don't permit formatting or fdisking,
309  whether Interactive or Nuke mode
310- added call to register_pid() at start of main()
311- if Nuke Mode & it succeeds then ask user if they have contributed yet
312- changed tape-size to media-size (config file)
313- changed using_* to backup_media_type
314- changed *_from_tape to *_from_stream
315
31607/01 - 07/31
317- added find_and_mount_actual_cdrom()
318- temp dir is always random
319- skip tarballs if they don't contain files we're looking for
320  (used to read the whole thing & _then_ skip)
321- use media_size[1] instead of media_size[0]
322- fixed serious bug in line 1546 - should have been !=, not ==; stopped
323  mondorestore from correctly restoring big files
324- bigfile piping enhancements (Philippe de Muyter)
325- unmount CD-ROM after restoring from live filesystem
326- TAPE_BLOCK_SIZE treated as %ld, not %d
327
32806/01 - 06/30
329- added signal-trapping
330- disabled 'nr-failed-disks' flag
331- fixed problem w/selective restore
332- don't change /tmp's permissions unless it doesn't exist & must be created
333- fixed bug in --mbr
334- is_file_in_list() enhanced to exclude /mnt/RESTORING or whatever
335- added support for uncompressed archives
336- --monitas-live now accepts path-to-restore_to_, not just path to restore
337- added some debugging/tracking code to the NFS section
338- various monitas-related enhancements
339- added --isonuke and --mbr switches
340- better logging in run_grub()
341- improved --monitas-live
342- mkdir -p /mnt/RESTORING/var/run/console just in case user excludes it
343- afio now uses 16MB buffer instead of 8MB
344- always use bkpinfo->media_size[0], now that -s has been expanded
345- popup and ask where to restore data, if restoring selectively
346
34705/01 - 05/31
348- add '--monitas' flag
349- don't run chmod -R 1777 /mnt/RESTORING/tmp before unmounting unless
350  restoring at the time...
351
35204/01 - 04/30
353- delete old /tmp/filelist.full,biggielist.txt if found when restoring to
354  live filesystem
355- replace MONDO_VERSION #define with VERSION from ../config.h
356- write fname of bigfile to screen when having trouble reading/comparing it
357- if restoring to live filesystem then wipe /tmp/tmpfs/ * afterwards
358- removed spurious finish(0) from main()
359
36003/01 - 03/31/2002
361- if /tmp/m*ndo-restore.cfg not found then assume live restore; restore
362  to / instead of /mnt/RESTORING
363- clean up is_file_in_list() to deal with the /mnt/RESTORING/ prefix
364- exclude leading '/' from filelist.restore-these
365- if /tmp/fstab.new exists then use _it_ instead of /tmp/fstab to label
366  ext2 or ext3 partitions
367- improved logging
368
369[...]
370
37107/10/2001 --- first incarnation
372*/
373
374
375/**
376 * @file
377 * The main file for mondorestore.
378 */
379
380/**************************************************************************
381 * #include statements                                                    *
382 **************************************************************************/
383#include <pthread.h>
384#include "../common/my-stuff.h"
385#include "../common/mondostructures.h"
386#include "../common/libmondo.h"
387#include "mr-externs.h"
388#include "mondo-restore.h"
389#include "mondo-rstr-compare-EXT.h"
390#include "mondo-rstr-tools-EXT.h"
391
392extern void success_message(void);
393extern void twenty_seconds_til_yikes(void);
394
395
396/* For use in other programs (ex. XMondo) */
397#ifdef MONDORESTORE_MODULE
398#define main __mondorestore_main
399#define g_ISO_restore_mode __mondorestore_g_ISO_restore_mode
400#endif
401
402#ifndef VERSION
403#define VERSION AUX_VER
404#endif
405
406char g_version[] = VERSION;
407
408
409//static char cvsid[] = "$Id: mondo-restore.c 2708 2011-01-27 18:31:44Z bruno $";
410
411/**************************************************************************
412 * Globals                                                                *
413 **************************************************************************/
414extern char *g_tmpfs_mountpt; // declared in libmondo-tools.c
415extern struct s_bkpinfo *g_bkpinfo_DONTUSETHIS; // used by finish() to free
416                                                // up global bkpinfo struct
417extern bool g_text_mode;
418extern FILE *g_fprep;
419extern double g_kernel_version;
420extern int g_partition_table_locked_up;
421extern int g_noof_rows;
422
423extern int partition_everything(struct mountlist_itself *mountlist);
424
425
426/**
427 * @name Restore-Time Globals
428 * @ingroup globalGroup
429 * @{
430 */
431/**
432 * If TRUE, then SIGPIPE was just caught.
433 * Set by the signal handler; cleared after it's handled.
434 */
435bool    g_sigpipe_caught=FALSE;
436
437/**
438 * If TRUE, then we're restoring from ISOs or an NFS server.
439 * If FALSE, then we're restoring from some kind of real media (tape, CD, etc.)
440 */
441bool    g_ISO_restore_mode = FALSE; /* are we in Iso Mode? */
442
443/**
444 * If TRUE, then we have had a successful "nuke" restore.
445 */
446bool    g_I_have_just_nuked = FALSE;
447
448/**
449 * The device to mount to get at the ISO images. Ignored unless @p g_ISO_restore_mode.
450 */
451char    *g_isodir_device;
452
453/**
454 * The format of @p g_isodir_device. Ignored unless @p g_ISO_restore_mode.
455 */
456char    *g_isodir_format;
457
458/**
459 * The location of 'biggielist.txt', containing the biggiefiles on the current archive set.
460 */
461char    *g_biggielist_txt;
462
463/**
464 * The location of 'filelist.full', containing all files (<em>including biggiefiles</em>) on
465 * the current archive set.
466 */
467char    *g_filelist_full;
468
469/**
470 * The location of a file containing a list of the devices that were archived
471 * as images, not as individual files.
472 */
473char  *g_filelist_imagedevs;
474
475/**
476 * The location of a file containing a list of imagedevs to actually restore.
477 * @see g_filelist_imagedevs
478 */
479char  *g_imagedevs_restthese;
480
481/**
482 * The location of 'mondo-restore.cfg', containing the metadata
483 * information for this backup.
484 */
485char  *g_mondo_cfg_file;
486
487/**
488 * The location of 'mountlist.txt', containing the information on the
489 * user's partitions and hard drives.
490 */
491char  *g_mountlist_fname;
492
493/**
494 * Mondo's home directory during backup. Unused in mondo-restore; included
495 * to avoid link errors.
496 */
497char  *g_mondo_home;
498
499/* @} - end of "Restore-Time Globals" in globalGroup */
500
501
502
503extern int copy_from_src_to_dest(FILE*f_orig, FILE*f_archived, char direction);
504
505
506
507/**************************************************************************
508 * COMPAQ PROLIANT Stuff:  needs some special help                        *
509**************************************************************************/
510
511/**
512 * The message to display if we detect that the user is using a Compaq Proliant.
513 */
514#define COMPAQ_PROLIANTS_SUCK "Partition and format your disk using Compaq's disaster recovery CD. After you've done that, please reboot with your Mondo CD/floppy in Interactive Mode."
515
516
517
518
519/**
520 * Allow the user to modify the mountlist before we partition & format their drives.
521 * @param bkpinfo The backup information structure. @c disaster_recovery is the only field used.
522 * @param mountlist The mountlist to let the user modify.
523 * @param raidlist The raidlist that goes with @p mountlist.
524 * @return 0 for success, nonzero for failure.
525 * @ingroup restoreGuiGroup
526 */
527int let_user_edit_the_mountlist(struct s_bkpinfo *bkpinfo, struct mountlist_itself *mountlist, struct raidlist_itself *raidlist)
528{
529  int retval=0, res=0;
530
531  log_msg(2, "let_user_edit_the_mountlist() --- starting");
532
533  assert(bkpinfo!=NULL);
534  assert(mountlist!=NULL);
535  assert(raidlist!=NULL);
536      if ( !bkpinfo->disaster_recovery )
537        {
538          strcpy( g_mountlist_fname, "/tmp/mountlist.txt" );
539          log_msg(2,  "I guess you're testing edit_mountlist()" );
540        }
541      if (!does_file_exist(g_mountlist_fname))
542        {
543          log_to_screen(g_mountlist_fname);
544          log_to_screen("does not exist");
545          return(1);
546        }
547     
548      retval = load_mountlist( mountlist, g_mountlist_fname );
549      load_raidtab_into_raidlist( raidlist, RAIDTAB_FNAME );
550      if ( retval ) { log_to_screen( "Warning - load_raidtab_into_raidlist returned an error" ); }
551      res = edit_mountlist( g_mountlist_fname, mountlist, raidlist );
552      if ( res ) 
553    { 
554      return( 1 ); 
555    }
556
557      save_mountlist_to_disk( mountlist, g_mountlist_fname );
558      save_raidlist_to_raidtab( raidlist, RAIDTAB_FNAME );
559     
560      log_to_screen("I have finished editing the mountlist for you.");
561     
562      return( retval );
563    }
564
565
566
567
568
569/**
570 * Determine whether @p mountlist contains a Compaq diagnostic partition.
571 * @param mountlist The mountlist to examine.
572 * @return TRUE if there's a Compaq diagnostic partition; FALSE if not.
573 * @ingroup restoreUtilityGroup
574 */
575bool 
576partition_table_contains_Compaq_diagnostic_partition(struct mountlist_itself *mountlist)
577{
578  int i;
579
580  assert(mountlist!=NULL);
581
582  for( i = 0; i < mountlist->entries; i++ )
583    {
584      if ( strstr( mountlist->el[i].format, "ompaq" ) )
585    {
586      log_msg(2, "mountlist[%d] (%s) is %s (Compaq alert!)",
587          i, 
588          mountlist->el[i].device, 
589          mountlist->el[i].format );
590     
591      return( TRUE );
592    }
593    }
594  return( FALSE );
595}
596/**************************************************************************
597 *END_PARTITION_TABLE_CONTAINS_COMPAQ_DIAGNOSTIC_PARTITION                *
598 **************************************************************************/
599
600
601/**
602 * Allow the user to abort the backup if we find that there is a Compaq diagnostic partition.
603 * @note This function does not actually check for the presence of a Compaq partition.
604 * @ingroup restoreUtilityGroup
605 */
606void 
607offer_to_abort_because_Compaq_Proliants_suck(void)
608{
609  popup_and_OK( COMPAQ_PROLIANTS_SUCK );
610  if ( ask_me_yes_or_no("Would you like to reboot and use your Compaq CD to prep your hard drive?") )
611    { 
612      fatal_error( "Aborting. Please reboot and prep your hard drive with your Compaq CD." ); 
613    }
614}
615/**************************************************************************
616 *END_OFFER_TO_ABORT_BECAUSE_COMPAQ_PROLIANTS_SUCK                        *
617 **************************************************************************/
618
619
620
621/**
622 * Call interactive_mode(), nuke_mode(), or compare_mode() depending on the user's choice.
623 * @param bkpinfo The backup information structure. Most fields are used.
624 * @param mountlist The mountlist containing information about the user's partitions.
625 * @param raidlist The raidlist to go with @p mountlist.
626 * @return The return code from the mode function called.
627 * @ingroup restoreGroup
628 */
629int 
630catchall_mode( struct s_bkpinfo *bkpinfo, 
631           struct mountlist_itself *mountlist, 
632           struct raidlist_itself*raidlist)
633{
634  char c, *tmp;
635  int retval = 0;
636
637  iamhere("inside catchall");
638  assert(bkpinfo!=NULL);
639  assert(mountlist!=NULL);
640  assert(raidlist!=NULL);
641  malloc_string(tmp);
642  iamhere("pre wrm");
643  c = which_restore_mode();
644  iamhere("post wrm");
645  if ( c == 'I' || c == 'N' || c == 'C')
646    { 
647      interactively_obtain_media_parameters_from_user( bkpinfo, FALSE); 
648    }
649  else
650    {
651      popup_and_OK( "No restoring or comparing will take place today." );
652      if ( is_this_device_mounted( "/mnt/cdrom" ) ) 
653    { 
654      run_program_and_log_output( "umount /mnt/cdrom", FALSE); 
655    }
656      if ( g_ISO_restore_mode ) 
657    {
658          sprintf(tmp, "umount %s", bkpinfo->isodir);
659      run_program_and_log_output( tmp, FALSE); 
660    }
661      paranoid_MR_finish( 0 );
662    }
663
664  iamhere("post int");
665
666  if (bkpinfo->backup_media_type == iso)
667    {
668      if (iso_fiddly_bits(bkpinfo, (c=='N')?TRUE:FALSE))
669        { log_msg(2, "catchall_mode --- iso_fiddly_bits returned w/ error"); return(1); }
670      else
671        { log_msg(2, "catchall_mode --- iso_fiddly_bits ok"); }
672    }
673
674  if (c == 'I' ) 
675    { 
676      log_msg(2, "IM selected" ); 
677      retval += interactive_mode( bkpinfo,mountlist,raidlist ); 
678    }
679  else if 
680    ( c == 'N' ) 
681    { 
682      log_msg(2, "NM selected"); 
683      retval += nuke_mode( bkpinfo, mountlist, raidlist ); }
684  else if 
685    ( c == 'C' ) 
686    { 
687      log_msg(2, "CM selected" ); 
688      retval += compare_mode( bkpinfo, mountlist, raidlist); 
689    }
690  paranoid_free(tmp);
691  return( retval );
692}
693/**************************************************************************
694 *END_CATCHALL_MODE                                                      *
695 **************************************************************************/
696
697/**************************************************************************
698 *END_  EXTRACT_CONFIG_FILE_FROM_RAMDISK                                  *
699 **************************************************************************/
700
701
702/**
703 * Locate an executable in the directory structure rooted at @p restg.
704 * @param out_path Where to put the executable.
705 * @param fname The basename of the executable.
706 * @param restg The directory structure to look in.
707 * @note If it could not be found in @p restg then @p fname is put in @p out_path.
708 * @ingroup restoreUtilityGroup
709 */
710void
711find_pathname_of_executable_preferably_in_RESTORING( char *out_path, char *fname, char*restg )
712{
713  assert(out_path!=NULL);
714  assert_string_is_neither_NULL_nor_zerolength(fname);
715
716  sprintf( out_path, "%s/sbin/%s", restg, fname );
717  if ( does_file_exist(out_path) )
718    {
719      sprintf( out_path, "%s/usr/sbin/%s", restg, fname );
720      if ( does_file_exist( out_path ) )
721        {
722          sprintf( out_path, "%s/bin/%s", restg, fname );
723          if ( does_file_exist( out_path ) )
724            {
725              sprintf( out_path, "%s/usr/bin/%s", restg, fname );
726              if ( does_file_exist( out_path ) )
727                {
728                  strcpy( out_path, fname );
729                }
730            }
731        }
732    }
733}
734
735/**************************************************************************
736 *END_FIND_PATHNAME_OF_EXECUTABLE_PREFERABLY_IN_RESTORING                 *
737 **************************************************************************/
738
739
740
741
742/**
743 * @addtogroup restoreGroup
744 * @{
745 */
746/**
747 * Restore the user's data, in a disaster recovery situation, prompting the
748 * user about whether or not to do every step.
749 * The user can edit the mountlist, choose files to restore, etc.
750 * @param bkpinfo The backup information structure. Most fields are used.
751 * @param mountlist The mountlist containing information about the user's partitions.
752 * @param raidlist The raidlist to go with @p mountlist.
753 * @return 0 for success, or the number of errors encountered.
754 */
755int 
756interactive_mode( struct s_bkpinfo *bkpinfo, 
757          struct mountlist_itself *mountlist, 
758          struct raidlist_itself *raidlist)
759{
760  int retval = 0;
761  int res;
762  int ptn_errs = 0;
763  int fmt_errs = 0;
764
765  bool done;
766  bool restore_all;
767
768  /** needs malloc **********/
769  char *tmp;
770  char *fstab_fname;
771  char *old_restpath;
772 
773  struct s_node *filelist;
774
775  /* try to partition and format */
776
777  log_msg(2,"interactive_mode --- starting (great, assertions OK)");
778
779  malloc_string(tmp);
780  malloc_string(fstab_fname);
781  malloc_string(old_restpath);
782  assert(bkpinfo!=NULL);
783  assert(mountlist!=NULL);
784  assert(raidlist!=NULL); 
785
786  log_msg(2,"interactive_mode --- assertions OK");
787
788  if (g_text_mode)
789    {
790      if (!ask_me_yes_or_no("Interactive Mode + textonly = experimental! Proceed anyway?"))
791        { fatal_error("Wise move."); }
792    }
793
794  iamhere("About to load config file");
795  get_cfg_file_from_archive_or_bust(bkpinfo);
796  read_cfg_file_into_bkpinfo( g_mondo_cfg_file, bkpinfo );
797  iamhere("Done loading config file; resizing ML");
798#ifdef __FreeBSD__
799  if (strstr(call_program_and_get_last_line_of_output("cat /tmp/cmdline"), "noresize"))
800#else
801  if (strstr(call_program_and_get_last_line_of_output("cat /proc/cmdline"), "noresize"))
802#endif
803    { log_msg(1,"Not resizing mountlist."); }
804  else
805    { resize_mountlist_proportionately_to_suit_new_drives(mountlist); }
806  for( done = FALSE; !done; )
807    {
808      iamhere("About to edit mountlist");
809      if (g_text_mode)
810        {
811          save_mountlist_to_disk (mountlist, g_mountlist_fname);
812      sprintf(tmp, "%s %s", find_my_editor(), g_mountlist_fname);
813          res = system(tmp);
814          load_mountlist (mountlist, g_mountlist_fname);
815        }
816      else
817        {
818          res = edit_mountlist( g_mountlist_fname, mountlist, raidlist );
819        }
820      iamhere("Finished editing mountlist");
821      if ( res ) 
822    { 
823      paranoid_MR_finish( 1 ); 
824    }
825      log_msg(2, "Proceeding..." );
826      save_mountlist_to_disk( mountlist, g_mountlist_fname );
827      save_raidlist_to_raidtab( raidlist, RAIDTAB_FNAME );
828      mvaddstr_and_log_it( 1, 30, "Restoring Interactively" );
829      if ( bkpinfo->differential )
830        {
831          log_to_screen( "Because this is a differential backup, disk" );
832      log_to_screen(" partitioning and formatting will not take place." );
833          done=TRUE;
834        }
835      else
836        {
837          if ( ask_me_yes_or_no( "Do you want to erase and partition your hard drives?" ) )
838            {
839          if ( partition_table_contains_Compaq_diagnostic_partition( mountlist ) )
840        { offer_to_abort_because_Compaq_Proliants_suck(); done=TRUE; }
841          else
842        {
843          twenty_seconds_til_yikes();
844          g_fprep = fopen("/tmp/prep.sh", "w");
845          ptn_errs = partition_everything( mountlist );
846          if (ptn_errs)
847            {
848              log_to_screen("Warning. Errors occurred during disk partitioning.");
849            }
850         
851          fmt_errs = format_everything( mountlist, FALSE );
852          if (!fmt_errs)
853            {
854              log_to_screen("Errors during disk partitioning were handled OK.");
855              log_to_screen("Partitions were formatted OK despite those errors.");
856              ptn_errs = 0;
857            }
858          if ( !ptn_errs && !fmt_errs)
859            {
860              done = TRUE;
861            }
862        }
863              paranoid_fclose(g_fprep);
864        }
865          else
866            {
867              mvaddstr_and_log_it( g_currentY++, 0, "User opted not to partition the devices" );
868              if ( ask_me_yes_or_no( "Do you want to format your hard drives?" ) )
869                {
870                  fmt_errs = format_everything( mountlist, TRUE );
871                  if (!fmt_errs) 
872            { 
873              done = TRUE; 
874            }
875            }
876              else
877                {
878                  ptn_errs = fmt_errs = 0;
879                  done = TRUE;
880                }
881            }
882          if (fmt_errs)
883            {
884              mvaddstr_and_log_it( g_currentY++,
885                   0,
886                   "Errors occurred. Please repartition and format drives manually.");
887              done = FALSE;
888            }
889          if ( ptn_errs & !fmt_errs )
890            {
891              mvaddstr_and_log_it( g_currentY++,
892                   0,
893                   "Errors occurred during partitioning. Formatting, however, went OK.");
894              done = TRUE;
895            }
896          if ( !done )
897            {
898              if ( !ask_me_yes_or_no( "Re-edit the mountlist?" ) ) 
899        {
900          retval++;
901          goto end_of_func;
902        }
903            }
904        }
905    }
906
907  /* mount */
908  if ( mount_all_devices( mountlist, TRUE ) )
909    { 
910      unmount_all_devices( mountlist ); 
911      retval++;
912      goto end_of_func;
913    }
914  /* restore */
915  if ( ( restore_all = ask_me_yes_or_no( "Do you want me to restore all of your data?" ) ) )
916    {
917      log_msg(1, "Restoring all data");
918      retval += restore_everything( bkpinfo, NULL );
919    }
920  else if ( ( restore_all = ask_me_yes_or_no( "Do you want me to restore _some_ of your data?") ) )
921    {
922      strcpy( old_restpath, bkpinfo->restore_path );
923      for( done = FALSE; !done; )
924        {
925      unlink("/tmp/filelist.full");
926          filelist = process_filelist_and_biggielist( bkpinfo );
927      /* Now you have /tmp/tmpfs/filelist.restore-these and /tmp/tmpfs/biggielist.restore-these;
928         the former is a list of regular files; the latter, biggiefiles and imagedevs.
929      */       
930      if ( filelist )
931            {
932gotos_suck:
933              strcpy( tmp, old_restpath );
934// (NB: %s is where your filesystem is mounted now, by default)", MNT_RESTORING);
935              if ( popup_and_get_string( "Restore path", "Restore files to where?", tmp, MAX_STR_LEN/4 ) )
936                {
937          if ( !strcmp( tmp, "/" ) )
938            { 
939              if ( !ask_me_yes_or_no( "Are you sure?" ) ) 
940            { 
941              goto gotos_suck;
942            } 
943              tmp[0] = '\0'; // so we restore to [blank]/file/name :)
944            }
945                  strcpy( bkpinfo->restore_path, tmp );
946          log_msg(1, "Restoring subset");
947                  retval += restore_everything( bkpinfo, filelist );
948                  free_filelist( filelist );
949                }
950              else
951                {
952                  strcpy( bkpinfo->restore_path, old_restpath );
953                  free_filelist( filelist );
954                }
955              if ( !ask_me_yes_or_no( "Restore another subset of your backup?" ) )
956        { 
957          done = TRUE; 
958        }
959            }
960          else
961            {
962              done = TRUE;
963            }
964    }
965      strcpy( old_restpath, bkpinfo->restore_path );
966    }
967  else
968    {
969      mvaddstr_and_log_it( g_currentY++,
970               0,
971               "User opted not to restore any data.                                  ");
972    }
973  if ( retval )
974    {
975      mvaddstr_and_log_it( g_currentY++,
976               0,
977               "Errors occurred during the restore phase.            ");
978    }
979 
980  if (ask_me_yes_or_no( "Initialize the boot loader?" ) )
981    {
982      run_boot_loader( TRUE );
983    }
984  else
985    {
986      mvaddstr_and_log_it( g_currentY++,
987               0,
988               "User opted not to initialize the boot loader.");
989    }
990
991//  run_program_and_log_output("cp -af /etc/lvm " MNT_RESTORING "/etc/", 1);
992  protect_against_braindead_sysadmins();
993  //  modify_rclocal_one_time( MNT_RESTORING "/etc" );
994  retval += unmount_all_devices( mountlist );
995  /*  if (restore_some || restore_all || */
996  if ( ask_me_yes_or_no( "Label your ext2 and ext3 partitions if necessary?" ) )
997    {
998      mvaddstr_and_log_it( g_currentY,
999               0,
1000               "Using e2label to label your ext2,3 partitions" );
1001      if ( does_file_exist( "/tmp/fstab.new" ) )
1002        { 
1003      strcpy( fstab_fname, "/tmp/fstab.new"); 
1004    }
1005      else
1006        { 
1007      strcpy( fstab_fname, "/tmp/fstab"); 
1008    }
1009      sprintf( tmp,
1010           "label-partitions-as-necessary %s < %s >> %s 2>> %s", g_mountlist_fname, 
1011           fstab_fname, MONDO_LOGFILE, MONDO_LOGFILE);
1012      res=system( tmp );
1013      if ( res )
1014    {
1015      log_to_screen("label-partitions-as-necessary returned an error");
1016      mvaddstr_and_log_it( g_currentY++, 74, "Failed.");
1017    }
1018      else
1019    {
1020      mvaddstr_and_log_it(g_currentY++, 74, "Done.");
1021    }
1022      retval += res;
1023    }
1024
1025  iamhere("About to leave interactive_mode()");
1026  if ( retval )
1027    {
1028      mvaddstr_and_log_it(g_currentY++,
1029              0,
1030              "Warning - errors occurred during the restore phase.");
1031    }
1032end_of_func:
1033  paranoid_free(tmp);
1034  paranoid_free(fstab_fname);
1035  paranoid_free(old_restpath);
1036  iamhere("Leaving interactive_mode()");
1037  return( retval );
1038}
1039/**************************************************************************
1040 *END_INTERACTIVE_MODE                                                    *
1041 **************************************************************************/
1042
1043
1044
1045/**
1046 * Run an arbitrary restore mode (prompt the user), but from ISO images
1047 * instead of real media.
1048 * @param bkpinfo The backup information structure. Most fields are used.
1049 * @param mountlist The mountlist containing information about the user's partitions.
1050 * @param raidlist The raidlist that goes with @p mountlist.
1051 * @param nuke_me_please If TRUE, we plan to run Nuke Mode.
1052 * @return 0 for success, or the number of errors encountered.
1053 */
1054int 
1055iso_mode(struct s_bkpinfo *bkpinfo, 
1056     struct mountlist_itself *mountlist, 
1057     struct raidlist_itself *raidlist, 
1058     bool nuke_me_please)
1059{
1060  char c;
1061  int retval=0;
1062
1063  assert(bkpinfo!=NULL);
1064  assert(mountlist!=NULL);
1065  assert(raidlist!=NULL);
1066  if (iso_fiddly_bits(bkpinfo, nuke_me_please))
1067    { log_msg(1,"iso_mode --- returning w/ error"); return(1); }
1068  else
1069    {
1070      c=which_restore_mode();
1071      if (c=='I' || c=='N' || c=='C')
1072    { interactively_obtain_media_parameters_from_user(bkpinfo, FALSE); }
1073      if (c=='I') { retval+=interactive_mode(bkpinfo,mountlist,raidlist); }
1074      else if (c=='N') { retval+=nuke_mode(bkpinfo,mountlist,raidlist); }
1075      else if (c=='C') { retval+=compare_mode(bkpinfo,mountlist,raidlist); }
1076      else
1077    { log_to_screen("OK, I shan't restore/compare any files."); }
1078    }
1079  if (is_this_device_mounted(MNT_CDROM)) { paranoid_system("umount "MNT_CDROM); }
1080//  if (! already_mounted)
1081//    {
1082      if (system("umount /tmp/isodir 2> /dev/null")) { log_to_screen("WARNING - unable to unmount device where the ISO files are stored."); }
1083//    }
1084  return( retval );
1085}
1086/**************************************************************************
1087 *END_ISO_MODE                                                            *
1088 **************************************************************************/
1089
1090
1091/*            MONDO - saving your a$$ since Feb 18th, 2000            */
1092
1093
1094
1095
1096/**
1097 * Restore the user's data automatically (no prompts), after a twenty-second
1098 * warning period.
1099 * @param bkpinfo The backup information structure. Most fields are used.
1100 * @param mountlist The mountlist containing information about the user's partitions.
1101 * @param raidlist The raidlist that goes with @p mountlist.
1102 * @return 0 for success, or the number of errors encountered.
1103 * @warning <b><i>THIS WILL ERASE ALL EXISTING DATA!</i></b>
1104 */
1105int 
1106nuke_mode( struct s_bkpinfo *bkpinfo, 
1107       struct mountlist_itself *mountlist,
1108       struct raidlist_itself *raidlist )
1109{
1110  int retval = 0;
1111  int res = 0;
1112  bool boot_loader_installed = FALSE;
1113  /** malloc **/
1114  char tmp[MAX_STR_LEN], tmpA[MAX_STR_LEN], tmpB[MAX_STR_LEN], tmpC[MAX_STR_LEN];
1115
1116  assert(bkpinfo!=NULL);
1117  assert(mountlist!=NULL);
1118  assert(raidlist!=NULL);
1119
1120  log_msg(2, "nuke_mode --- starting");
1121
1122  get_cfg_file_from_archive_or_bust(bkpinfo);
1123  load_mountlist( mountlist, g_mountlist_fname); // in case read_cfg_file_into_bkpinfo updated the mountlist
1124#ifdef __FreeBSD__
1125  if (strstr(call_program_and_get_last_line_of_output("cat /tmp/cmdline"), "noresize"))
1126#else
1127  if (strstr(call_program_and_get_last_line_of_output("cat /proc/cmdline"), "noresize"))
1128#endif
1129    { log_msg(2, "Not resizing mountlist."); }
1130  else
1131    { resize_mountlist_proportionately_to_suit_new_drives(mountlist); }
1132  if (!evaluate_mountlist( mountlist, tmpA, tmpB, tmpC ))
1133    {
1134      sprintf(tmp, "Mountlist analyzed. Result: \"%s %s %s\" Switch to Interactive Mode?", tmpA, tmpB, tmpC);
1135      if (ask_me_yes_or_no(tmp) )
1136    {
1137      retval = interactive_mode( bkpinfo, mountlist, raidlist );
1138      finish(retval);
1139    }
1140      else
1141    {
1142      fatal_error( "Nuke Mode aborted. ");
1143    }
1144    }
1145  save_mountlist_to_disk( mountlist, g_mountlist_fname );
1146  mvaddstr_and_log_it( 1, 30, "Restoring Automatically" );
1147  if ( bkpinfo->differential )
1148    {
1149      log_to_screen( "Because this is a differential backup, disk" );
1150      log_to_screen( "partitioning and formatting will not take place." );
1151      res = 0;
1152    }
1153  else
1154    {     
1155      if ( partition_table_contains_Compaq_diagnostic_partition( mountlist ) )
1156    { 
1157      offer_to_abort_because_Compaq_Proliants_suck(); 
1158    }
1159      else
1160    {
1161      twenty_seconds_til_yikes();
1162      g_fprep = fopen("/tmp/prep.sh", "w");
1163#ifdef __FreeBSD__
1164      if (strstr (call_program_and_get_last_line_of_output ("cat /tmp/cmdline"), "nopart"))
1165#else
1166      if (strstr (call_program_and_get_last_line_of_output ("cat /proc/cmdline"), "nopart"))
1167#endif
1168          {
1169          log_msg (2, "Not partitioning drives due to 'nopart' option.");
1170          res = 0;
1171          }
1172      else
1173          {
1174          res = partition_everything( mountlist );
1175          if (res)
1176            {
1177              log_to_screen("Warning. Errors occurred during partitioning.");
1178              res = 0;
1179            }
1180          }
1181      retval += res;
1182      if ( !res )
1183        {
1184          log_to_screen("Preparing to format your disk(s)");
1185          sleep(1);
1186          system("sync");
1187          log_to_screen("Please wait. This may take a few minutes.");
1188          res += format_everything( mountlist, FALSE );
1189        }
1190      paranoid_fclose(g_fprep);
1191    }
1192    }
1193  retval += res;
1194  if ( res )
1195    {
1196      mvaddstr_and_log_it( g_currentY++,
1197               0,
1198               "Failed to partition and/or format your hard drives.");
1199     
1200      if ( ask_me_yes_or_no( "Try in interactive mode instead?" ) )
1201    { 
1202      retval = interactive_mode( bkpinfo, mountlist, raidlist ); 
1203      goto after_the_nuke;
1204    }
1205      else if ( !ask_me_yes_or_no( "Would you like to try to proceed anyway?" ) )
1206        {
1207          return( retval );
1208    }
1209    }
1210  retval = mount_all_devices( mountlist, TRUE );
1211  if ( retval ) 
1212    {
1213      unmount_all_devices( mountlist ); 
1214      log_to_screen("Unable to mount all partitions. Sorry, I cannot proceed.");
1215      return( retval );
1216    }
1217  iamhere("Restoring everything");
1218  retval += restore_everything( bkpinfo, NULL );
1219  if (!run_boot_loader( FALSE ))
1220    {
1221      log_msg(1, "Great! Boot loader was installed. No need for msg at end.");
1222      boot_loader_installed = TRUE;
1223    }
1224  protect_against_braindead_sysadmins();
1225//  run_program_and_log_output("cp -af /etc/lvm " MNT_RESTORING "/etc/", 1);
1226  //  modify_rclocal_one_time( MNT_RESTORING "/etc" );
1227  retval += unmount_all_devices( mountlist );
1228  mvaddstr_and_log_it( g_currentY,
1229               0,
1230               "Using e2label to label your ext2,3 partitions");
1231
1232  sprintf( tmp, "label-partitions-as-necessary %s < /tmp/fstab", g_mountlist_fname );
1233  res = run_program_and_log_output( tmp, TRUE );
1234  if ( res )
1235    {
1236      log_to_screen( "label-partitions-as-necessary returned an error" );
1237      mvaddstr_and_log_it( g_currentY++, 74, "Failed." );
1238    }
1239  else
1240    {
1241      mvaddstr_and_log_it( g_currentY++, 74, "Done." );
1242    }
1243  retval += res;
1244
1245after_the_nuke:
1246  if (retval)
1247    {
1248      log_to_screen("Errors occurred during the nuke phase.");
1249    }
1250  else if (strstr(call_program_and_get_last_line_of_output("cat /proc/cmdline"), "RESTORE")) // Bruno's thing
1251    {
1252      log_to_screen("PC was restored successfully. Thank you for using Mondo Rescue.");
1253      log_to_screen("Please visit http://www.mondorescue.org and thank the dev team.");
1254    }
1255  else
1256    {
1257#ifdef FREELOADER
1258      success_message();
1259#else
1260      log_to_screen("PC was restored successfully!");
1261#endif
1262    }
1263  g_I_have_just_nuked = TRUE;
1264/*
1265  if (!boot_loader_installed && !does_file_exist(DO_MBR_PLEASE))
1266    {
1267      log_to_screen("PLEASE RUN 'mondorestore --mbr' NOW TO INITIALIZE YOUR BOOT SECTOR");
1268      write_one_liner_data_file(DO_MBR_PLEASE, "mondorestore --mbr");
1269    }
1270*/
1271  return( retval );
1272}
1273
1274/**************************************************************************
1275 *END_NUKE_MODE                                                           *
1276 **************************************************************************/
1277
1278
1279
1280/**
1281 * Restore the user's data (or a subset of it) to the live filesystem.
1282 * This should not be called if we're booted from CD!
1283 * @param bkpinfo The backup information structure. Most fields are used.
1284 * @return 0 for success, or the number of errors encountered.
1285 */
1286int
1287restore_to_live_filesystem( struct s_bkpinfo *bkpinfo )
1288{
1289  int retval = 0;
1290
1291  /** malloc **/
1292  char *old_restpath;
1293
1294  struct mountlist_itself *mountlist;
1295//  static
1296  struct raidlist_itself *raidlist;
1297  struct s_node *filelist;
1298
1299  log_msg(1, "restore_to_live_filesystem() - starting");
1300  assert(bkpinfo!=NULL);
1301  malloc_string(old_restpath);
1302  mountlist = malloc(sizeof(struct mountlist_itself));
1303  raidlist = malloc(sizeof(struct raidlist_itself));
1304  if (!mountlist || !raidlist) { fatal_error("Cannot malloc() mountlist and/or raidlist"); }
1305
1306  strcpy(bkpinfo->restore_path, "/");
1307  if ( !g_restoring_live_from_cd)
1308    {
1309      popup_and_OK("Please insert tape/CD/boot floppy, then hit 'OK' to continue.");
1310      sleep( 1 );
1311    }
1312  interactively_obtain_media_parameters_from_user(bkpinfo, FALSE);
1313  log_msg(2,  "bkpinfo->media_device = %s", bkpinfo->media_device );
1314  if ( !bkpinfo->media_device[0] )
1315    {
1316      log_msg(2, "Warning - failed to find media dev");
1317    }
1318
1319
1320  log_msg(2, "bkpinfo->isodir = %s", bkpinfo->isodir);
1321
1322  open_evalcall_form("Thinking...");
1323
1324  get_cfg_file_from_archive_or_bust ( bkpinfo );
1325  read_cfg_file_into_bkpinfo(g_mondo_cfg_file, bkpinfo);
1326  load_mountlist( mountlist, g_mountlist_fname); // in case read_cfg_file_into_bkpinfo
1327 
1328  close_evalcall_form();
1329  retval = load_mountlist(mountlist, g_mountlist_fname );
1330  load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME );
1331  filelist = process_filelist_and_biggielist( bkpinfo );
1332  if ( filelist )
1333    {
1334      save_filelist(filelist, "/tmp/selected-files.txt");
1335      strcpy( old_restpath, bkpinfo->restore_path );
1336      if ( popup_and_get_string( "Restore path",
1337                 "Restore files to where? )",
1338                 bkpinfo->restore_path, MAX_STR_LEN/4 ) )
1339        {
1340      iamhere("Restoring everything");
1341          retval += restore_everything( bkpinfo, filelist );
1342          free_filelist( filelist );
1343          strcpy(bkpinfo->restore_path, old_restpath);
1344        }
1345      else
1346        {
1347          free_filelist(filelist);
1348        }
1349      strcpy(bkpinfo->restore_path, old_restpath);
1350    }
1351  if ( IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type ) )
1352    {
1353      log_msg(2, "I probably don't need to unmount or eject the CD-ROM but I'm doing it anyway.");
1354    }
1355  run_program_and_log_output( "umount "MNT_CDROM, FALSE );
1356  if (!bkpinfo->please_dont_eject) { eject_device( bkpinfo->media_device ); }
1357  paranoid_free(old_restpath);
1358  free(mountlist);
1359  free(raidlist);
1360  return( retval );
1361}
1362
1363/**************************************************************************
1364 *END_RESTORE_TO_LIVE_FILESYSTEM                                          *
1365 **************************************************************************/
1366
1367/* @} - end of restoreGroup */
1368
1369
1370#include <utime.h>
1371/**
1372 * @addtogroup LLrestoreGroup
1373 * @{
1374 */
1375/**
1376 * Restore biggiefile @p bigfileno from the currently mounted CD.
1377 * @param bkpinfo The backup information structure. Fields used:
1378 * - @c bkpinfo->backup_media_type
1379 * - @c bkpinfo->restore_path
1380 * @param bigfileno The biggiefile number (starting from 0) to restore.
1381 * @param filelist The node structure containing the list of files to restore.
1382 * If the biggiefile is not in this list, it will be skipped (return value will
1383 * still indicate success).
1384 * @return 0 for success (or skip), nonzero for failure.
1385 */
1386int
1387restore_a_biggiefile_from_CD(struct s_bkpinfo *bkpinfo,
1388                 long bigfileno,
1389                 struct s_node*filelist, char*pathname_of_last_file_restored)
1390{
1391  FILE *fin;
1392  FILE *fout;
1393  FILE *fbzip2;
1394 
1395  /** malloc ***/
1396  char *checksum, *outfile_fname, *tmp, *bzip2_command, *partimagehack_command, *suffix, *sz_devfile;
1397  char *bigblk;
1398  char *p;
1399  int retval = 0;
1400  int finished = FALSE;
1401  long sliceno;
1402  long siz;
1403  char partimagehack_fifo[MAX_STR_LEN];
1404  char *file_to_openout = NULL;
1405  struct s_filename_and_lstat_info biggiestruct;
1406  struct utimbuf the_utime_buf, *ubuf;
1407  bool use_partimage_hack=FALSE;
1408  pid_t pid;
1409  int res=0;
1410  int old_loglevel;
1411  char sz_msg[MAX_STR_LEN];
1412  struct s_node *node;
1413
1414  old_loglevel = g_loglevel;
1415  ubuf = &the_utime_buf;
1416  assert(bkpinfo!=NULL);
1417
1418  malloc_string(checksum);
1419  malloc_string(outfile_fname);
1420  malloc_string(tmp);
1421  malloc_string(bzip2_command);
1422  malloc_string(partimagehack_command);
1423  malloc_string(suffix);
1424  malloc_string(sz_devfile);
1425
1426  pathname_of_last_file_restored[0] = '\0';
1427  if( !(bigblk = malloc( TAPE_BLOCK_SIZE ) ) )
1428    {
1429      fatal_error("Cannot malloc bigblk");
1430    }
1431
1432  if ( !(fin = fopen( slice_fname( bigfileno, 0, ARCHIVES_PATH, ""), "r" ) ) )
1433    {
1434      log_to_screen( "Cannot even open bigfile's info file" );
1435      return( 1 );
1436    }
1437
1438  memset((void*)&biggiestruct, 0, sizeof(biggiestruct));
1439  if ( fread((void*)&biggiestruct, 1, sizeof(biggiestruct), fin) < sizeof(biggiestruct))
1440    {
1441      log_msg(2, "Warning - unable to get biggiestruct of bigfile #%d", bigfileno+1);
1442    }
1443  paranoid_fclose(fin);
1444
1445  strcpy(checksum, biggiestruct.checksum);
1446
1447  if ( !checksum[0])
1448    {
1449      sprintf(tmp,"Warning - bigfile %ld does not have a checksum",bigfileno+1);
1450      log_msg(3, tmp);
1451      p = checksum;
1452    }
1453
1454  if (!strncmp ( biggiestruct.filename, "/dev/", 5)) // Whether NTFS or not :)
1455    { strcpy( outfile_fname, biggiestruct.filename); }
1456  else
1457    { sprintf( outfile_fname, "%s/%s", bkpinfo->restore_path, biggiestruct.filename ); }
1458
1459  /* skip file if we have a selective restore subset & it doesn't match */
1460  if (filelist != NULL)
1461    {
1462      node = find_string_at_node(filelist, biggiestruct.filename);
1463      if (!node)
1464        {
1465          log_msg(0, "Skipping %s (name isn't in filelist)", biggiestruct.filename);
1466          pathname_of_last_file_restored[0] = '\0';
1467      return (0);
1468        }
1469      else if (!(node->selected))
1470        {
1471      log_msg(1, "Skipping %s (name isn't in biggielist subset)", biggiestruct.filename);
1472          pathname_of_last_file_restored[0] = '\0';
1473          return( 0 );
1474        }
1475    }
1476  /* otherwise, continue */
1477 
1478  log_msg(1, "DEFINITELY restoring %s", biggiestruct.filename); 
1479  if (biggiestruct.use_partimagehack)
1480    {
1481      if (strncmp ( biggiestruct.filename, "/dev/", 5))
1482        {
1483      log_msg(1, "I was in error when I set biggiestruct.use_partimagehack to TRUE.");
1484      log_msg(1, "%s isn't even in /dev", biggiestruct.filename);
1485      biggiestruct.use_partimagehack = FALSE;
1486    }
1487    }
1488
1489  if (biggiestruct.use_partimagehack) // if it's an NTFS device
1490//  if (!strncmp ( biggiestruct.filename, "/dev/", 5))
1491    {
1492      g_loglevel = 4;
1493      use_partimage_hack = TRUE;
1494      log_msg(2, "Calling partimagehack in background because %s is an NTFS /dev entry", outfile_fname);
1495      sprintf(sz_devfile, "/tmp/%d.%d.000", (int)(random()%32768), (int)(random()%32768));
1496      mkfifo(sz_devfile, 0x770);
1497      strcpy(partimagehack_fifo, sz_devfile);
1498      file_to_openout = partimagehack_fifo;
1499      switch(pid=fork())
1500                {
1501                  case -1: fatal_error("Fork failure");
1502              case 0:
1503            log_msg(3, "CHILD - fip - calling feed_outfrom_partimage(%s, %s)", biggiestruct.filename, partimagehack_fifo);
1504            res=feed_outfrom_partimage(biggiestruct.filename, partimagehack_fifo);
1505//          log_msg(3, "CHILD - fip - exiting");
1506            exit(res);
1507            break;
1508                  default:
1509            log_msg(3, "feed_into_partimage() called in background --- pid=%ld", (long int)(pid));
1510                }
1511    }
1512  else
1513    {
1514      use_partimage_hack = FALSE;
1515      partimagehack_fifo[0] = '\0';
1516      file_to_openout = outfile_fname;
1517      if ( !does_file_exist( outfile_fname ) ) // yes, it looks weird with the '!' but it's correct that way
1518       { make_hole_for_file( outfile_fname ); }
1519    }
1520
1521  sprintf( tmp, "Reassembling big file %ld (%s)", bigfileno+1, outfile_fname );
1522  log_msg(2, tmp );
1523
1524  /*
1525    last slice is zero-length and uncompressed; when we find it, we stop.
1526    We DON'T wait until there are no more slices; if we did that,
1527    We might stop at end of CD, not at last slice (which is 0-len and uncompd)
1528  */
1529
1530  strncpy(pathname_of_last_file_restored, biggiestruct.filename, MAX_STR_LEN-1);
1531  pathname_of_last_file_restored[MAX_STR_LEN-1] = '\0';
1532
1533  log_msg(3, "file_to_openout = %s", file_to_openout);
1534  if ( !(fout = fopen( file_to_openout, "w" ) ) )
1535    {
1536      log_to_screen( "Cannot openout outfile_fname - hard disk full?");
1537      return(1);
1538    }
1539  log_msg(3, "Opened out to %s", outfile_fname); // CD/DVD --> mondorestore --> partimagehack --> hard disk itself
1540
1541  for( sliceno = 1, finished = FALSE; !finished; )
1542    {
1543      if ( !does_file_exist(slice_fname(bigfileno,sliceno,ARCHIVES_PATH,"")) && !does_file_exist(slice_fname(bigfileno,sliceno,ARCHIVES_PATH,"lzo")) && !does_file_exist(slice_fname(bigfileno,sliceno,ARCHIVES_PATH,"bz2")))
1544    {
1545      log_msg(3, "Cannot find a data slice or terminator slice on CD %d", g_current_media_number);
1546      g_current_media_number++;
1547      sprintf( tmp, "Asking for %s #%d so that I may read slice #%ld\n",media_descriptor_string(bkpinfo->backup_media_type), g_current_media_number,sliceno);
1548      log_msg(2,  tmp );
1549      sprintf( tmp, "Restoring from %s #%d", media_descriptor_string(bkpinfo->backup_media_type), g_current_media_number );
1550      log_to_screen( tmp );
1551      insist_on_this_cd_number( bkpinfo, g_current_media_number );
1552      log_to_screen( "Continuing to restore.");
1553    }
1554      else
1555    {
1556      strcpy(tmp, slice_fname(bigfileno,sliceno,ARCHIVES_PATH,""));
1557      if (does_file_exist(tmp) && length_of_file(tmp) == 0)
1558        {
1559          log_msg(2, "End of bigfile # %ld (slice %ld is the terminator)", bigfileno + 1, sliceno );
1560          finished = TRUE;
1561              continue;
1562        }
1563      else
1564        {
1565          if ( does_file_exist(slice_fname(bigfileno, sliceno,ARCHIVES_PATH, "lzo" ) ) )
1566        {
1567          strcpy( bzip2_command, "lzop" );
1568          strcpy( suffix, "lzo");
1569        }
1570          else if ( does_file_exist( slice_fname( bigfileno, sliceno, ARCHIVES_PATH, "bz2" ) ) )
1571        {
1572          strcpy( bzip2_command, "bzip2" );
1573          strcpy( suffix, "bz2");
1574        }
1575          else if ( does_file_exist( slice_fname( bigfileno, sliceno, ARCHIVES_PATH, "" ) ) )
1576        {
1577          strcpy( bzip2_command, "" );
1578          strcpy( suffix, "");
1579        }
1580          else
1581        {
1582          log_to_screen( "OK, that's pretty fsck0red...");
1583          return( 1 );
1584        }
1585        }
1586          if ( bzip2_command[0] != '\0' )
1587            {
1588          sprintf( bzip2_command + strlen( bzip2_command ),
1589               " -dc %s 2>> %s",
1590               slice_fname( bigfileno, sliceno, ARCHIVES_PATH, suffix),
1591               MONDO_LOGFILE);
1592        }
1593          else
1594            {
1595          sprintf( bzip2_command, "cat %s 2>> %s",
1596               slice_fname(bigfileno, sliceno, ARCHIVES_PATH, suffix ),
1597               MONDO_LOGFILE );
1598        }
1599      sprintf(tmp, "Working on %s #%d, file #%ld, slice #%ld    ", media_descriptor_string(bkpinfo->backup_media_type), g_current_media_number, bigfileno + 1, sliceno );
1600          log_msg(2, tmp );
1601
1602          if (!g_text_mode)
1603            {
1604              newtDrawRootText( 0, g_noof_rows - 2, tmp );
1605              newtRefresh();
1606              strip_spaces( tmp );
1607              update_progress_form( tmp );
1608            }
1609      if ( !(fbzip2 = popen( bzip2_command, "r" ) ) )
1610        {
1611          fatal_error( "Can't run popen command");
1612        }
1613      while( !feof( fbzip2 ) )
1614        {
1615          siz = fread( bigblk, 1, TAPE_BLOCK_SIZE, fbzip2 );
1616          if (siz > 0)
1617        {
1618                  sprintf(sz_msg, "Read %ld from fbzip2", siz);
1619          siz = fwrite( bigblk, 1, siz, fout);
1620                  sprintf(sz_msg + strlen(sz_msg), "; written %ld to fout", siz);
1621//        log_msg(2. sz_msg);
1622        }
1623        }
1624      paranoid_pclose(fbzip2);
1625
1626
1627          sliceno++;
1628          g_current_progress++;
1629        }
1630    }
1631/*
1632  memset(bigblk, TAPE_BLOCK_SIZE, 1); // This all looks very fishy...
1633  fwrite( bigblk, 1, TAPE_BLOCK_SIZE, fout);
1634  fwrite( bigblk, 1, TAPE_BLOCK_SIZE, fout);
1635  fwrite( bigblk, 1, TAPE_BLOCK_SIZE, fout);
1636  fwrite( bigblk, 1, TAPE_BLOCK_SIZE, fout);
1637*/
1638  paranoid_fclose( fout );
1639  g_loglevel = old_loglevel;
1640
1641  if (use_partimage_hack)
1642    {
1643      log_msg(3, "Waiting for partimage to finish");
1644      sprintf(tmp, " ps ax | grep \" partimagehack \" | grep -v grep > /dev/null 2> /dev/null");
1645      while(system(tmp) == 0)
1646        { sleep(1); }
1647      log_it("OK, partimage has really finished");
1648    }
1649
1650  if (strcmp(outfile_fname, "/dev/null"))
1651    {
1652      chown( outfile_fname, biggiestruct.properties.st_uid, biggiestruct.properties.st_gid );
1653      chmod( outfile_fname, biggiestruct.properties.st_mode );
1654      ubuf->actime = biggiestruct.properties.st_atime;
1655      ubuf->modtime= biggiestruct.properties.st_mtime;
1656      utime( outfile_fname, ubuf );
1657    }
1658  paranoid_free( bigblk );
1659  paranoid_free(checksum);
1660  paranoid_free(outfile_fname);
1661  paranoid_free(tmp);
1662  paranoid_free(bzip2_command);
1663  paranoid_free(partimagehack_command);
1664  paranoid_free(suffix);
1665  paranoid_free(sz_devfile);
1666
1667  return( retval );
1668}
1669
1670/**************************************************************************
1671 *END_ RESTORE_A_BIGGIEFILE_FROM_CD                                       *
1672 **************************************************************************/
1673
1674
1675
1676/**
1677 * Restore a biggiefile from the currently opened stream.
1678 * @param bkpinfo The backup information structure. Fields used:
1679 * - @c bkpinfo->restore_path
1680 * - @c bkpinfo->zip_exe
1681 * @param orig_bf_fname The original filename of the biggiefile.
1682 * @param biggiefile_number The number of the biggiefile (starting from 0).
1683 * @param orig_checksum Unused.
1684 * @param biggiefile_size Unused.
1685 * @param filelist The node structure containing the list of files to be restored.
1686 * If @p orig_bf_fname is not in the list, it will be ignored.
1687 * @return 0 for success (or skip), nonzero for failure.
1688 * @bug orig_checksum and biggiefile_size are unused (except to check that they are non-NULL).
1689 */
1690int
1691restore_a_biggiefile_from_stream(struct s_bkpinfo *bkpinfo,
1692                 char *orig_bf_fname,
1693                 long biggiefile_number,
1694                 char *orig_checksum, //UNUSED
1695                 long long biggiefile_size, //UNUSED
1696                 struct s_node *filelist, int use_partimagehack,
1697                 char*pathname_of_last_file_restored)
1698{
1699  FILE *pout;
1700  FILE *fin;
1701
1702  /** mallocs ********/
1703  char *tmp;
1704  char *command;
1705  char *outfile_fname;
1706  char *partimagehack_command;
1707  char *sz_devfile;
1708  char *partimagehack_fifo;
1709  char *file_to_openout = NULL;
1710
1711  struct s_node *node;
1712
1713  int old_loglevel;
1714  long current_slice_number = 0;
1715  int retval = 0;
1716  int res = 0;
1717  int ctrl_chr = '\0';
1718  long long slice_siz;
1719  bool dummy_restore = FALSE;
1720  bool use_partimage_hack=FALSE;
1721  pid_t pid;
1722  struct s_filename_and_lstat_info biggiestruct;
1723  struct utimbuf the_utime_buf, *ubuf;
1724  ubuf = &the_utime_buf;
1725
1726  malloc_string(tmp);
1727  malloc_string(partimagehack_fifo);
1728  malloc_string(outfile_fname);
1729  malloc_string(command);
1730  malloc_string(sz_devfile);
1731  malloc_string(partimagehack_command);
1732  old_loglevel = g_loglevel;
1733  assert(bkpinfo!=NULL);
1734  assert(orig_bf_fname!=NULL);
1735  assert(orig_checksum!=NULL);
1736
1737  pathname_of_last_file_restored[0] = '\0';
1738  if (use_partimagehack == BLK_START_A_PIHBIGGIE)
1739    {
1740      use_partimagehack = 1;
1741      log_msg(1, "%s --- pih=YES", orig_bf_fname);
1742    }
1743  else if (use_partimagehack == BLK_START_A_NORMBIGGIE)
1744    {
1745      use_partimagehack = 0;
1746      log_msg(1, "%s --- pih=NO", orig_bf_fname);
1747    }
1748  else
1749    {
1750      use_partimagehack = 0;
1751      log_msg(1, "%s --- pih=NO (weird marker though)", orig_bf_fname);
1752    }
1753 
1754  strncpy(pathname_of_last_file_restored, orig_bf_fname, MAX_STR_LEN-1);
1755  pathname_of_last_file_restored[MAX_STR_LEN-1] = '\0';
1756 
1757  /* open out to biggiefile to be restored (or /dev/null if biggiefile is not to be restored) */
1758
1759  if (filelist != NULL)
1760    {
1761      node = find_string_at_node(filelist, orig_bf_fname);
1762      if (!node)
1763        {
1764          dummy_restore = TRUE;
1765          log_msg(1, "Skipping big file %ld (%s) - not in biggielist subset", biggiefile_number+1, orig_bf_fname);
1766          pathname_of_last_file_restored[0] = '\0';
1767        }
1768      else if (!(node->selected))
1769        {
1770          dummy_restore = TRUE;
1771      log_msg(1, "Skipping %s (name isn't in biggielist subset)", orig_bf_fname);
1772          pathname_of_last_file_restored[0] = '\0';
1773        }
1774    }
1775
1776  if (use_partimagehack)
1777    {
1778      if (strncmp ( orig_bf_fname, "/dev/", 5))
1779        {
1780      log_msg(1, "I was in error when I set use_partimagehack to TRUE.");
1781      log_msg(1, "%s isn't even in /dev", orig_bf_fname);
1782      use_partimagehack = FALSE;
1783    }
1784    }
1785
1786  if (use_partimagehack)
1787    {
1788      g_loglevel = 4;
1789      strcpy(outfile_fname, orig_bf_fname);
1790      use_partimage_hack = TRUE;
1791      log_msg(2, "Calling partimagehack in background because %s is a /dev entry", outfile_fname);
1792      sprintf(sz_devfile, "/tmp/%d.%d.000", (int)(random()%32768), (int)(random()%32768));
1793      mkfifo(sz_devfile, 0x770);
1794      strcpy(partimagehack_fifo, sz_devfile);
1795      file_to_openout = partimagehack_fifo;
1796      switch(pid=fork())
1797                {
1798                  case -1: fatal_error("Fork failure");
1799              case 0:
1800            log_msg(3, "CHILD - fip - calling feed_outfrom_partimage(%s, %s)", outfile_fname, partimagehack_fifo);
1801            res=feed_outfrom_partimage(outfile_fname, partimagehack_fifo);
1802//          log_msg(3, "CHILD - fip - exiting");
1803            exit(res);
1804            break;
1805                  default:
1806            log_msg(3, "feed_into_partimage() called in background --- pid=%ld", (long int)(pid));
1807                }
1808    }
1809  else
1810    {
1811      if (!strncmp ( orig_bf_fname, "/dev/", 5)) // non-NTFS partition
1812        { strcpy(outfile_fname, orig_bf_fname); }
1813      else // biggiefile
1814        { sprintf( outfile_fname, "%s/%s", bkpinfo->restore_path, orig_bf_fname ); }
1815      use_partimage_hack = FALSE;
1816      partimagehack_fifo[0] = '\0';
1817      file_to_openout = outfile_fname;
1818      if ( !does_file_exist( outfile_fname ) ) // yes, it looks weird with the '!' but it's correct that way
1819       { make_hole_for_file( outfile_fname ); }
1820      sprintf(tmp, "Reassembling big file %ld (%s)", biggiefile_number + 1, orig_bf_fname );
1821      log_msg(2, tmp );
1822    }
1823 
1824  if (dummy_restore)
1825    { sprintf( outfile_fname, "/dev/null" ); }
1826   
1827  if ( !bkpinfo->zip_exe[0] )
1828    {
1829      sprintf(command, "cat > \"%s\"", file_to_openout);
1830    }
1831  else
1832    {
1833      sprintf(command,"%s -dc > \"%s\" 2>> %s",bkpinfo->zip_exe, file_to_openout, MONDO_LOGFILE);
1834    }
1835  sprintf(tmp,"Pipe command = '%s'",command);
1836  log_msg(3, tmp);
1837
1838  /* restore biggiefile, one slice at a time */
1839  if ( !( pout = popen(command, "w" ) ) )
1840    {
1841      fatal_error( "Cannot pipe out" );
1842    }
1843  for( res = read_header_block_from_stream( &slice_siz, tmp, &ctrl_chr); ctrl_chr!=BLK_STOP_A_BIGGIE; res=read_header_block_from_stream(&slice_siz, tmp, &ctrl_chr ) )
1844    {
1845      if ( ctrl_chr != BLK_START_AN_AFIO_OR_SLICE )
1846    {
1847      wrong_marker( BLK_START_AN_AFIO_OR_SLICE,ctrl_chr );
1848    }
1849      sprintf( tmp,"Working on file #%ld, slice #%ld    ",
1850           biggiefile_number + 1,
1851           current_slice_number);
1852      log_msg(2, tmp);
1853      if (!g_text_mode)
1854        {
1855          newtDrawRootText( 0, g_noof_rows - 2, tmp);
1856          newtRefresh();
1857        }
1858      strip_spaces( tmp );
1859      update_progress_form( tmp );
1860      if ( current_slice_number == 0 )
1861        {
1862          res = read_file_from_stream_to_file( bkpinfo,"/tmp/biggie-blah.txt",slice_siz);
1863          if (!(fin = fopen("/tmp/biggie-blah.txt", "r")))
1864            { log_OS_error("blah blah"); }
1865          else
1866            {
1867              if ( fread( (void*)&biggiestruct, 1, sizeof(biggiestruct), fin) < sizeof(biggiestruct))
1868                {
1869                  log_msg(2, "Warning - unable to get biggiestruct of bigfile #%d", biggiefile_number + 1);
1870                }
1871              paranoid_fclose(fin);
1872            }
1873    }
1874      else
1875        {
1876          res = read_file_from_stream_to_stream( bkpinfo, pout, slice_siz );
1877        }
1878      retval += res;
1879      res = read_header_block_from_stream( &slice_siz, tmp, &ctrl_chr );
1880      if (ctrl_chr != BLK_STOP_AN_AFIO_OR_SLICE)
1881    {
1882      wrong_marker(BLK_STOP_AN_AFIO_OR_SLICE, ctrl_chr);
1883    }
1884      current_slice_number++;
1885      g_current_progress++;
1886    }
1887  paranoid_pclose(pout);
1888 
1889  log_msg(1, "pathname_of_last_file_restored is now %s", pathname_of_last_file_restored);
1890
1891  if (use_partimage_hack)
1892    {
1893      log_msg(3, "Waiting for partimage to finish");
1894      sprintf(tmp, " ps ax | grep \" partimagehack \" | grep -v grep > /dev/null 2> /dev/null");
1895      while(system(tmp) == 0)
1896        { sleep(1); }
1897      log_msg(3, "OK, partimage has really finished");
1898    }
1899
1900  log_msg(3, "biggiestruct.filename = %s", biggiestruct.filename);
1901  log_msg(3, "biggiestruct.checksum = %s", biggiestruct.checksum);
1902  if (strcmp(outfile_fname, "/dev/null"))
1903    {
1904      chmod(outfile_fname, biggiestruct.properties.st_mode);
1905      chown(outfile_fname, biggiestruct.properties.st_uid, biggiestruct.properties.st_gid);
1906      ubuf->actime = biggiestruct.properties.st_atime;
1907      ubuf->modtime= biggiestruct.properties.st_mtime;
1908      utime( outfile_fname, ubuf );
1909    }
1910
1911  paranoid_free(tmp);
1912  paranoid_free(outfile_fname);
1913  paranoid_free(command);
1914  paranoid_free(partimagehack_command);
1915  paranoid_free(sz_devfile);
1916  paranoid_free(partimagehack_fifo);
1917  g_loglevel = old_loglevel;
1918  return(retval);
1919}
1920
1921/**************************************************************************
1922 *END_RESTORE_A_BIGGIEFILE_FROM_STREAM                                    *
1923 **************************************************************************/
1924
1925
1926
1927/**
1928 * Restore @p tarball_fname from CD.
1929 * @param tarball_fname The filename of the tarball to restore (in /mnt/cdrom).
1930 * This will be used unmodified.
1931 * @param current_tarball_number The number (starting from 0) of the fileset
1932 * we're restoring now.
1933 * @param filelist The node structure containing the list of files to be
1934 * restored. If no file in the afioball is in this list, afio will still be
1935 * called, but nothing will be written.
1936 * @return 0 for success, nonzero for failure.
1937 */
1938int
1939restore_a_tarball_from_CD(char *tarball_fname,
1940              long current_tarball_number,
1941              struct s_node*filelist)
1942{
1943  int retval = 0;
1944  int res;
1945  char *p;
1946
1947  /** malloc **/
1948  char *command;
1949  char *tmp;
1950  char *filelist_name;
1951  char *filelist_subset_fname;
1952  char *executable;
1953  char *temp_log;
1954  char screen_message[100];
1955  long matches=0;
1956  bool use_star;
1957  char *xattr_fname;
1958  char *acl_fname;
1959//  char files_to_restore_this_time_fname[MAX_STR_LEN];
1960
1961  assert_string_is_neither_NULL_nor_zerolength(tarball_fname);
1962  malloc_string(command);
1963  malloc_string(tmp);
1964  malloc_string(filelist_name);
1965  malloc_string(filelist_subset_fname);
1966  malloc_string(executable);
1967  malloc_string(temp_log);
1968  malloc_string(xattr_fname);
1969  malloc_string(acl_fname);
1970 
1971  log_msg(5, "Entering");
1972  filelist_subset_fname[0] = '\0';
1973  use_star = (strstr(tarball_fname, ".star"))?TRUE:FALSE;
1974//  sprintf(files_to_restore_this_time_fname, "/tmp/ftrttf.%d.%d", (int)getpid(), (int)random());
1975  sprintf(command, "mkdir -p %s/tmp", MNT_RESTORING);
1976  run_program_and_log_output(command, 9);
1977  sprintf(temp_log, "/tmp/%d.%d", (int)(random()%32768), (int)(random()%32768));
1978 
1979  sprintf(filelist_name, MNT_CDROM"/archives/filelist.%ld",current_tarball_number);
1980  if ( length_of_file( filelist_name ) <= 2 )
1981    {
1982      log_msg(2, "There are _zero_ files in filelist '%s'", filelist_name);
1983      log_msg(2, "This is a bit silly (ask Hugo to fix mondo-makefilelist, please)");
1984      log_msg(2, "but it's non-critical. It's cosmetic. Don't worry about it.");
1985      retval=0;
1986      goto leave_sub;
1987    }
1988  if ( count_lines_in_file(filelist_name) <= 0 || length_of_file( tarball_fname ) <= 0 )
1989    {
1990      log_msg(3, "length_of_file(%s) = %ld", tarball_fname, length_of_file(tarball_fname));
1991      sprintf(tmp,"Unable to restore fileset #%ld (CD I/O error)",current_tarball_number);
1992      log_to_screen(tmp);
1993      retval=1;
1994      goto leave_sub;
1995    }
1996
1997  if (filelist)
1998    {
1999      sprintf(filelist_subset_fname, "/tmp/filelist-subset-%ld.tmp", current_tarball_number);
2000      if ((matches=save_filelist_entries_in_common
2001                (filelist_name, filelist, filelist_subset_fname, use_star))
2002                <= 0)
2003    {
2004      sprintf(tmp, "Skipping fileset %ld", current_tarball_number);
2005      log_msg(1, tmp);
2006    }
2007      else
2008        {
2009      log_msg(3, "Saved fileset %ld's subset to %s", current_tarball_number, filelist_subset_fname);
2010    }
2011      sprintf(screen_message, "Tarball #%ld --- %ld matches", current_tarball_number, matches);
2012      log_to_screen(screen_message);
2013    }
2014  else
2015    {
2016      filelist_subset_fname[0] = '\0';
2017    }
2018
2019  if (filelist == NULL || matches>0)
2020    {
2021      sprintf(xattr_fname, XATTR_LIST_FNAME_RAW_SZ, MNT_CDROM"/archives", current_tarball_number);
2022      sprintf(acl_fname, ACL_LIST_FNAME_RAW_SZ, MNT_CDROM"/archives", current_tarball_number);
2023      if ( strstr( tarball_fname, ".bz2" ) )
2024        {
2025          strcpy(executable,"bzip2");
2026        }
2027      else if ( strstr( tarball_fname, ".lzo") )
2028        {
2029          strcpy( executable,"lzop");
2030        }
2031      else
2032        {
2033          executable[0] = '\0';
2034        }
2035      if (executable[0])
2036        {
2037          sprintf( tmp, "which %s > /dev/null 2> /dev/null", executable );
2038          if ( run_program_and_log_output( tmp, FALSE ) )
2039            {
2040             log_to_screen("(compare_a_tarball) Compression program not found - oh no!");
2041             paranoid_MR_finish(1);
2042            }
2043          strcpy(tmp, executable);
2044          sprintf(executable, "-P %s -Z", tmp);
2045        }
2046#ifdef __FreeBSD__
2047#define BUFSIZE 512
2048#else
2049#define BUFSIZE (1024L*1024L)/TAPE_BLOCK_SIZE
2050#endif
2051
2052//      if (strstr(tarball_fname, ".star."))
2053      if (use_star)
2054        {
2055      sprintf( command, "star -x -force-remove -U " STAR_ACL_SZ " errctl= file=%s", tarball_fname);
2056      if (strstr (tarball_fname, ".bz2"))
2057        { strcat( command, " -bz"); }
2058    }
2059      else
2060        {
2061      if ( filelist_subset_fname[0] != '\0' )
2062            {
2063              sprintf( command,
2064           "afio -i -M 8m -b %ld -c %ld %s -w %s %s",
2065           TAPE_BLOCK_SIZE,
2066           BUFSIZE,
2067           executable,
2068           filelist_subset_fname,
2069//             files_to_restore_this_time_fname,
2070           tarball_fname);
2071        }
2072          else
2073            {
2074              sprintf( command,
2075           "afio -i -b %ld -c %ld -M 8m %s %s",
2076           TAPE_BLOCK_SIZE,
2077           BUFSIZE,
2078           executable,
2079           tarball_fname);
2080            }
2081    }
2082#undef BUFSIZE
2083      sprintf(command+strlen(command), " 2>> %s >> %s", temp_log, temp_log);
2084      log_msg(1,"command = '%s'", command);
2085      unlink(temp_log);
2086      res = system(command);
2087      if (res)
2088        {
2089      p = strstr(command, "-acl ");
2090      if (p)
2091        {
2092          p[0]=p[1]=p[2]=p[3]=' ';
2093              log_msg(1,"new command = '%s'", command);
2094              res = system(command);
2095        }
2096        }
2097      if (res && length_of_file(temp_log)<5) { res=0; }
2098     
2099      log_msg(1, "Setting fattr list %s", xattr_fname);
2100      if (length_of_file(xattr_fname)>0)
2101        {
2102          res=set_fattr_list(filelist_subset_fname, xattr_fname);
2103          if (res) { log_to_screen("Errors occurred while setting extended attributes"); }
2104          else { log_msg(1, "I set xattr OK"); }
2105          retval += res;
2106        }
2107      if (length_of_file(acl_fname)>0)
2108        {
2109          log_msg(1, "Setting acl list %s", acl_fname);
2110          res=set_acl_list(filelist_subset_fname, acl_fname);
2111          if (res) { log_to_screen("Errors occurred while setting access control lists"); }
2112          else { log_msg(1, "I set ACL OK"); }
2113          retval += res;
2114        }
2115      if ( retval )
2116        {
2117          sprintf(command, "cat %s >> %s", temp_log, MONDO_LOGFILE);
2118          system(command);
2119          log_msg(2, "Errors occurred while processing fileset #%d",current_tarball_number);
2120        }
2121      else
2122        {
2123          log_msg(2, "Fileset #%d processed OK", current_tarball_number);
2124        }
2125    }
2126  if (does_file_exist("/PAUSE"))
2127    { popup_and_OK("Press ENTER to go on. Delete /PAUSE to stop these pauses."); }
2128  unlink(filelist_subset_fname);
2129  unlink(xattr_fname);
2130  unlink(acl_fname);
2131  unlink(temp_log);
2132 
2133leave_sub:
2134  paranoid_free(command); paranoid_free(tmp);
2135  paranoid_free(filelist_name); paranoid_free(filelist_subset_fname);
2136  paranoid_free(executable); paranoid_free(temp_log);
2137  paranoid_free(xattr_fname); paranoid_free(acl_fname);
2138  log_msg(5, "Leaving");
2139  return(retval);
2140}
2141
2142/**************************************************************************
2143 *END_RESTORE_A_TARBALL_FROM_CD                                           *
2144 **************************************************************************/
2145
2146
2147/**
2148 * Restore a tarball from the currently opened stream.
2149 * @param bkpinfo The backup information structure. Fields used:
2150 * - @c bkpinfo->backup_media_type
2151 * - @c bkpinfo->media_device
2152 * - @c bkpinfo->zip_exe
2153 * @param tarball_fname The filename of the afioball to restore.
2154 * @param current_tarball_number The number (starting from 0) of the fileset
2155 * we're restoring now.
2156 * @param filelist The node structure containing the list of files to be
2157 * restored. If no file in the afioball is in this list, afio will still be
2158 * called, but nothing will be written.
2159 * @param size The size (in @b bytes) of the afioball.
2160 * @return 0 for success, nonzero for failure.
2161 */
2162int
2163restore_a_tarball_from_stream(struct s_bkpinfo *bkpinfo,
2164                  char *tarball_fname,
2165                  long current_tarball_number,
2166                  struct s_node*filelist,
2167                  long long size, char*xattr_fname, char*acl_fname)
2168{
2169  int retval = 0;
2170  int res = 0;
2171
2172  /** malloc add ***/
2173  char *tmp;
2174  char *command;
2175  char *afio_fname;
2176  char *filelist_fname;
2177  char *filelist_subset_fname;
2178  char *executable;
2179  long matches=0;
2180  bool restore_this_fileset = FALSE;
2181  bool use_star;
2182 
2183  assert(bkpinfo!=NULL);
2184  assert_string_is_neither_NULL_nor_zerolength(tarball_fname);
2185  malloc_string(filelist_subset_fname);
2186  malloc_string(filelist_fname);
2187  malloc_string(afio_fname);
2188  malloc_string(executable);
2189  malloc_string(command);
2190  malloc_string(tmp);
2191  filelist_subset_fname[0] = '\0';
2192  /* to do it with a file... */
2193  use_star = (strstr(tarball_fname, ".star"))?TRUE:FALSE;
2194  sprintf( tmp,
2195       "Restoring from fileset #%ld (%ld KB) on %s #%d",current_tarball_number,
2196       (long) size>>10,
2197       media_descriptor_string(bkpinfo->backup_media_type),
2198       g_current_media_number );
2199  log_msg(2, tmp );
2200  run_program_and_log_output( "mkdir -p " MNT_RESTORING "/tmp", FALSE );
2201
2202  /****************************************************************************
2203   * Use RAMDISK's /tmp; saves time; oh wait, it's too small                  *
2204   * Well, pipe from tape to afio, then; oh wait, can't do that either: bug   *
2205   * in afio or someting; oh darn.. OK, use tmpfs :-)                         *
2206   ****************************************************************************/
2207  filelist_fname[0] = filelist_subset_fname[0] = '\0';
2208  sprintf(afio_fname, "/tmp/tmpfs/archive.tmp.%ld", current_tarball_number);
2209  sprintf(filelist_fname, "%s/filelist.%ld", bkpinfo->tmpdir, current_tarball_number);
2210  sprintf(filelist_subset_fname, "%s/filelist-subset-%ld.tmp", bkpinfo->tmpdir, current_tarball_number);
2211//  sprintf(filelist_fname, "/tmp/tmpfs/temp-filelist.%ld", current_tarball_number);
2212  res = read_file_from_stream_to_file( bkpinfo, afio_fname,size );
2213  if (strstr(tarball_fname, ".star")) { bkpinfo->use_star = TRUE; }
2214  if (res) { log_msg(1, "Warning - error reading afioball from tape"); }
2215  if (bkpinfo->compression_level == 0)
2216    {
2217      executable[0] = '\0';
2218    }
2219  else
2220    {
2221      if (bkpinfo->use_star)
2222        { strcpy(executable, " -bz"); }
2223      else
2224        { sprintf(executable, "-P %s -Z", bkpinfo->zip_exe); }
2225    }
2226
2227  if (!filelist) // if unconditional restore then restore entire fileset
2228    {
2229      restore_this_fileset = TRUE;
2230    }
2231  else          // If restoring selectively then get TOC from tarball
2232    {
2233      if (strstr(tarball_fname, ".star."))
2234        {
2235      use_star = TRUE;
2236      sprintf( command, "star -t file=%s %s", afio_fname, executable);
2237    }
2238      else
2239        {
2240      use_star = FALSE;
2241          sprintf( command, "afio -t -M 8m -b %ld %s %s", TAPE_BLOCK_SIZE,
2242                        executable, afio_fname);
2243    }
2244      sprintf(command+strlen(command), " > %s 2>> %s", filelist_fname, MONDO_LOGFILE);
2245      log_msg(1, "command = %s", command);
2246      if (system(command)) { log_msg(4, "Warning - error occurred while retrieving TOC"); }
2247      if ((matches=save_filelist_entries_in_common(filelist_fname, filelist, filelist_subset_fname, use_star))
2248                     <= 0
2249                    || length_of_file(filelist_subset_fname)<2)
2250        {
2251      if (length_of_file(filelist_subset_fname)<2)
2252        { log_msg(1, "No matches found in fileset %ld", current_tarball_number); }
2253      sprintf(tmp, "Skipping fileset %ld", current_tarball_number);
2254      log_msg(2, tmp);
2255          restore_this_fileset = FALSE;
2256        }
2257      else
2258        {
2259      log_msg(5, "%ld matches. Saved fileset %ld's subset to %s", matches, current_tarball_number, filelist_subset_fname);
2260      restore_this_fileset = TRUE;
2261    }
2262    }
2263
2264// Concoct the call to star/afio to restore files
2265  if (strstr(tarball_fname, ".star.")) // star
2266    {
2267      sprintf( command, "star -x file=%s %s", afio_fname, executable);
2268      if (filelist)
2269        { sprintf(command+strlen(command), " list=%s", filelist_subset_fname); }
2270    }
2271  else                                 // afio
2272    {
2273      sprintf( command, "afio -i -M 8m -b %ld %s", TAPE_BLOCK_SIZE, executable);
2274      if (filelist)
2275        { sprintf(command+strlen(command), " -w %s", filelist_subset_fname); }
2276      sprintf(command+strlen(command), " %s", afio_fname);
2277    }
2278  sprintf( command+strlen(command), " 2>> %s", MONDO_LOGFILE);
2279
2280// Call if IF there are files to restore (selectively/unconditionally)
2281  if (restore_this_fileset)
2282    {
2283      log_msg(1, "Calling command='%s'", command);
2284      paranoid_system(command);
2285
2286      iamhere("Restoring xattr, acl stuff");
2287      res=set_fattr_list(filelist_subset_fname, xattr_fname);
2288      if (res) { log_msg(1, "Errors occurred while setting xattr"); }
2289      else { log_msg(1, "I set xattr OK"); }
2290      retval += res;
2291     
2292      res=set_acl_list(filelist_subset_fname, acl_fname);
2293      if (res) { log_msg(1, "Errors occurred while setting ACL"); }
2294      else { log_msg(1, "I set ACL OK"); }
2295      retval += res;
2296     
2297    }
2298  else
2299    {
2300      log_msg(1, "NOT CALLING '%s'", command);
2301    }
2302   
2303  if (does_file_exist("/PAUSE") && current_tarball_number >= 50)
2304    {
2305      log_to_screen("Paused after set %ld", current_tarball_number); 
2306      popup_and_OK("Pausing. Press ENTER to continue.");
2307    }
2308   
2309  unlink(filelist_subset_fname);
2310  unlink(filelist_fname);
2311  unlink(afio_fname);
2312
2313  paranoid_free(filelist_subset_fname);
2314  paranoid_free(filelist_fname);
2315  paranoid_free(afio_fname);
2316  paranoid_free(command);
2317  paranoid_free(tmp);
2318  return(retval);
2319}
2320/**************************************************************************
2321 *END_RESTORE_A_TARBALL_FROM_STREAM                                       *
2322 **************************************************************************/
2323
2324
2325
2326
2327/**
2328 * Restore all biggiefiles from all media in this CD backup.
2329 * The CD with the last afioball should be currently mounted.
2330 * @param bkpinfo The backup information structure. @c backup_media_type is the
2331 * only field used in this function.
2332 * @param filelist The node structure containing the list of files to be
2333 * restored. If a prospective biggiefile is not in this list, it will be ignored.
2334 * @return 0 for success, nonzero for failure.
2335 */
2336int
2337restore_all_biggiefiles_from_CD(struct s_bkpinfo *bkpinfo, struct s_node* filelist)
2338{
2339  int retval = 0;
2340  int res;
2341  long noof_biggiefiles, bigfileno = 0, total_slices;
2342  /** malloc **/
2343  char *tmp;
2344  bool just_changed_cds = FALSE, finished;
2345  char *xattr_fname;
2346  char *acl_fname;
2347  char *biggies_whose_EXATs_we_should_set; // EXtended ATtributes
2348  char *pathname_of_last_biggie_restored;
2349  FILE *fbw = NULL;
2350   
2351  malloc_string(xattr_fname);
2352  malloc_string(acl_fname);
2353  malloc_string(tmp);
2354  malloc_string(biggies_whose_EXATs_we_should_set);
2355  malloc_string(pathname_of_last_biggie_restored);
2356  assert(bkpinfo!=NULL);
2357
2358  sprintf(biggies_whose_EXATs_we_should_set, "%s/biggies-whose-EXATs-we-should-set", bkpinfo->tmpdir);
2359  if (!(fbw = fopen(biggies_whose_EXATs_we_should_set, "w")))
2360   { log_msg(1, "Warning - cannot openout %s", biggies_whose_EXATs_we_should_set); }
2361 
2362  read_cfg_var( g_mondo_cfg_file, "total-slices", tmp);
2363  total_slices = atol( tmp );
2364  sprintf(tmp,"Reassembling large files      ");
2365  mvaddstr_and_log_it( g_currentY, 0, tmp );
2366  if (length_of_file(BIGGIELIST) < 6)
2367    {
2368      log_msg(1, "OK, no biggielist; not restoring biggiefiles");
2369      return(0);
2370    }
2371  noof_biggiefiles = count_lines_in_file(BIGGIELIST);
2372  if ( noof_biggiefiles <= 0 )
2373    {
2374      log_msg(2, "OK, no biggiefiles in biggielist; not restoring biggiefiles");
2375      return(0);
2376    }
2377  sprintf( tmp,"OK, there are %ld biggiefiles in the archives",noof_biggiefiles);
2378  log_msg(2, tmp );
2379 
2380  open_progress_form( "Reassembling large files",
2381              "I am now reassembling all the large files." ,
2382              "Please wait. This may take some time.",
2383              "",
2384              total_slices);
2385  for( bigfileno = 0, finished = FALSE; !finished;)
2386    {
2387      log_msg( 2, "Thinking about restoring bigfile %ld", bigfileno + 1 );
2388      if ( !does_file_exist(slice_fname(bigfileno, 0, ARCHIVES_PATH, "" ) ) )
2389    {
2390      log_msg(3, "...but its first slice isn't on this CD. Perhaps this was a selective restore?");
2391          log_msg(3, "Cannot find bigfile #%ld 's first slice on %s #%d", bigfileno+1, media_descriptor_string(bkpinfo->backup_media_type), g_current_media_number);
2392          log_msg(3, "Slicename would have been %s", slice_fname(bigfileno+1,0,ARCHIVES_PATH,""));
2393      // I'm not positive 'just_changed_cds' is even necessary...
2394      if (just_changed_cds)
2395            {
2396              just_changed_cds = FALSE;
2397              log_msg(3, "I'll continue to scan this CD for bigfiles to be restored.");
2398            }
2399      else if (does_file_exist( MNT_CDROM"/archives/NOT-THE-LAST"))
2400        {
2401              insist_on_this_cd_number(bkpinfo, ++g_current_media_number);
2402          sprintf(tmp,"Restoring from %s #%d", media_descriptor_string(bkpinfo->backup_media_type), g_current_media_number);
2403          log_to_screen(tmp);
2404              just_changed_cds = TRUE;
2405        }
2406          else
2407        {
2408          log_msg(2, "There was no bigfile #%ld. That's OK." ,bigfileno+1);
2409          log_msg(2, "I'm going to stop restoring bigfiles now.");
2410          finished = TRUE;
2411        }
2412    }
2413      else
2414    {
2415          just_changed_cds = FALSE;
2416      sprintf(tmp,"Restoring big file %ld",bigfileno + 1);
2417      update_progress_form(tmp);
2418      res = restore_a_biggiefile_from_CD(bkpinfo, bigfileno, filelist, pathname_of_last_biggie_restored);
2419      iamhere(pathname_of_last_biggie_restored);
2420      if (fbw && pathname_of_last_biggie_restored[0])
2421        { fprintf(fbw, "%s\n", pathname_of_last_biggie_restored); }
2422      retval += res;
2423      bigfileno++;
2424
2425    }
2426    }
2427
2428  if (fbw)
2429    {
2430      fclose(fbw);
2431      sprintf(acl_fname, ACL_BIGGLST_FNAME_RAW_SZ, ARCHIVES_PATH);
2432      sprintf(xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, ARCHIVES_PATH);
2433      if (length_of_file(acl_fname)  >0 && find_home_of_exe("setfacl"))
2434        {
2435      set_acl_list  (biggies_whose_EXATs_we_should_set, acl_fname);
2436    }
2437      if (length_of_file(xattr_fname)>0 && find_home_of_exe("setfattr"))
2438        {
2439      set_fattr_list(biggies_whose_EXATs_we_should_set, xattr_fname);
2440    }
2441    }
2442  if (does_file_exist("/PAUSE"))
2443    { popup_and_OK("Press ENTER to go on. Delete /PAUSE to stop these pauses."); }
2444  close_progress_form();
2445  if (retval)
2446    {
2447      mvaddstr_and_log_it(g_currentY++, 74, "Errors.");
2448    }
2449  else
2450    {
2451      mvaddstr_and_log_it(g_currentY++, 74, "Done.");
2452    }
2453  paranoid_free(xattr_fname);
2454  paranoid_free(acl_fname);
2455  paranoid_free(tmp);
2456  paranoid_free(biggies_whose_EXATs_we_should_set);
2457  paranoid_free(pathname_of_last_biggie_restored);
2458  return( retval );
2459}
2460/**************************************************************************
2461 *END_RESTORE_ALL_BIGGIFILES_FROM_CD                                      *
2462 **************************************************************************/
2463
2464
2465
2466/**
2467 * Restore all afioballs from all CDs in the backup.
2468 * The first CD should be inserted (if not, it will be asked for).
2469 * @param bkpinfo The backup information structure. @c backup_media_type is the
2470 * only field used in @e this function.
2471 * @param filelist The node structure containing the list of files to be
2472 * restored. If no file in some particular afioball is in this list, afio will
2473 * still be called for that fileset, but nothing will be written.
2474 * @return 0 for success, or the number of filesets that failed.
2475 */
2476int
2477restore_all_tarballs_from_CD(struct s_bkpinfo *bkpinfo, struct s_node* filelist)
2478{
2479  int retval = 0;
2480  int res;
2481  int attempts;
2482  long current_tarball_number = 0;
2483  long max_val;
2484  /**malloc ***/
2485  char *tmp;
2486  char *tarball_fname;
2487  char *progress_str;
2488  char *comment;
2489
2490  malloc_string(tmp);
2491  malloc_string(tarball_fname);
2492  malloc_string(progress_str);
2493  malloc_string(comment);
2494 
2495  assert(bkpinfo!=NULL);
2496
2497  mvaddstr_and_log_it(g_currentY, 0, "Restoring from archives");
2498  log_msg(2, "Insisting on 1st CD, so that I can have a look at LAST-FILELIST-NUMBER");
2499  if ( g_current_media_number != 1) 
2500    { 
2501      log_msg(3, "OK, that's jacked up.");
2502      g_current_media_number = 1;
2503    }
2504  insist_on_this_cd_number( bkpinfo, g_current_media_number);
2505  read_cfg_var(g_mondo_cfg_file, "last-filelist-number", tmp);
2506  max_val = atol(tmp) + 1;
2507  sprintf(progress_str,"Restoring from %s #%d", media_descriptor_string(bkpinfo->backup_media_type), g_current_media_number);
2508  log_to_screen(progress_str);
2509  open_progress_form("Restoring from archives", 
2510             "Restoring data from the archives." , 
2511             "Please wait. This may take some time.",
2512             progress_str,max_val);
2513  for(;;)
2514    {
2515      insist_on_this_cd_number(bkpinfo, g_current_media_number);
2516      update_progress_form(progress_str);
2517      sprintf(tarball_fname, MNT_CDROM"/archives/%ld.afio.bz2",current_tarball_number);
2518      if (!does_file_exist(tarball_fname)) 
2519    {
2520      sprintf(tarball_fname, MNT_CDROM"/archives/%ld.afio.lzo",current_tarball_number);
2521    }
2522      if (!does_file_exist(tarball_fname)) 
2523    {
2524      sprintf(tarball_fname, MNT_CDROM"/archives/%ld.afio.",current_tarball_number);
2525    }
2526      if (!does_file_exist(tarball_fname))
2527    {
2528      sprintf(tarball_fname, MNT_CDROM"/archives/%ld.star.bz2", current_tarball_number);
2529    }
2530      if (!does_file_exist(tarball_fname))
2531    {
2532      sprintf(tarball_fname, MNT_CDROM"/archives/%ld.star.", current_tarball_number);
2533    }
2534      if (!does_file_exist(tarball_fname))
2535    {
2536      if (current_tarball_number == 0)
2537        {
2538          log_to_screen("No tarballs. Strange. Maybe you only backed up freakin' big files?");
2539          return(0);
2540        }
2541      if (!does_file_exist( MNT_CDROM"/archives/NOT-THE-LAST") || system("find "MNT_CDROM"/archives/slice* > /dev/null 2> /dev/null") == 0 )
2542        {
2543          break;
2544        }
2545      g_current_media_number++;
2546      sprintf(progress_str,"Restoring from %s #%d",media_descriptor_string(bkpinfo->backup_media_type), g_current_media_number);
2547      log_to_screen(progress_str);
2548    }
2549      else
2550        {
2551          sprintf(progress_str,"Restoring from fileset #%ld on %s #%d", 
2552                current_tarball_number,
2553                media_descriptor_string(bkpinfo->backup_media_type),
2554                g_current_media_number);
2555//    log_msg(3, "progress_str = %s", progress_str);
2556          for(res = 999, attempts = 0; attempts < 3 && res != 0; attempts++)
2557            {
2558          res = restore_a_tarball_from_CD(tarball_fname,current_tarball_number, filelist);
2559        }
2560          sprintf(tmp,"%s #%d, fileset #%ld - restore ",
2561        media_descriptor_string(bkpinfo->backup_media_type),
2562          g_current_media_number,
2563          current_tarball_number);
2564          if (res) 
2565        { 
2566          strcat(tmp,"reported errors");
2567        } 
2568      else if (attempts > 1) 
2569        {
2570          strcat(tmp,"succeeded"); 
2571        } 
2572      else 
2573        { 
2574          strcat(tmp,"succeeded"); 
2575        }
2576          if (attempts > 1) 
2577        { 
2578          sprintf( tmp + strlen(tmp)," (%d attempts) - review logs",attempts); 
2579        }
2580          strcpy(comment, tmp);
2581          if (attempts > 1) 
2582        {
2583          log_to_screen(comment); 
2584        }
2585         
2586          retval += res;
2587          current_tarball_number++;
2588          g_current_progress++;
2589        }
2590    }
2591  close_progress_form();
2592  if (retval)
2593    { 
2594      mvaddstr_and_log_it(g_currentY++,74,"Errors."); 
2595    }
2596  else
2597    { 
2598      mvaddstr_and_log_it(g_currentY++,74,"Done."); 
2599    }
2600  paranoid_free(tmp);
2601  paranoid_free(tarball_fname);
2602  paranoid_free(progress_str);
2603  paranoid_free(comment);
2604 
2605  return(retval);
2606}
2607
2608/**************************************************************************
2609 *END_RESTORE_ALL_TARBALLS_FROM_CD                                        *
2610 **************************************************************************/
2611
2612
2613
2614/**
2615 * Restore all biggiefiles from the currently opened stream.
2616 * @param bkpinfo The backup information structure. Passed to other functions.
2617 * @param filelist The node structure containing the list of files to be
2618 * restored. If a prospective biggiefile is not in the list, it will be ignored.
2619 * @return 0 for success, or the number of biggiefiles that failed.
2620 */
2621int
2622restore_all_biggiefiles_from_stream(struct s_bkpinfo *bkpinfo, struct s_node*filelist)
2623{
2624  long noof_biggiefiles;
2625  long current_bigfile_number = 0;
2626  long total_slices;
2627
2628  int retval = 0;
2629  int res = 0;
2630  int ctrl_chr;
2631
2632  /** malloc add ****/
2633  char *tmp;
2634  char *biggie_fname;
2635  char *biggie_cksum;
2636  char *xattr_fname;
2637  char *acl_fname;
2638  char *p;
2639  char *pathname_of_last_biggie_restored; 
2640  char *biggies_whose_EXATs_we_should_set; // EXtended ATtributes
2641  long long biggie_size;
2642  FILE *fbw = NULL;
2643
2644  malloc_string(tmp);
2645  malloc_string(biggie_fname);
2646  malloc_string(biggie_cksum);
2647  malloc_string(xattr_fname);
2648  malloc_string(acl_fname);
2649  malloc_string(biggies_whose_EXATs_we_should_set);
2650  malloc_string(pathname_of_last_biggie_restored);
2651  assert(bkpinfo!=NULL);
2652
2653  read_cfg_var(g_mondo_cfg_file, "total-slices", tmp);
2654
2655  total_slices = atol(tmp);
2656  sprintf(tmp, "Reassembling large files      ");
2657  sprintf(xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
2658  sprintf(acl_fname,   ACL_BIGGLST_FNAME_RAW_SZ,   bkpinfo->tmpdir);
2659  mvaddstr_and_log_it( g_currentY, 0, tmp );
2660  sprintf(biggies_whose_EXATs_we_should_set, "%s/biggies-whose-EXATs-we-should-set", bkpinfo->tmpdir);
2661  if (!(fbw = fopen(biggies_whose_EXATs_we_should_set, "w")))
2662   { log_msg(1, "Warning - cannot openout %s", biggies_whose_EXATs_we_should_set); }
2663 
2664// get xattr and acl files if they're there
2665  res = read_header_block_from_stream( &biggie_size, biggie_fname, &ctrl_chr);
2666  if (ctrl_chr == BLK_START_EXTENDED_ATTRIBUTES)
2667    {
2668      res = read_EXAT_files_from_tape(bkpinfo, &biggie_size, biggie_fname, &ctrl_chr, xattr_fname, acl_fname); 
2669    }
2670
2671  noof_biggiefiles = atol( biggie_fname );
2672  sprintf( tmp, "OK, there are %ld biggiefiles in the archives", noof_biggiefiles );
2673  log_msg(2, tmp );
2674  open_progress_form( "Reassembling large files", 
2675              "I am now reassembling all the large files." , 
2676              "Please wait. This may take some time.", 
2677              "", 
2678              total_slices);
2679
2680  for( res = read_header_block_from_stream( &biggie_size, biggie_fname, &ctrl_chr); ctrl_chr!=BLK_STOP_BIGGIEFILES; res=read_header_block_from_stream(&biggie_size, biggie_fname, &ctrl_chr))
2681    {
2682      if (ctrl_chr != BLK_START_A_NORMBIGGIE && ctrl_chr != BLK_START_A_PIHBIGGIE) 
2683    {
2684      wrong_marker(BLK_START_A_NORMBIGGIE,ctrl_chr);
2685    }
2686      p = strrchr(biggie_fname,'/');
2687      if (!p)
2688    {
2689      p = biggie_fname;
2690    }
2691      else
2692    {
2693      p++;
2694    }
2695      sprintf(tmp,"Restoring big file %ld (%lld K)",current_bigfile_number+1, biggie_size/1024);
2696      update_progress_form(tmp);
2697      res = restore_a_biggiefile_from_stream(bkpinfo,biggie_fname,
2698                         current_bigfile_number,
2699                         biggie_cksum,
2700                         biggie_size,
2701                         filelist, ctrl_chr,
2702                         pathname_of_last_biggie_restored);
2703      log_msg(1, "I believe I have restored %s", pathname_of_last_biggie_restored);
2704      if (fbw && pathname_of_last_biggie_restored[0])
2705        { fprintf(fbw, "%s\n", pathname_of_last_biggie_restored); }
2706      retval += res;
2707      current_bigfile_number++;
2708
2709    }
2710  if (current_bigfile_number != noof_biggiefiles && noof_biggiefiles != 0 )
2711    {
2712      sprintf( tmp,
2713           "Warning - bigfileno=%ld but noof_biggiefiles=%ld\n",current_bigfile_number,
2714           noof_biggiefiles);
2715    }
2716  else
2717    {
2718      sprintf( tmp,"%ld biggiefiles in biggielist.txt; %ld biggiefiles processed today.",
2719           noof_biggiefiles,
2720           current_bigfile_number);
2721    }
2722  log_msg(1, tmp);
2723
2724  if (fbw)
2725    {
2726      fclose(fbw);
2727      if (length_of_file(biggies_whose_EXATs_we_should_set) >2)
2728        {
2729      iamhere("Setting biggie-EXATs");
2730          if (length_of_file(acl_fname)  >0)
2731            {
2732          log_msg(1, "set_acl_list(%s,%s)", biggies_whose_EXATs_we_should_set, acl_fname);
2733          set_acl_list  (biggies_whose_EXATs_we_should_set, acl_fname);
2734        }
2735          if (length_of_file(xattr_fname)>0)
2736            {
2737          log_msg(1, "set_fattr_List(%s,%s)", biggies_whose_EXATs_we_should_set, xattr_fname);
2738          set_fattr_list(biggies_whose_EXATs_we_should_set, xattr_fname); 
2739        }
2740    }
2741      else
2742        {
2743      iamhere("No biggiefiles selected. So, no biggie-EXATs to set.");
2744    }
2745    }
2746  if (does_file_exist("/PAUSE"))
2747    { popup_and_OK("Press ENTER to go on. Delete /PAUSE to stop these pauses."); }
2748
2749  close_progress_form();
2750  if (retval)
2751    {
2752      mvaddstr_and_log_it(g_currentY++, 74, "Errors.");
2753    }
2754  else
2755    {
2756      mvaddstr_and_log_it(g_currentY++, 74, "Done.");
2757    }
2758  paranoid_free(biggies_whose_EXATs_we_should_set);
2759  paranoid_free(pathname_of_last_biggie_restored);
2760  paranoid_free(biggie_fname);
2761  paranoid_free(biggie_cksum);
2762  paranoid_free(xattr_fname);
2763  paranoid_free(acl_fname);
2764  paranoid_free(tmp);
2765  return(retval);
2766}
2767/**************************************************************************
2768 *END_RESTORE_ALL_BIGGIEFILES_FROM_STREAM                                 *
2769 **************************************************************************/
2770
2771
2772
2773
2774
2775
2776/**
2777 * Restore all afioballs from the currently opened tape stream.
2778 * @param bkpinfo The backup information structure. Fields used:
2779 * - @c bkpinfo->backup_media_type
2780 * - @c bkpinfo->restore_path
2781 * @param filelist The node structure containing the list of files to be
2782 * restored. If no file in an afioball is in this list, afio will still be
2783 * called for that fileset, but nothing will be written.
2784 * @return 0 for success, or the number of filesets that failed.
2785 */
2786int
2787restore_all_tarballs_from_stream(struct s_bkpinfo *bkpinfo, struct s_node *filelist)
2788{
2789  int retval = 0;
2790  int res;
2791  long current_afioball_number = 0;
2792  int ctrl_chr;
2793  long max_val /*, total_noof_files */;
2794
2795  /** malloc **/
2796  char *tmp;
2797  char *progress_str;
2798  char *tmp_fname;
2799  char *xattr_fname;
2800  char *acl_fname;
2801
2802  long long tmp_size;
2803
2804  malloc_string(tmp);
2805  malloc_string(progress_str);
2806  malloc_string(tmp_fname);
2807  assert(bkpinfo!=NULL);
2808  malloc_string(xattr_fname);
2809  malloc_string(acl_fname);
2810  mvaddstr_and_log_it(g_currentY, 0, "Restoring from archives");
2811  read_cfg_var(g_mondo_cfg_file, "last-filelist-number", tmp);
2812  max_val = atol(tmp) + 1;
2813
2814  chdir(bkpinfo->restore_path); /* I don't know why this is needed _here_ but it seems to be. -HR, 02/04/2002 */
2815
2816  run_program_and_log_output("pwd", 5);
2817
2818  sprintf(progress_str,"Restoring from media #%d",g_current_media_number);
2819  log_to_screen(progress_str);
2820  open_progress_form("Restoring from archives",
2821             "Restoring data from the archives." ,
2822             "Please wait. This may take some time.",
2823             progress_str,max_val);
2824
2825  log_msg(3, "hey");
2826
2827  res = read_header_block_from_stream( &tmp_size, tmp_fname, &ctrl_chr);
2828  if (res)
2829    {
2830      log_msg(2, "Warning - error reading afioball from tape");
2831    }
2832  retval += res;
2833  if ( ctrl_chr != BLK_START_AFIOBALLS)
2834    {
2835      wrong_marker(BLK_START_AFIOBALLS,ctrl_chr);
2836    }
2837  log_msg(2, "ho");
2838  res = read_header_block_from_stream(&tmp_size, tmp_fname, &ctrl_chr);
2839  while(ctrl_chr!=BLK_STOP_AFIOBALLS)
2840    {
2841      update_progress_form(progress_str);
2842      sprintf(xattr_fname, "%s/xattr-subset-%ld.tmp", bkpinfo->tmpdir, current_afioball_number);
2843      sprintf(acl_fname, "%s/acl-subset-%ld.tmp", bkpinfo->tmpdir, current_afioball_number);
2844      unlink(xattr_fname);
2845      unlink(acl_fname);
2846      if (ctrl_chr == BLK_START_EXTENDED_ATTRIBUTES)
2847        {
2848      iamhere("Reading EXAT files from tape");
2849      res = read_EXAT_files_from_tape(bkpinfo, &tmp_size, tmp_fname, &ctrl_chr, xattr_fname, acl_fname);
2850        }
2851      if (ctrl_chr != BLK_START_AN_AFIO_OR_SLICE)
2852        { wrong_marker(BLK_START_AN_AFIO_OR_SLICE, ctrl_chr); }
2853      sprintf(tmp,
2854          "Restoring from fileset #%ld (name=%s, size=%ld K)",
2855          current_afioball_number,
2856          tmp_fname,
2857          (long) tmp_size>>10);
2858      res = restore_a_tarball_from_stream(bkpinfo,tmp_fname,current_afioball_number,filelist,tmp_size, xattr_fname, acl_fname);
2859      retval += res;
2860      if ( res )
2861        {
2862      sprintf(tmp,"Fileset %ld - errors occurred",current_afioball_number);
2863      log_to_screen(tmp);
2864    }
2865      res = read_header_block_from_stream(&tmp_size, tmp_fname, &ctrl_chr);
2866      if (ctrl_chr != BLK_STOP_AN_AFIO_OR_SLICE)
2867    {
2868      wrong_marker(BLK_STOP_AN_AFIO_OR_SLICE,ctrl_chr);
2869    }
2870
2871      current_afioball_number++;
2872      g_current_progress++;
2873      sprintf(progress_str,"Restoring from fileset #%ld on %s #%d",current_afioball_number, media_descriptor_string(bkpinfo->backup_media_type), g_current_media_number);     
2874      res=read_header_block_from_stream(&tmp_size, tmp_fname, &ctrl_chr);
2875      unlink(xattr_fname);
2876      unlink(acl_fname);
2877    } // next
2878  log_msg(1, "All done with afioballs");
2879  close_progress_form();
2880  if (retval)
2881    { 
2882      mvaddstr_and_log_it(g_currentY++,74,"Errors."); }
2883  else
2884    { 
2885      mvaddstr_and_log_it(g_currentY++,74,"Done."); }
2886  paranoid_free(tmp);
2887  paranoid_free(progress_str);
2888  paranoid_free(tmp_fname);
2889  paranoid_free(xattr_fname);
2890  paranoid_free(acl_fname);
2891  return(retval);
2892}
2893/**************************************************************************
2894 *END_ RESTORE_ALL_TARBALLS_FROM_STREAM                                   *
2895 **************************************************************************/
2896
2897/* @} - end of LLrestoreGroup */
2898
2899
2900/**
2901 * Restore all files in @p filelist.
2902 * @param bkpinfo The backup information structure. Most fields are used.
2903 * @param filelist The node structure containing the list of files to be
2904 * restored.
2905 * @return 0 for success, or the number of afioballs and biggiefiles that failed.
2906 * @ingroup restoreGroup
2907 */
2908int
2909restore_everything(struct s_bkpinfo*bkpinfo,
2910           struct s_node *filelist)
2911{
2912  int resA;
2913  int resB;
2914
2915  /** mallco ***/
2916  char *cwd;
2917  char *newpath;
2918  char *tmp;
2919  assert(bkpinfo!=NULL);
2920
2921  malloc_string(cwd);
2922  malloc_string(newpath);
2923  malloc_string(tmp);
2924  log_msg(2, "restore_everything() --- starting");
2925  g_current_media_number = 1;
2926  getcwd(cwd, MAX_STR_LEN - 1);
2927  sprintf(tmp, "mkdir -p %s", bkpinfo->restore_path);
2928  run_program_and_log_output(tmp, FALSE);
2929  log_msg(1, "Changing dir to %s", bkpinfo->restore_path);
2930  chdir(bkpinfo->restore_path);
2931  getcwd(newpath,MAX_STR_LEN-1);
2932  log_msg(1, "path is now %s", newpath);
2933  log_msg(1, "restoring everything");
2934  if (!find_home_of_exe("petris") && !g_text_mode)
2935    {
2936      newtDrawRootText(0, g_noof_rows-2, "Press ALT-<left cursor> twice to play Petris :-) ");
2937      newtRefresh();
2938    }
2939  mvaddstr_and_log_it (g_currentY, 0, "Preparing to read your archives");
2940  if ( IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type ) )
2941    {
2942      mount_cdrom( bkpinfo );
2943      mvaddstr_and_log_it ( g_currentY++, 0, "Restoring OS and data from streaming media");
2944      if (bkpinfo->backup_media_type == cdstream)
2945        {
2946      openin_cdstream( bkpinfo );
2947    }
2948      else
2949        {
2950      assert_string_is_neither_NULL_nor_zerolength(bkpinfo->media_device);
2951      openin_tape(bkpinfo);
2952    }
2953      resA = restore_all_tarballs_from_stream(bkpinfo, filelist);
2954      resB = restore_all_biggiefiles_from_stream(bkpinfo, filelist);
2955      if (bkpinfo->backup_media_type == cdstream)
2956        {
2957      closein_cdstream(bkpinfo);
2958    }
2959      else
2960        {
2961      closein_tape(bkpinfo);
2962    }
2963    }
2964  else
2965    {
2966      mvaddstr_and_log_it (g_currentY++, 0, "Restoring OS and data from CD       ");
2967      mount_cdrom(bkpinfo);
2968      resA = restore_all_tarballs_from_CD(bkpinfo, filelist);
2969      resB = restore_all_biggiefiles_from_CD(bkpinfo, filelist);
2970    }
2971  chdir(cwd);
2972  if ( resA + resB )
2973    {
2974      log_to_screen("Errors occurred while data was being restored.");
2975    }
2976  if ( length_of_file("/etc/raidtab") > 0 )
2977    {
2978      log_msg(2, "Copying local raidtab to restored filesystem");
2979      run_program_and_log_output("cp -f /etc/raidtab " MNT_RESTORING "/etc/raidtab", FALSE);
2980    }
2981  kill_petris();
2982  log_msg(2, "restore_everything() --- leaving");
2983  paranoid_free(cwd);
2984  paranoid_free(newpath);
2985  paranoid_free(tmp);
2986  return(resA+resB);
2987}
2988
2989/**************************************************************************
2990 *END_RESTORE_EVERYTHING                                                  *
2991 **************************************************************************/
2992
2993
2994
2995/**
2996 * @brief Haha. You wish! (This function is not implemented :-)
2997 */
2998int
2999restore_live_from_monitas_server(struct s_bkpinfo *bkpinfo, 
3000                 char *monitas_device,
3001                 char *restore_this_directory, 
3002                 char *restore_here)
3003     /* NB: bkpinfo hasn't been populated yet, except for ->tmp which is "/tmp" */
3004{
3005  FILE *fout;
3006  int retval = 0;
3007  int i;
3008  int j;
3009  struct mountlist_itself the_mountlist;
3010  static struct raidlist_itself the_raidlist;
3011  /** malloc **/
3012  char tmp[ MAX_STR_LEN + 1 ];
3013  char command[ MAX_STR_LEN + 1 ];
3014  char datablock[ 256 * 1024 ];
3015  char datadisks_fname[ MAX_STR_LEN + 1 ];
3016  long k;
3017  long length;
3018  long long llt;
3019  struct s_node *filelist = NULL;
3020  assert(bkpinfo!=NULL);
3021  assert_string_is_neither_NULL_nor_zerolength(monitas_device);
3022  assert(restore_this_directory != NULL);
3023  assert(restore_here != NULL);
3024
3025  sprintf(tmp, "restore_here = '%s'", restore_here);
3026
3027  log_msg(2, tmp);
3028 
3029  log_msg(2, "restore_live_from_monitas_server() - starting");
3030  unlink("/tmp/mountlist.txt"); unlink("/tmp/filelist.full");
3031  unlink("/tmp/biggielist.txt");
3032  if ( restore_here[0] == '\0' )
3033    {
3034      strcpy(bkpinfo->restore_path, MNT_RESTORING); 
3035    }
3036  else
3037    { 
3038      strcpy(bkpinfo->restore_path, restore_here); 
3039    }
3040  log_msg(3, "FYI FYI FYI FYI FYI FYI FYI FYI FYI FYI FYI");
3041  sprintf(tmp, "FYI - data will be restored to %s", bkpinfo->restore_path);
3042  log_msg(3, tmp);
3043  log_msg(3, "FYI FYI FYI FYI FYI FYI FYI FYI FYI FYI FYI");
3044  sprintf(datadisks_fname, "/tmp/mondorestore.datadisks.%d", (int)(random()%32768));
3045  chdir(bkpinfo->tmpdir);
3046
3047  sprintf(command, "cat %s", monitas_device);
3048  g_tape_stream=popen(command, "r"); // for compatibility with openin_tape()
3049  if (!(fout = fopen(datadisks_fname, "w"))) { log_OS_error(datadisks_fname); return(1); }
3050  for (i = 0; i < 32; i++)
3051    {
3052      for (j = 0; j < 4; j++)
3053        {
3054          for( length = k = 0; length < 256 * 1024; length += k)
3055            {
3056              k = fread( datablock + length, 1, 256 * 1024 - length, g_tape_stream);
3057            }
3058          fwrite (datablock, 1, length, fout);
3059          g_tape_posK += length;
3060        }
3061    }
3062  paranoid_fclose(fout);
3063  sprintf( command,
3064       "tar -zxvf %s tmp/mondo-restore.cfg tmp/mountlist.txt tmp/filelist.full tmp/biggielist.txt",
3065       datadisks_fname);
3066  run_program_and_log_output(command, 4);
3067  read_header_block_from_stream (&llt, tmp, &i);
3068  read_header_block_from_stream (&llt, tmp, &i);
3069
3070  unlink(datadisks_fname);
3071  read_cfg_file_into_bkpinfo(g_mondo_cfg_file, bkpinfo);
3072  retval = load_mountlist( &the_mountlist, g_mountlist_fname); // in case read_cfg_file_into_bkpinfo   strcpy(bkpinfo->media_device, monitas_device);
3073 
3074
3075  load_raidtab_into_raidlist(&the_raidlist, RAIDTAB_FNAME );
3076  iamhere("FIXME");
3077  fatal_error("This will fail");
3078  sprintf( command,
3079       "cat %s | grep -x \"%s.*\" > %s",
3080       g_filelist_full,
3081       restore_this_directory,
3082       g_filelist_full);
3083  if (system(command))
3084    {
3085      retval++;
3086      log_to_screen("Error(s) occurred while processing filelist and wildcard");
3087    }
3088  iamhere("FIXME");
3089  fatal_error("This will fail");
3090  sprintf(command,
3091      "cat %s | grep -x \"%s.*\" > %s",
3092      g_biggielist_txt,
3093      restore_this_directory,
3094      g_biggielist_txt);
3095  if (system(command))
3096    {
3097      log_msg(1, "Error(s) occurred while processing biggielist and wildcard");
3098    }
3099  sprintf(command, "touch %s", g_biggielist_txt);
3100  run_program_and_log_output(command, FALSE);
3101//  filelist = load_filelist(g_filelist_restthese);  // FIXME --- this probably doesn't work because it doesn't include the biggiefiles
3102  retval += restore_everything(bkpinfo, filelist);
3103  free_filelist(filelist);
3104  log_msg(2, "--------End of restore_live_from_monitas_server--------");
3105  return(retval);
3106}
3107/**************************************************************************
3108 *END_RESTORE_LIVE_FROM_MONITAS_SERVER                                    *
3109 **************************************************************************/
3110
3111
3112
3113
3114extern void wait_until_software_raids_are_prepped(char*, int);
3115
3116
3117char which_restore_mode(void);
3118
3119
3120/**
3121 * Log a "don't panic" message to the logfile.
3122 */
3123void welcome_to_mondorestore()
3124{
3125  log_msg(0, "-------------- Mondo Restore v%s -------------", VERSION);
3126  log_msg(0, "DON'T PANIC! Mondorestore logs almost everything, so please " );
3127  log_msg(0, "don't break out in a cold sweat just because you see a few  " );
3128  log_msg(0, "error messages in the log. Read them; analyze them; see if  " );
3129  log_msg(0, "they are significant; above all, verify your backups! Please" );
3130  log_msg(0, "attach a compressed copy of this log to any e-mail you send " );
3131  log_msg(0, "to the Mondo mailing list when you are seeking technical    " );
3132  log_msg(0, "support. Without it, we can't help you.               - Hugo" );
3133  log_msg(0, "------------------------------------------------------------" );
3134  log_msg(0, "BTW, despite (or perhaps because of) the wealth of messages," );
3135  log_msg(0, "some users are inclined to stop reading this log.  If Mondo " );
3136  log_msg(0, "stopped for some reason, chances are it's detailed here.    " );
3137  log_msg(0, "More than likely there's a message at the very end of this  " );
3138  log_msg(0, "log that will tell you what is wrong.  Please read it!      " );
3139  log_msg(0, "------------------------------------------------------------");
3140}
3141
3142
3143
3144/**
3145 * Restore the user's data.
3146 * What did you think it did, anyway? :-)
3147 */
3148int
3149main(int argc, char*argv[])
3150{
3151      FILE*fin;
3152      FILE*fout;
3153  int retval = 0;
3154  int res;
3155//  int c;
3156  char *tmp;
3157
3158#ifndef VERSION
3159#define VERSION "1.7x_cvs"
3160#endif
3161
3162  struct mountlist_itself     *mountlist;
3163  struct raidlist_itself      *raidlist;
3164  struct s_bkpinfo            *bkpinfo;
3165  struct s_node *filelist;
3166  char *a, *b;
3167
3168  /**************************************************************************
3169   * hugo-                                                                  *
3170   * busy stuff here - it needs some comments -stan                           *
3171   *                                                                        *
3172   **************************************************************************/
3173  if (getuid () != 0)
3174    {
3175      fprintf (stderr, "Please run as root.\r\n");
3176      exit (127);
3177    }
3178
3179  g_loglevel = DEFAULT_MR_LOGLEVEL;
3180  malloc_string(tmp);
3181 
3182/* Configure global variables */
3183#ifdef __FreeBSD__
3184  if (strstr(call_program_and_get_last_line_of_output("cat /tmp/cmdline"), "textonly"))
3185#else
3186  if (strstr(call_program_and_get_last_line_of_output("cat /proc/cmdline"), "textonly"))
3187#endif
3188    { g_text_mode = TRUE; log_msg(1, "TEXTONLY MODE"); }
3189  else
3190    { g_text_mode = FALSE; }               // newt :-)
3191  if ( ! ( bkpinfo = g_bkpinfo_DONTUSETHIS = malloc( sizeof(struct s_bkpinfo))))
3192    { fatal_error( "Cannot malloc bkpinfo" ); }
3193  if ( ! ( mountlist = malloc (sizeof(struct mountlist_itself))))
3194    { fatal_error ("Cannot malloc mountlist" ); }
3195  if ( ! ( raidlist = malloc (sizeof(struct raidlist_itself))))
3196    { fatal_error ("Cannot malloc raidlist" ); }
3197
3198  malloc_libmondo_global_strings();
3199
3200  strcpy( g_mondo_home, call_program_and_get_last_line_of_output("which mondorestore") );
3201  sprintf(g_tmpfs_mountpt, "/tmp/tmpfs");
3202  make_hole_for_dir(g_tmpfs_mountpt);
3203  g_current_media_number = 1;        // precaution
3204
3205  run_program_and_log_output ("mkdir -p " MNT_CDROM, FALSE);
3206  run_program_and_log_output ("mkdir -p /mnt/floppy", FALSE);
3207
3208  malloc_string(tmp);
3209  malloc_string(a);
3210  malloc_string(b);
3211  setup_MR_global_filenames( bkpinfo ); // malloc() and set globals, using bkpinfo->tmpdir etc.
3212  reset_bkpinfo( bkpinfo );
3213  bkpinfo->backup_media_type = none; // in case boot disk was made for one backup type but user wants to restore from another backup type
3214  bkpinfo->restore_data = TRUE;      // Well, yeah :-)
3215  if (am_I_in_disaster_recovery_mode())
3216    { run_program_and_log_output("mount / -o remount,rw",2); } // for b0rken distros
3217  g_main_pid = getpid();
3218  srandom( (int)(time(NULL)) );
3219  register_pid( getpid(), "mondo" );
3220  set_signals(TRUE);
3221  g_kernel_version = get_kernel_version();
3222
3223  log_msg(1, "FYI - g_mountlist_fname = %s", g_mountlist_fname);
3224  if (strlen(g_mountlist_fname) < 3)
3225    { fatal_error("Serious error in malloc()'ing. Could be a bug in your glibc."); }
3226  mkdir(MNT_CDROM, 0x770);
3227 
3228/* Backup original mountlist.txt */
3229  sprintf (tmp, "%s.orig", g_mountlist_fname);
3230  if (!does_file_exist(g_mountlist_fname))
3231    {
3232      log_msg(2, "%ld: Warning - g_mountlist_fname (%s) does not exist yet", __LINE__, g_mountlist_fname);
3233    }
3234  else if ( !does_file_exist(tmp) )
3235    {
3236       sprintf(tmp, "cp -f %s %s.orig", g_mountlist_fname, g_mountlist_fname);
3237       run_program_and_log_output(tmp, FALSE);
3238    }
3239
3240/* Init directories */
3241  make_hole_for_dir(bkpinfo->tmpdir);
3242  sprintf( tmp, "mkdir -p %s", bkpinfo->tmpdir );
3243  run_program_and_log_output( tmp, FALSE );
3244  make_hole_for_dir( "/var/log");
3245  make_hole_for_dir( "/tmp/tmpfs"); /* just in case... */
3246  run_program_and_log_output( "umount "MNT_CDROM, FALSE );
3247  run_program_and_log_output( "ln -sf /var/log/mondo-archive.log /tmp/mondo-restore.log", FALSE );
3248
3249  run_program_and_log_output( "rm -Rf /tmp/tmpfs/mondo.tmp.*", FALSE);
3250
3251/* Init GUI */
3252  malloc_libmondo_global_strings();
3253  setup_newt_stuff();                       /* call newtInit and setup screen log */
3254  welcome_to_mondorestore();
3255  if ( bkpinfo->disaster_recovery )
3256    { log_msg(1, "I am in disaster recovery mode" ); }
3257  else
3258    { log_msg(1, "I am in normal, live mode" ); }
3259
3260  iamhere("what time is it");
3261
3262/* Process command-line parameters */
3263  if (argc == 2 && strcmp( argv[1], "--edit-mountlist" ) == 0 )
3264    {
3265#ifdef __FreeBSD__
3266    system ("mv -f /tmp/raidconf.txt /etc/raidtab");
3267    if (!does_file_exist ("/etc/raidtab"))
3268        system ("vinum printconfig > /etc/raidtab");
3269#endif
3270      load_raidtab_into_raidlist( raidlist, RAIDTAB_FNAME );
3271      if (!does_file_exist(g_mountlist_fname)) { strcpy(g_mountlist_fname, "/tmp/mountlist.txt"); }
3272      res = let_user_edit_the_mountlist(bkpinfo, mountlist, raidlist);
3273#ifdef __FreeBSD__
3274      system ("mv -f /etc/raidtab /tmp/raidconf.txt");
3275#endif
3276      paranoid_MR_finish(res);
3277    }
3278
3279  g_loglevel = DEFAULT_MR_LOGLEVEL;
3280  if (argc == 3 && strcmp(argv[1], "--echo-to-screen") == 0)
3281    {
3282      fout = fopen("/tmp/out.txt", "w");
3283      fput_string_one_char_at_a_time(stderr, argv[2]);
3284      finish(0);
3285    }     
3286
3287  if (argc == 3 && strcmp( argv[1], "--gendf" ) == 0 )
3288    {
3289      make_grub_install_scriptlet(argv[2]);
3290      finish(0);
3291    }
3292
3293  if (argc >= 2 && strcmp(argv[1], "--pih" ) == 0 )
3294    {
3295      if (system("mount | grep cdrom 2> /dev/null > /dev/null"))
3296        { system("mount "MNT_CDROM); }
3297      bkpinfo->compression_level = 1;
3298      g_current_media_number = 2;
3299      strcpy(bkpinfo->restore_path, "/tmp/TESTING");
3300      bkpinfo->backup_media_type = dvd;
3301        open_progress_form( "Reassembling /dev/hda1",
3302              "Shark is a bit of a silly person." ,
3303              "Please wait. This may take some time.",
3304              "",
3305              1999);
3306     system("rm -Rf /tmp/*pih*");
3307
3308      restore_a_biggiefile_from_CD(bkpinfo, 42, NULL, tmp);
3309    }
3310
3311  if (argc == 5 && strcmp( argv[1], "--common") == 0 )
3312    {
3313      g_loglevel = 6;
3314      filelist = load_filelist(argv[2]);
3315      if (!filelist) { fatal_error("Failed to load filelist"); }
3316      toggle_node_selection (filelist, FALSE);
3317      toggle_all_root_dirs_on (filelist);
3318      toggle_path_selection (filelist, "/usr/share", TRUE);
3319//      show_filelist(filelist);
3320      save_filelist(filelist, "/tmp/out.txt");
3321//      finish(0);
3322//      toggle_path_selection (filelist, "/root/stuff", TRUE);
3323      strcpy(a, argv[3]);
3324      strcpy(b, argv[4]);
3325
3326      res = save_filelist_entries_in_common(
3327                a, filelist, b, FALSE);
3328      free_filelist(filelist);
3329      printf("res = %d", res);
3330      finish(0);
3331    }
3332
3333  if (argc == 3 && strcmp( argv[1], "--popuplist" ) == 0 )
3334    {
3335      popup_changelist_from_file( argv[2] );
3336      paranoid_MR_finish(0);
3337    }
3338
3339   if (argc == 5 && strcmp( argv[1], "--copy" ) == 0 )
3340    {
3341          log_msg(1, "SCORE");
3342      g_loglevel = 10;
3343          if (strstr(argv[2], "save"))
3344        {
3345          log_msg(1, "Saving from %s to %s", argv[3], argv[4]);
3346          fin = fopen(argv[3], "r");
3347          fout = fopen(argv[4], "w");
3348          copy_from_src_to_dest(fin, fout, 'w');
3349          fclose(fin);
3350          fin = fopen(argv[3], "r");
3351          copy_from_src_to_dest(fin, fout, 'w');
3352          fclose(fout);
3353          fclose(fin);
3354        }
3355      else if (strstr(argv[2], "restore"))
3356        {
3357          fout = fopen(argv[3], "w");
3358          fin = fopen(argv[4], "r");
3359          copy_from_src_to_dest(fout, fin, 'r');
3360          fclose(fin);
3361          fin = fopen(argv[4], "r");
3362          copy_from_src_to_dest(fout, fin, 'r');
3363          fclose(fout);
3364          fclose(fin);
3365        }
3366      else
3367        { fatal_error("Unknown additional param"); }
3368      finish(0);
3369    }
3370
3371  if (argc == 3 && strcmp(argv[1], "--mdstat") == 0)
3372    {
3373      wait_until_software_raids_are_prepped(argv[2], 100);
3374      finish(0);
3375    }
3376 
3377  if (argc == 4 && strcmp(argv[1], "--mdconv") == 0)
3378    {
3379      finish(create_raidtab_from_mdstat(argv[2], argv[3]));
3380    }
3381
3382
3383  if ( argc == 2 && strcmp( argv[1],"--live-grub" ) == 0 )
3384    {
3385              retval = run_grub( FALSE, "/dev/hda" );
3386          if ( retval )
3387            {
3388              log_to_screen("Failed to write Master Boot Record");
3389            }
3390      paranoid_MR_finish(0);
3391   }
3392  if (argc == 3 && strcmp( argv[1], "--paa" ) == 0 )
3393    {
3394      g_current_media_number = atoi(argv[2]);
3395      pause_and_ask_for_cdr(5, NULL);
3396      paranoid_MR_finish(0);
3397    }
3398  else if ( !bkpinfo->disaster_recovery )
3399    { // live!
3400      if (argc!=1)
3401        {
3402      popup_and_OK("Live mode doesn't support command-line parameters yet.");
3403      paranoid_MR_finish(1);
3404//    return(1);
3405    }
3406      log_msg (1, "I am in normal, live mode.");
3407      log_msg (2, "FYI, MOUNTLIST_FNAME = %s", g_mountlist_fname);
3408      mount_boot_if_necessary();  /* for Gentoo users */
3409      log_msg (2, "Still here.");
3410      if ( argc>1 && strcmp( argv[argc-1], "--live-from-cd" ) == 0 )
3411        { g_restoring_live_from_cd = TRUE; }
3412      if ( argc == 5 && strcmp(argv[1], "--monitas-live" ) == 0 )
3413        {
3414      retval =
3415        restore_live_from_monitas_server( bkpinfo,
3416                          argv[2],
3417                          argv[3],
3418                          argv[4] );
3419    }
3420      else
3421        {
3422      log_msg(2, "Calling restore_to_live_filesystem()");
3423      retval = restore_to_live_filesystem( bkpinfo );
3424    }
3425      log_msg(2, "Still here. Yay.");
3426      if (strlen(bkpinfo->tmpdir) > 0)
3427        {
3428          sprintf( tmp, "rm -Rf %s/*", bkpinfo->tmpdir );
3429          run_program_and_log_output ( tmp, FALSE );
3430        }
3431      unmount_boot_if_necessary(); /* for Gentoo users */
3432      paranoid_MR_finish( retval );
3433    }
3434  else
3435    {
3436/* Disaster recovery mode (must be) */
3437      log_msg(1, "I must be in disaster recovery mode.");
3438      log_msg(2, "FYI, MOUNTLIST_FNAME = %s ", g_mountlist_fname );
3439      if (argc == 3 && strcmp(argv[1], "--monitas-memorex" ) == 0 )
3440        {
3441          log_to_screen( "Uh, that hasn't been implemented yet." );
3442          paranoid_MR_finish( 1 );
3443        }
3444
3445      iamhere("About to call load_mountlist and load_raidtab");
3446      strcpy( bkpinfo->restore_path, MNT_RESTORING );
3447      read_cfg_file_into_bkpinfo( g_mondo_cfg_file, bkpinfo );
3448      retval = load_mountlist( mountlist, g_mountlist_fname );
3449      retval += load_raidtab_into_raidlist( raidlist, RAIDTAB_FNAME );
3450      iamhere("Returned from calling load_mountlist and load_raidtab successfully");
3451
3452      if (argc>1 && (strcmp( argv[1], "--compare" ) == 0 || strcmp( argv[1], "--nuke" ) == 0 ))
3453        {
3454          if (bkpinfo->backup_media_type == nfs && !is_this_device_mounted(bkpinfo->nfs_mount))
3455            {
3456          log_msg(1, "Mounting nfs dir");
3457              sprintf(bkpinfo->isodir, "/tmp/isodir");
3458          run_program_and_log_output("mkdir -p /tmp/isodir", 5);
3459          sprintf(tmp, "mount %s -t nfs -o nolock /tmp/isodir", bkpinfo->nfs_mount);
3460          run_program_and_log_output(tmp, 1);
3461           }
3462        }
3463
3464     
3465      if ( retval ) 
3466        { 
3467          log_to_screen( "Warning - load_raidtab_into_raidlist returned an error" ); 
3468        }
3469   
3470
3471      log_msg(1, "Send in the clowns.");
3472
3473      if (argc == 2 && strcmp(argv[1], "--partition-only") == 0)
3474        {
3475      log_msg(0, "Partitioning only.");
3476          load_raidtab_into_raidlist( raidlist, RAIDTAB_FNAME );
3477          strcpy(g_mountlist_fname, "/tmp/mountlist.txt");
3478      load_mountlist( mountlist, g_mountlist_fname );
3479          res = partition_everything(mountlist);
3480          finish(res);
3481        }
3482
3483      if (argc == 2 && strcmp(argv[1], "--format-only") == 0)
3484        {
3485      log_msg(0, "Formatting only.");
3486          load_raidtab_into_raidlist( raidlist, RAIDTAB_FNAME );
3487          strcpy(g_mountlist_fname, "/tmp/mountlist.txt");
3488      load_mountlist( mountlist, g_mountlist_fname );
3489          res = format_everything(mountlist, FALSE);
3490          finish(res);
3491        }
3492
3493      if (argc == 2 && strcmp(argv[1], "--stop-lvm-and-raid") == 0)
3494        {
3495      log_msg(0, "Stopping LVM and RAID");
3496          load_raidtab_into_raidlist( raidlist, RAIDTAB_FNAME );
3497          strcpy(g_mountlist_fname, "/tmp/mountlist.txt");
3498      load_mountlist( mountlist, g_mountlist_fname );
3499          res = do_my_funky_lvm_stuff(TRUE, FALSE);
3500      res += stop_all_raid_devices(mountlist);
3501          finish(res);
3502        }
3503
3504      if (argc == 2 && strcmp( argv[1], "--nuke" ) == 0 )
3505        {
3506      iamhere("nuking");
3507          retval += nuke_mode( bkpinfo, mountlist, raidlist);
3508        }
3509      else if (argc == 2 && strcmp( argv[1], "--interactive" ) == 0 )
3510        {
3511      iamhere("catchall");
3512          retval += catchall_mode( bkpinfo, mountlist,raidlist );
3513        }
3514      else if (argc == 2 && strcmp( argv[1], "--compare" ) == 0 )
3515        {
3516      iamhere("compare");
3517          retval += compare_mode( bkpinfo, mountlist, raidlist );
3518        }
3519      else if (argc == 2 && strcmp( argv[1], "--iso" ) == 0 )
3520        {
3521      iamhere("iso");
3522      retval = iso_mode( bkpinfo, mountlist, raidlist, FALSE );
3523        }
3524      else if ( argc == 2 && strcmp( argv[1],"--mbr" ) == 0 )
3525        {
3526      iamhere("mbr");
3527          retval = mount_all_devices( mountlist, TRUE );
3528          if ( !retval )
3529            {
3530              retval += run_boot_loader( FALSE );
3531              retval += unmount_all_devices( mountlist );
3532            }
3533          if ( retval )
3534            {
3535              log_to_screen("Failed to write Master Boot Record");
3536            }
3537        }
3538      else if ( argc == 2 && strcmp( argv[1],"--isonuke") ==0 )
3539        { 
3540      iamhere("isonuke");
3541          retval = iso_mode( bkpinfo,
3542             mountlist,
3543             raidlist, 
3544             TRUE ); 
3545        }
3546      else if ( argc != 1 )
3547        {
3548          log_to_screen( "Invalid paremeters" );
3549          paranoid_MR_finish( 1 );
3550        }
3551      else
3552        { 
3553      iamhere("catchall (no mode specified in command-line call");
3554          retval += catchall_mode( bkpinfo, mountlist, raidlist); 
3555        }
3556    }
3557
3558  /* clean up at the end */
3559  if (retval)
3560    {
3561      if (does_file_exist("/tmp/changed.files"))
3562    { 
3563          log_to_screen( "See /tmp/changed.files for list of files that have changed." );
3564    }
3565      mvaddstr_and_log_it ( g_currentY++,
3566            0,
3567            "Run complete. Errors were reported. Please review the logfile." );
3568    }
3569  else
3570    {
3571      if (IS_THIS_A_STREAMING_BACKUP ( bkpinfo->backup_media_type ) )
3572        {
3573      mvaddstr_and_log_it( g_currentY++,
3574                   0, 
3575                   "Run complete. Please remove floppy/CD/media and reboot." ); 
3576    }
3577      else
3578    {
3579      run_program_and_log_output ( "sync", FALSE );
3580      if ( is_this_device_mounted( MNT_CDROM ) ) 
3581        { 
3582          res = run_program_and_log_output( "umount "MNT_CDROM, FALSE );
3583        }
3584      else 
3585        { 
3586          res = 0; 
3587        }
3588     
3589          if ( !bkpinfo->please_dont_eject)
3590            {
3591              res = eject_device("/dev/cdrom");
3592/*
3593              if (res)
3594        {
3595          log_to_screen( "WARNING - failed to eject CD-ROM disk" );
3596        }
3597*/
3598            }
3599      mvaddstr_and_log_it( g_currentY++,
3600                   0,
3601                   "Run complete. Please remove media and reboot." );
3602    }
3603    }
3604
3605// g_I_have_just_nuked is set true by nuke_mode() just before it returns
3606  if ( g_I_have_just_nuked || does_file_exist("/POST-NUKE-ANYWAY"))
3607    {
3608      if (!system("which post-nuke > /dev/null 2> /dev/null"))
3609        {
3610          log_msg(1, "post-nuke found; running...");
3611          if (mount_all_devices(mountlist, TRUE))
3612            {
3613              log_to_screen("Unable to re-mount partitions for post-nuke stuff");
3614            }
3615          else
3616            {
3617              log_msg(1, "Re-mounted partitions for post-nuke stuff");
3618              sprintf(tmp, "post-nuke %s %d", bkpinfo->restore_path, retval);
3619              if (!g_text_mode) { newtSuspend(); }
3620              log_msg(2, "Calling '%s'", tmp);
3621              if ((res=system(tmp))) { log_OS_error(tmp); }
3622              if (!g_text_mode) { newtResume(); }
3623//              newtCls();
3624              log_msg(1, "post-nuke returned w/ res=%d", res);
3625            }
3626          unmount_all_devices(mountlist);
3627          log_msg(1, "I've finished post-nuking.");
3628        }
3629    }
3630/* 
3631  log_to_screen("If you are REALLY in a hurry, hit Ctrl-Alt-Del now.");
3632  log_to_screen("Otherwise, please wait until the RAID disks are done.");
3633  wait_until_software_raids_are_prepped("/proc/mdstat", 100);
3634  log_to_screen("Thank you.");
3635*/ 
3636  unlink( "/tmp/mondo-run-prog.tmp" );
3637  set_signals( FALSE );
3638  sprintf( tmp, "rm -Rf %s", bkpinfo->tmpdir );
3639  run_program_and_log_output ( tmp, FALSE );
3640  log_to_screen( "Restore log copied to /tmp/mondo-restore.log on your hard disk" );
3641  sprintf( tmp, "Mondo-restore is exiting (retval=%d)                                      ",retval);
3642  log_to_screen( tmp );
3643  sprintf(tmp, "umount %s", bkpinfo->isodir);
3644  run_program_and_log_output(tmp, 5);
3645  paranoid_free(mountlist);
3646  paranoid_free(raidlist);
3647  if (am_I_in_disaster_recovery_mode())
3648    { run_program_and_log_output("mount / -o remount,rw",2); } // for b0rken distros
3649  paranoid_MR_finish( retval ); // frees global stuff plus bkpinfo
3650  free_libmondo_global_strings(); // it's fine to have this here :) really :)
3651  paranoid_free(a);
3652  paranoid_free(b);
3653  paranoid_free(tmp);
3654 
3655  unlink("/tmp/filelist.full");
3656  unlink("/tmp/filelist.full.gz");
3657
3658  exit( retval );
3659}
3660
3661/**************************************************************************
3662 *END_MAIN                                                                *
3663 **************************************************************************/
3664
3665
3666
3667
3668
3669/**************************************************************************
3670 *END_MONDO-RESTORE.C                                                     *
3671 **************************************************************************/
3672
Note: See TracBrowser for help on using the repository browser.