1 | /*************************************************************************** |
---|
2 | mondostructures.h - description |
---|
3 | ------------------- |
---|
4 | begin : Fri Apr 19 2002 |
---|
5 | copyright : (C) 2002 by Stan Benoit |
---|
6 | email : troff@nakedsoul.org |
---|
7 | cvsid : $Id: mondostructures.h 2224 2009-06-17 02:43:35Z 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 | /** |
---|
21 | * @file |
---|
22 | * The header file defining all of Mondo's structures. |
---|
23 | */ |
---|
24 | |
---|
25 | |
---|
26 | /** @def MAX_NOOF_MEDIA The maximum number of media that can be used in any one backup. */ |
---|
27 | |
---|
28 | ///* So we can override it in config.h: */ |
---|
29 | //#ifndef MAX_NOOF_MEDIA |
---|
30 | #define MAX_NOOF_MEDIA 50 |
---|
31 | //#endif |
---|
32 | |
---|
33 | /** |
---|
34 | * Structure indicating one entry in the mountlist. |
---|
35 | * There is one mountlist_line for each device we're keeping track of in the mountlist. |
---|
36 | */ |
---|
37 | struct mountlist_line { |
---|
38 | /** |
---|
39 | * The name of the device (/dev entry) for this mountlist line. Guaranteed to be unique. |
---|
40 | */ |
---|
41 | char device[64]; |
---|
42 | |
---|
43 | /** |
---|
44 | * The mountpoint for this mountlist line. Should be unique. |
---|
45 | * This can be "raid", for a RAID subdisk, or "lvm", for an LVM PV. |
---|
46 | */ |
---|
47 | char mountpoint[256]; |
---|
48 | |
---|
49 | /** |
---|
50 | * The filesystem type of this entry. Examples: ext2, ext3, reiserfs, xfs, swap. |
---|
51 | * Also, this can be "raid", for a RAID subdisk, or "lvm", for an LVM PV. |
---|
52 | */ |
---|
53 | char format[64]; |
---|
54 | |
---|
55 | /** |
---|
56 | * The size in kilobytes of this device. 0 or -1 indicates LVM. |
---|
57 | */ |
---|
58 | long long size; |
---|
59 | |
---|
60 | /** |
---|
61 | * For ext2 and ext3, this is the filesystem label or uuid (if there is one). If not, this should be "". |
---|
62 | */ |
---|
63 | char label[256]; |
---|
64 | |
---|
65 | }; |
---|
66 | |
---|
67 | /** |
---|
68 | * The mountlist structure. |
---|
69 | * This is used to keep track of a list of all the devices/partitions/formats/sizes/labels in the |
---|
70 | * system, so we can recreate them in a nuke restore. |
---|
71 | */ |
---|
72 | struct mountlist_itself { |
---|
73 | /** |
---|
74 | * Number of entries in the mountlist. |
---|
75 | */ |
---|
76 | int entries; |
---|
77 | |
---|
78 | /** |
---|
79 | * The list of entries, all @p entries of them. |
---|
80 | */ |
---|
81 | struct mountlist_line el[MAX_MOUNTLIST_ENTRIES]; |
---|
82 | }; |
---|
83 | |
---|
84 | /** |
---|
85 | * A structure which holds references to elements of the mountlist. |
---|
86 | * This is used in resize_drive_proportionately_to_fit_new_drives() to |
---|
87 | * ensure accurate resizing. |
---|
88 | */ |
---|
89 | struct mountlist_reference { |
---|
90 | /** |
---|
91 | * The number of entries in the list of mountlist references. |
---|
92 | */ |
---|
93 | int entries; |
---|
94 | |
---|
95 | /** |
---|
96 | * The array of mountlist_line, allocated on demand. |
---|
97 | */ |
---|
98 | struct mountlist_line **el; |
---|
99 | }; |
---|
100 | |
---|
101 | /** |
---|
102 | * A line in @p additional_raid_variables. |
---|
103 | */ |
---|
104 | struct raid_var_line { |
---|
105 | /** |
---|
106 | * The label for this RAID variable. |
---|
107 | */ |
---|
108 | char label[64]; |
---|
109 | |
---|
110 | /** |
---|
111 | * The value for this RAID variable. |
---|
112 | */ |
---|
113 | char value[64]; |
---|
114 | }; |
---|
115 | |
---|
116 | /** |
---|
117 | * The additional RAID variables structure. |
---|
118 | * This is used to store a list of additional variables to be put in the raidtab, |
---|
119 | * to allow users to use (new) features of RAID which Mondo doesn't (yet) support directly. |
---|
120 | * Each @p raid_device_record has one. |
---|
121 | */ |
---|
122 | struct additional_raid_variables { |
---|
123 | /** |
---|
124 | * The number of entries in the list. |
---|
125 | */ |
---|
126 | int entries; |
---|
127 | |
---|
128 | /** |
---|
129 | * The list of entries, all @p entries of them. |
---|
130 | */ |
---|
131 | struct raid_var_line el[MAXIMUM_ADDITIONAL_RAID_VARS]; |
---|
132 | }; |
---|
133 | |
---|
134 | /** |
---|
135 | * One disk in a @p list_of_disks. |
---|
136 | */ |
---|
137 | struct s_disk { |
---|
138 | #ifdef __FreeBSD__ |
---|
139 | /** |
---|
140 | * The name of this disk. If blank it will eventually get filled in automatically. |
---|
141 | */ |
---|
142 | char name[64]; |
---|
143 | #endif |
---|
144 | /** |
---|
145 | * The device this entry describes. |
---|
146 | */ |
---|
147 | char device[64]; |
---|
148 | |
---|
149 | /** |
---|
150 | * Index number of this entry in the whole disklist. |
---|
151 | */ |
---|
152 | int index; |
---|
153 | |
---|
154 | /** |
---|
155 | * Type of disk. |
---|
156 | */ |
---|
157 | char type; // ' ' = data (default), S = spare, F = faulty |
---|
158 | |
---|
159 | }; |
---|
160 | |
---|
161 | /** |
---|
162 | * A list of @p s_disk. Every @p raid_device_record has four. |
---|
163 | */ |
---|
164 | struct list_of_disks { |
---|
165 | /** |
---|
166 | * The number of entries in the disklist. |
---|
167 | */ |
---|
168 | int entries; |
---|
169 | |
---|
170 | /** |
---|
171 | * The entries themselves, all @p entries of them. |
---|
172 | */ |
---|
173 | struct s_disk el[MAXIMUM_DISKS_PER_RAID_DEV]; |
---|
174 | }; |
---|
175 | |
---|
176 | /** |
---|
177 | * A type of media we're backing up to. |
---|
178 | */ |
---|
179 | typedef enum { none = 0, ///< No type has been set yet. |
---|
180 | iso, ///< Back up to ISO images. |
---|
181 | cdr, ///< Back up to recordable CDs (do not erase them). |
---|
182 | cdrw, ///< Back up to CD-RWs and blank them first. |
---|
183 | dvd, ///< Back up to DVD+R[W] or DVD-R[W] disks. |
---|
184 | cdstream, ///< Back up to recordable CDs but treat them like a tape streamer. |
---|
185 | nfs, ///< Back up to an NFS mount on the local subnet. |
---|
186 | tape, ///< Back up to tapes. |
---|
187 | usb, ///< Back up to USB devices. |
---|
188 | udev ///< Back up to another unsupported device; just send a stream of bytes. |
---|
189 | } t_bkptype; |
---|
190 | |
---|
191 | /** |
---|
192 | * A type of file in the catalog of recent archives. |
---|
193 | */ |
---|
194 | typedef enum { other, ///< Some other kind of file. |
---|
195 | fileset, ///< An afioball (fileset), optionally compressed. |
---|
196 | biggieslice ///< A slice of a biggiefile, optionally compressed. |
---|
197 | } t_archtype; |
---|
198 | |
---|
199 | /** |
---|
200 | * A type of file in the catalog of recent archives. |
---|
201 | */ |
---|
202 | typedef enum { |
---|
203 | nuke = 0, /// Nuke mode |
---|
204 | interactive, /// Interactive mode |
---|
205 | compare, /// Compare mode |
---|
206 | mbr, /// MBR mode |
---|
207 | isoonly, /// ISO mode |
---|
208 | isonuke, /// ISO+Nuke mode |
---|
209 | } t_restore_mode; |
---|
210 | |
---|
211 | |
---|
212 | #ifdef __FreeBSD__ |
---|
213 | |
---|
214 | struct vinum_subdisk { |
---|
215 | char which_device[64]; |
---|
216 | }; |
---|
217 | |
---|
218 | struct vinum_plex { |
---|
219 | int raidlevel; |
---|
220 | int stripesize; |
---|
221 | int subdisks; |
---|
222 | struct vinum_subdisk sd[MAXIMUM_RAID_DEVS]; |
---|
223 | }; |
---|
224 | |
---|
225 | struct vinum_volume { |
---|
226 | char volname[64]; |
---|
227 | int plexes; |
---|
228 | struct vinum_plex plex[9]; |
---|
229 | }; |
---|
230 | |
---|
231 | struct raidlist_itself { |
---|
232 | int entries; |
---|
233 | struct list_of_disks spares; |
---|
234 | struct list_of_disks disks; |
---|
235 | struct vinum_volume el[MAXIMUM_RAID_DEVS]; |
---|
236 | }; |
---|
237 | |
---|
238 | #else |
---|
239 | |
---|
240 | /** |
---|
241 | * A RAID device in the raidlist. |
---|
242 | */ |
---|
243 | struct raid_device_record { |
---|
244 | /** |
---|
245 | * The name of the RAID device (e.g. /dev/md0). |
---|
246 | */ |
---|
247 | char raid_device[64]; |
---|
248 | |
---|
249 | /** |
---|
250 | * The RAID level (-1 to 5) we're using. |
---|
251 | */ |
---|
252 | int raid_level; |
---|
253 | |
---|
254 | /** |
---|
255 | * Whether the disk has a persistent superblock. |
---|
256 | */ |
---|
257 | int persistent_superblock; |
---|
258 | |
---|
259 | /** |
---|
260 | * The chunk size of this RAID device. |
---|
261 | */ |
---|
262 | int chunk_size; |
---|
263 | |
---|
264 | /** |
---|
265 | * The parity algorithm of this RAID device. (RAID5 only) |
---|
266 | */ |
---|
267 | int parity; // 0=left-asymmetric, 1=right-asymmetric, 2=left-symmetric, 3=right-symmetric |
---|
268 | |
---|
269 | /** |
---|
270 | * A list of the disks to use for storing data. |
---|
271 | */ |
---|
272 | struct list_of_disks data_disks; |
---|
273 | |
---|
274 | /** |
---|
275 | * A list of the disks to use as "hot spares" in case one dies. |
---|
276 | */ |
---|
277 | struct list_of_disks spare_disks; |
---|
278 | |
---|
279 | /** |
---|
280 | * A list of the disks to use for storing parity information. |
---|
281 | */ |
---|
282 | struct list_of_disks parity_disks; |
---|
283 | |
---|
284 | /** |
---|
285 | * A list of the disks in this RAID device that have failed\. Rare. |
---|
286 | */ |
---|
287 | struct list_of_disks failed_disks; |
---|
288 | |
---|
289 | /** |
---|
290 | * The additional RAID variables for this device. |
---|
291 | */ |
---|
292 | struct additional_raid_variables additional_vars; |
---|
293 | |
---|
294 | /** |
---|
295 | * Resync progress for this device. |
---|
296 | */ |
---|
297 | int progress; |
---|
298 | }; |
---|
299 | |
---|
300 | /** |
---|
301 | * The list of RAID devices. |
---|
302 | * This is intended to be used along with the mountlist, and it can be |
---|
303 | * directly loaded from/saved to raidtab format. |
---|
304 | */ |
---|
305 | struct raidlist_itself { |
---|
306 | /** |
---|
307 | * The number of entries in the list. |
---|
308 | */ |
---|
309 | int entries; |
---|
310 | |
---|
311 | /** |
---|
312 | * The RAID devices in the raidlist, all @p entries of them. |
---|
313 | */ |
---|
314 | struct raid_device_record el[MAXIMUM_RAID_DEVS]; |
---|
315 | }; |
---|
316 | |
---|
317 | #endif |
---|
318 | |
---|
319 | /** |
---|
320 | * The backup information structure. |
---|
321 | * |
---|
322 | * This is the central structure to all the activity going on inside Mondo. |
---|
323 | * It is passed to almost every function that is not just a helper, even those |
---|
324 | * which only use one variable of it, because it is useful keeping all the information |
---|
325 | * together in one place. The usage of particular fields in the bkpinfo is marked in |
---|
326 | * function documentation, but it is best to fill out as many fields as apply, because |
---|
327 | * that function may in turn pass the bkpinfo to other functions which use other fields. |
---|
328 | * |
---|
329 | * To fill out the bkpinfo first call reset_bkpinfo() and pre_param_configuration(). Then set |
---|
330 | * the backup-specific parameters (see mondo/mondoarchive/mondo-cli.c-\>process_switches for |
---|
331 | * an example). After that, you should call post_param_configuration() to set some final |
---|
332 | * parameters based on those you have already set. Failure to do the last step will result in |
---|
333 | * extremely strange and hard-to-track errors in chop_filelist(), since optimal_set_size is 0. |
---|
334 | */ |
---|
335 | struct s_bkpinfo { |
---|
336 | /** |
---|
337 | * The device we're backing up to. |
---|
338 | * If backup_media_type is @b cdr, @b cdrw, or @b cdstream, this should be the SCSI node (e.g. 0,1,0). |
---|
339 | * If backup_media_type is @b dvd, @b tape, @b usb or @b udev, this should be a /dev entry. |
---|
340 | * If backup_media_type is anything else, this should be blank. |
---|
341 | */ |
---|
342 | char media_device[MAX_STR_LEN / 4]; |
---|
343 | |
---|
344 | /** |
---|
345 | * An array containing the sizes of each media in our backup set, in MB. |
---|
346 | * For example, media 1's size would be stored in media_size[1]. |
---|
347 | * Element 0 is unused. |
---|
348 | * If the size should be autodetected, make it -1 (preferable) or 0. |
---|
349 | * @bug This should probably be only one variable, not an array. |
---|
350 | */ |
---|
351 | long media_size[MAX_NOOF_MEDIA + 1]; |
---|
352 | |
---|
353 | /** |
---|
354 | * The boot loader that is installed. Available choices are: |
---|
355 | * - 'G' for GRUB |
---|
356 | * - 'L' for LILO |
---|
357 | * - 'E' for ELILO |
---|
358 | * - (FreeBSD only) 'B' for boot0 |
---|
359 | * - (FreeBSD only) 'D' for dangerously dedicated |
---|
360 | * - 'R' for Raw |
---|
361 | * - 'U' for Unknown or None |
---|
362 | * |
---|
363 | * The function which_boot_loader() can help you set this. |
---|
364 | */ |
---|
365 | char boot_loader; |
---|
366 | |
---|
367 | /** |
---|
368 | * The boot device on which @p boot_loader is installed. |
---|
369 | * This is a bit difficult to autodetect; you may want |
---|
370 | * to take truncate_to_drive_name() of where_is_root_mounted(). |
---|
371 | */ |
---|
372 | char boot_device[MAX_STR_LEN / 4]; |
---|
373 | |
---|
374 | /** |
---|
375 | * The compression program to use. Currently supported |
---|
376 | * choices are lzop and bzip2; gzip may also work. This is ignored if |
---|
377 | * compression_level is 0. |
---|
378 | */ |
---|
379 | char zip_exe[MAX_STR_LEN / 4]; |
---|
380 | |
---|
381 | /** |
---|
382 | * The extension your compression program uses. lzop uses lzo, bzip uses |
---|
383 | * bz2, gzip uses gz, etc. Do not include the dot. |
---|
384 | */ |
---|
385 | char zip_suffix[MAX_STR_LEN / 4]; |
---|
386 | |
---|
387 | /** |
---|
388 | * Devices to back up as biggiefiles. |
---|
389 | * |
---|
390 | * This is useful for backing up NTFS partitions. |
---|
391 | * @c ntfsclone is used to back up only the used sectors, so the space tradeoff is not bad. |
---|
392 | * However, several caveats apply to such a partition: |
---|
393 | * - It must not be mounted during the backup |
---|
394 | * - It must be in a format that ntfsclone knows how to handle, i.e. NTFS |
---|
395 | * - It cannot be verified during the verify or compare phase |
---|
396 | * - It may not be resized or selectively restored at restore-time (all or nothing) |
---|
397 | * |
---|
398 | * This is a useful feature, but use at your own risk. |
---|
399 | */ |
---|
400 | char image_devs[MAX_STR_LEN / 4]; |
---|
401 | |
---|
402 | /** |
---|
403 | * The compression level (1-9) to use. 0 disables compression. |
---|
404 | */ |
---|
405 | int compression_level; |
---|
406 | |
---|
407 | /** |
---|
408 | * If TRUE, then use @c lzop to compress data. |
---|
409 | * This is used mainly in estimates. The backup/restore may or may |
---|
410 | * not work if you do not set this. You should also set @p zip_exe |
---|
411 | * and @p zip_suffix. |
---|
412 | */ |
---|
413 | bool use_lzo; |
---|
414 | |
---|
415 | /** |
---|
416 | * If TRUE, then use @c gzip to compress data. |
---|
417 | * This is used mainly in estimates. The backup/restore may or may |
---|
418 | * not work if you do not set this. You should also set @p zip_exe |
---|
419 | * and @p zip_suffix. |
---|
420 | */ |
---|
421 | bool use_gzip; |
---|
422 | |
---|
423 | /** |
---|
424 | * A filename containing a list of extensions, one per line, to not |
---|
425 | * compress. If this is set to "", afio will still exclude a set of well-known |
---|
426 | * compressed files from compression, but biggiefiles that are compressed |
---|
427 | * will be recompressed again. |
---|
428 | */ |
---|
429 | char do_not_compress_these[MAX_STR_LEN / 2]; |
---|
430 | |
---|
431 | /** |
---|
432 | * If TRUE, then we should verify a backup. |
---|
433 | */ |
---|
434 | bool verify_data; |
---|
435 | |
---|
436 | /** |
---|
437 | * If TRUE, then we should back up some data. |
---|
438 | */ |
---|
439 | bool backup_data; |
---|
440 | |
---|
441 | /** |
---|
442 | * If TRUE, then we should restore some data. |
---|
443 | */ |
---|
444 | bool restore_data; |
---|
445 | |
---|
446 | |
---|
447 | /** |
---|
448 | * If TRUE, then we should backup/restore using star, not afio |
---|
449 | */ |
---|
450 | bool use_star; |
---|
451 | |
---|
452 | |
---|
453 | /** |
---|
454 | * Size of internal block reads/writes |
---|
455 | */ |
---|
456 | long internal_tape_block_size; |
---|
457 | |
---|
458 | /** |
---|
459 | * If TRUE, we're making a CD that will autonuke without confirmation when booted. |
---|
460 | */ |
---|
461 | bool disaster_recovery; |
---|
462 | |
---|
463 | /** |
---|
464 | * The directory we're backing up to. |
---|
465 | * If backup_media_type is @b iso, then this is that directory. |
---|
466 | * If backup_media_type is anything else, this is ignored. |
---|
467 | */ |
---|
468 | char isodir[MAX_STR_LEN / 4]; |
---|
469 | |
---|
470 | /** |
---|
471 | * The prefix to put in front of media number |
---|
472 | * If backup_media_type is @b iso, then this is the prefix for the filename |
---|
473 | * If backup_media_type is anything else, this is ignored. |
---|
474 | */ |
---|
475 | char prefix[MAX_STR_LEN / 4]; |
---|
476 | |
---|
477 | /** |
---|
478 | * The scratch directory to use. |
---|
479 | * This is the "stage" that the CD image is made directly from. |
---|
480 | * As such, it needs to be at least as large as the largest CD/DVD/ISO. |
---|
481 | */ |
---|
482 | char scratchdir[MAX_STR_LEN / 4]; |
---|
483 | |
---|
484 | /** |
---|
485 | * The temp directory to use. |
---|
486 | * This is where filesets are stored by the archival threads before |
---|
487 | * the main thread moves them to the scratchdir. You don't need a lot |
---|
488 | * of space here. |
---|
489 | */ |
---|
490 | char tmpdir[MAX_STR_LEN / 4]; |
---|
491 | |
---|
492 | /** |
---|
493 | * The optimal size for each fileset. This is set automatically in |
---|
494 | * post_param_configuration() based on your @p backup_media_type; you |
---|
495 | * needn't set it yourself. |
---|
496 | */ |
---|
497 | long optimal_set_size; |
---|
498 | |
---|
499 | /** |
---|
500 | * The type of media we're backing up to. |
---|
501 | */ |
---|
502 | t_bkptype backup_media_type; |
---|
503 | // bool blank_dvd_first; |
---|
504 | |
---|
505 | /** |
---|
506 | * Whether we should use a premade filelist or generate our own. |
---|
507 | * If TRUE, then we generate our own filelist from the directories in @p include_paths. |
---|
508 | * If FALSE, then we use the filelist whose name is specified in @p include_paths. |
---|
509 | */ |
---|
510 | bool make_filelist; |
---|
511 | |
---|
512 | /** |
---|
513 | * Directories to back up, or (if !make_filelist) the filelist to use. |
---|
514 | * In the former case, multiple directories should be separated by spaces. |
---|
515 | * If you do nothing, "/" will be used. |
---|
516 | */ |
---|
517 | char include_paths[MAX_STR_LEN*4]; |
---|
518 | |
---|
519 | /** |
---|
520 | * Directories to NOT back up. Ignored if make_filelist == FALSE. |
---|
521 | * Multiple directories should be separated by spaces. /tmp, /proc, |
---|
522 | * the scratchdir, and the tempdir are automatically excluded. |
---|
523 | */ |
---|
524 | char exclude_paths[MAX_STR_LEN*4]; |
---|
525 | |
---|
526 | /** |
---|
527 | * The path to restore files relative to during a restore. |
---|
528 | * This is useful if you want to extract the files (to test, for example) |
---|
529 | * without overwriting the old ones. Ignored during a backup. |
---|
530 | */ |
---|
531 | char restore_path[MAX_STR_LEN]; |
---|
532 | |
---|
533 | /** |
---|
534 | * A command to call BEFORE making an ISO image. |
---|
535 | */ |
---|
536 | char call_before_iso[MAX_STR_LEN]; |
---|
537 | |
---|
538 | /** |
---|
539 | * A command to call to make an ISO image. |
---|
540 | */ |
---|
541 | char call_make_iso[MAX_STR_LEN]; |
---|
542 | |
---|
543 | /** |
---|
544 | * A command to call to burn the ISO image. |
---|
545 | */ |
---|
546 | char call_burn_iso[MAX_STR_LEN]; |
---|
547 | |
---|
548 | /** |
---|
549 | * A command to call AFTER making an ISO image. |
---|
550 | */ |
---|
551 | char call_after_iso[MAX_STR_LEN]; |
---|
552 | |
---|
553 | /** |
---|
554 | * Path to the user's kernel, or "FAILSAFE" or "SUCKS" to use the kernel |
---|
555 | * included with Mindi. |
---|
556 | */ |
---|
557 | char kernel_path[MAX_STR_LEN]; |
---|
558 | |
---|
559 | /** |
---|
560 | * The NFS mount to back up to/restore from. |
---|
561 | * If backup_media_type is not @b nfs, this is ignored. |
---|
562 | * It must contain a colon, and the server's address should be in dotted-decimal IP |
---|
563 | * address form. (Domain names will be resolved in post_param_configuration().) |
---|
564 | */ |
---|
565 | char nfs_mount[MAX_STR_LEN]; |
---|
566 | |
---|
567 | /** |
---|
568 | * The directory, relative to the root of @p nfs_mount, to put |
---|
569 | * the backups in. |
---|
570 | */ |
---|
571 | char nfs_remote_dir[MAX_STR_LEN]; |
---|
572 | |
---|
573 | /** |
---|
574 | * The potential user to use for NFS backup |
---|
575 | */ |
---|
576 | char nfs_user[MAX_STR_LEN/4]; |
---|
577 | |
---|
578 | /** |
---|
579 | * A tarball containing a program called "usr/bin/post-nuke" that will be run |
---|
580 | * after nuking the system. If "", do not use a post-nuke tarball. |
---|
581 | */ |
---|
582 | char postnuke_tarball[MAX_STR_LEN]; |
---|
583 | |
---|
584 | /** |
---|
585 | * If TRUE, then pass cdrecord the argument "blank=fast" to wipe the CDs before |
---|
586 | * writing to them. This has no effect for DVDs. |
---|
587 | */ |
---|
588 | bool wipe_media_first; |
---|
589 | |
---|
590 | // patch by Herman Kuster |
---|
591 | /** |
---|
592 | * The differential level of this backup. Currently only 0 (full backup) and 1 |
---|
593 | * (files changed since last full backup) are supported. |
---|
594 | */ |
---|
595 | int differential; |
---|
596 | // end patch |
---|
597 | |
---|
598 | /** |
---|
599 | * If TRUE, then don't eject media when backing up or restoring. |
---|
600 | */ |
---|
601 | bool please_dont_eject; |
---|
602 | |
---|
603 | /** |
---|
604 | * The speed of the CD-R[W] drive. |
---|
605 | */ |
---|
606 | int cdrw_speed; |
---|
607 | |
---|
608 | /** |
---|
609 | * If TRUE, then cdrecord will be passed some flags to help compensate for PCs |
---|
610 | * with eccentric CD-ROM drives. If it has BurnProof technology, or is in a laptop, |
---|
611 | * it probably falls into this category. |
---|
612 | */ |
---|
613 | bool manual_cd_tray; |
---|
614 | |
---|
615 | /** |
---|
616 | * If TRUE, do not make the first CD bootable. This is dangerous but it saves a minute |
---|
617 | * or so. It is useful in testing. Use with care. |
---|
618 | */ |
---|
619 | bool nonbootable_backup; |
---|
620 | |
---|
621 | /** |
---|
622 | * If TRUE, make the bootable CD use LILO/ELILO. If FALSE, use isolinux (the default). |
---|
623 | */ |
---|
624 | bool make_cd_use_lilo; |
---|
625 | |
---|
626 | /** |
---|
627 | * If TRUE, make the the tape bootable. If FALSE, normal tape, the default |
---|
628 | */ |
---|
629 | bool use_obdr; |
---|
630 | |
---|
631 | /** |
---|
632 | * Nature of the restore |
---|
633 | */ |
---|
634 | t_restore_mode restore_mode; |
---|
635 | }; |
---|
636 | |
---|
637 | |
---|
638 | |
---|
639 | /** |
---|
640 | * A node in a directory structure. |
---|
641 | * Its internals are managed by load_filelist() et al; you only need to keep track of the top node. |
---|
642 | * @bug My understanding of this structure is horrendously incomplete. Could you please fill in the details? |
---|
643 | */ |
---|
644 | struct s_node { |
---|
645 | /** |
---|
646 | * The character this node contains. |
---|
647 | */ |
---|
648 | char ch; |
---|
649 | |
---|
650 | /** |
---|
651 | * The node to the right of this one. |
---|
652 | */ |
---|
653 | struct s_node *right; |
---|
654 | |
---|
655 | /** |
---|
656 | * The node below this one. |
---|
657 | */ |
---|
658 | struct s_node *down; |
---|
659 | |
---|
660 | /** |
---|
661 | * If TRUE, then this node is selected (for restore, for example). |
---|
662 | */ |
---|
663 | bool selected; |
---|
664 | |
---|
665 | /** |
---|
666 | * If TRUE, then we want to see the directories below this one. |
---|
667 | */ |
---|
668 | bool expanded; |
---|
669 | }; |
---|
670 | |
---|
671 | |
---|
672 | |
---|
673 | /** |
---|
674 | * A structure to wrap a FIFO device for writing to a tape/CD stream. |
---|
675 | * @bug Is this structure used (w/the move to a standalone @c buffer and all)? |
---|
676 | */ |
---|
677 | struct s_wrapfifo { |
---|
678 | /** |
---|
679 | * The device we write to or read from (a FIFO). |
---|
680 | */ |
---|
681 | char public_device[MAX_STR_LEN / 4]; |
---|
682 | |
---|
683 | /** |
---|
684 | * The actual device that data from the FIFO should be buffered and written to. |
---|
685 | */ |
---|
686 | char private_device[MAX_STR_LEN / 4]; |
---|
687 | |
---|
688 | /** |
---|
689 | * A buffer for holding data read from the FIFO. |
---|
690 | */ |
---|
691 | char internal_buffer_IN_fifo[MAX_STR_LEN / 4]; |
---|
692 | |
---|
693 | /** |
---|
694 | * A buffer for holding data to be written to the FIFO. |
---|
695 | */ |
---|
696 | char internal_buffer_OUT_fifo[MAX_STR_LEN / 4]; |
---|
697 | |
---|
698 | /** |
---|
699 | * If TRUE, then we're writing directly to the tape streamer; if FALSE, we're writing to the FIFO. |
---|
700 | */ |
---|
701 | bool writing_to_private_device; |
---|
702 | }; |
---|
703 | |
---|
704 | |
---|
705 | |
---|
706 | /** |
---|
707 | * Information about one file. |
---|
708 | * This is used as the "zeroth slice" of a biggiefile to be able to recreate |
---|
709 | * its name, mode, owner, group, mtime, atime, and to be able to verify it in Compare Mode. |
---|
710 | */ |
---|
711 | struct s_filename_and_lstat_info { |
---|
712 | /** |
---|
713 | * The filename of the file this structure is describing. |
---|
714 | */ |
---|
715 | char filename[MAX_STR_LEN]; |
---|
716 | |
---|
717 | /** |
---|
718 | * The MD5 checksum (32 hex digits) of this file. |
---|
719 | */ |
---|
720 | char checksum[64]; |
---|
721 | |
---|
722 | /** |
---|
723 | * Unused; kept for backwards compatibility. |
---|
724 | */ |
---|
725 | char for_backward_compatibility; |
---|
726 | |
---|
727 | /** |
---|
728 | * The stat buffer for this file. |
---|
729 | * Generated with a call to <tt>lstat(&(struc->properties))</tt> where @p struc |
---|
730 | * is the @p s_filename_and_lstat_info. |
---|
731 | */ |
---|
732 | struct stat properties; |
---|
733 | bool use_ntfsprog; |
---|
734 | }; |
---|
735 | |
---|
736 | |
---|
737 | /** |
---|
738 | * A file with associated severity if it differed in a verify or compare. |
---|
739 | */ |
---|
740 | struct s_filelist_entry { |
---|
741 | /** |
---|
742 | * The name of the file. |
---|
743 | */ |
---|
744 | char filename[MAX_STR_LEN]; |
---|
745 | /** |
---|
746 | * The severity if the file has changed between the backup and live filesystem. |
---|
747 | * This is on a scale from 1 to 3, 3 being the most important. File patterns which cause |
---|
748 | * a severity of 1 are: |
---|
749 | * - /etc/adjtime |
---|
750 | * - /etc/mtab |
---|
751 | * - /var/lib/slocate |
---|
752 | * - /var/lock |
---|
753 | * - /var/log |
---|
754 | * - /var/spool (except /var/spool/mail) |
---|
755 | * - /var/run |
---|
756 | * - *~ |
---|
757 | * - *.log |
---|
758 | * - *cache* |
---|
759 | * - other temporary or unimportant files |
---|
760 | * |
---|
761 | * File patterns which cause a severity of 2 are: |
---|
762 | * - /var (except /var/lock, /var/log, /var/run, /var/spool) |
---|
763 | * - /home |
---|
764 | * - /root/.* |
---|
765 | * - /var/lib (except /var/lib/slocate, /var/lib/rpm) |
---|
766 | * - /var/spool/mail |
---|
767 | * |
---|
768 | * File patterns which cause a severity of 3 are: |
---|
769 | * - /etc (except /etc/adjtime, /etc/mtab) |
---|
770 | * - /root (except /root/.*) |
---|
771 | * - /usr |
---|
772 | * - /var/lib/rpm |
---|
773 | * - Anything else not matched explicitly |
---|
774 | * |
---|
775 | * @see severity_of_difference |
---|
776 | */ |
---|
777 | int severity; |
---|
778 | }; |
---|
779 | |
---|
780 | |
---|
781 | /** |
---|
782 | * A list of @c s_filelist_entry. |
---|
783 | */ |
---|
784 | struct s_filelist { |
---|
785 | /** |
---|
786 | * The number of entries in the list. |
---|
787 | */ |
---|
788 | int entries; |
---|
789 | |
---|
790 | /** |
---|
791 | * The entries themselves, all @p entries of them. |
---|
792 | */ |
---|
793 | struct s_filelist_entry el[ARBITRARY_MAXIMUM]; |
---|
794 | }; |
---|
795 | |
---|
796 | |
---|
797 | /** |
---|
798 | * An entry in the tape catalog. |
---|
799 | */ |
---|
800 | struct s_tapecat_entry { |
---|
801 | /** |
---|
802 | * The type of archive it is (afioball, slice, or something else). |
---|
803 | */ |
---|
804 | t_archtype type; |
---|
805 | |
---|
806 | /** |
---|
807 | * The filelist number or biggiefile (not slice!) number. |
---|
808 | */ |
---|
809 | int number; |
---|
810 | |
---|
811 | /** |
---|
812 | * The slice number if it's a biggiefile. |
---|
813 | */ |
---|
814 | long aux; |
---|
815 | |
---|
816 | /** |
---|
817 | * The tape position at the point this entry was added. |
---|
818 | */ |
---|
819 | long long tape_posK; |
---|
820 | |
---|
821 | /** |
---|
822 | * The filename of the file cataloged here. |
---|
823 | */ |
---|
824 | char fname[MAX_TAPECAT_FNAME_LEN + 1]; |
---|
825 | }; |
---|
826 | |
---|
827 | |
---|
828 | /** |
---|
829 | * A tape catalog, made of a list of @p s_tapecat_entry. |
---|
830 | */ |
---|
831 | struct s_tapecatalog { |
---|
832 | /** |
---|
833 | * The number of entries in the tape catalog. |
---|
834 | */ |
---|
835 | int entries; |
---|
836 | |
---|
837 | /** |
---|
838 | * The entries themselves, all @p entries of them. |
---|
839 | */ |
---|
840 | struct s_tapecat_entry el[MAX_TAPECATALOG_ENTRIES]; |
---|
841 | }; |
---|