Move VERBOSE flags to progress callbacks
[wimlib] / src / wimlib_internal.h
1 /*
2  * wimlib_internal.h
3  *
4  * Internal header for wimlib.
5  */
6
7 /*
8  * Copyright (C) 2010 Carl Thijssen
9  * Copyright (C) 2012 Eric Biggers
10  *
11  * This file is part of wimlib, a library for working with WIM files.
12  *
13  * wimlib is free software; you can redistribute it and/or modify it under the
14  * terms of the GNU General Public License as published by the Free
15  * Software Foundation; either version 3 of the License, or (at your option)
16  * any later version.
17  *
18  * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY
19  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
20  * A PARTICULAR PURPOSE. See the GNU General Public License for more
21  * details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with wimlib; if not, see http://www.gnu.org/licenses/.
25  */
26
27 #ifndef _WIMLIB_INTERNAL_H
28 #define _WIMLIB_INTERNAL_H
29
30 #include "config.h"
31 #include "util.h"
32 #include "list.h"
33
34 #ifdef WITH_FUSE
35 #include <pthread.h>
36 #endif
37
38 struct stat;
39 struct dentry;
40 struct inode;
41
42 #include "wimlib.h"
43
44 #define WIM_MAGIC_LEN  8
45 #define WIM_GID_LEN    16
46 #define WIM_UNUSED_LEN 60
47
48
49 /* Length of the WIM header on disk. */
50 #define WIM_HEADER_DISK_SIZE (148 + WIM_UNUSED_LEN)
51
52 /* Compressed resources in the WIM are divided into separated compressed chunks
53  * of this size. */
54 #define WIM_CHUNK_SIZE 32768
55
56 /* Version of the WIM file.  There is an older version, but we don't support it
57  * yet.  The differences between the versions are undocumented. */
58 #define WIM_VERSION 0x10d00
59
60 #define WIM_INTEGRITY_OK 0
61 #define WIM_INTEGRITY_NOT_OK -1
62 #define WIM_INTEGRITY_NONEXISTENT -2
63
64 /* Metadata for a resource in a WIM file. */
65 struct resource_entry {
66         /* Size, in bytes, of the resource in the WIM file. */
67         u64 size  : 56;
68
69         /* Bitwise or of one or more of the WIM_RESHDR_FLAG_* flags. */
70         u64 flags : 8;
71
72         /* Offset, in bytes, of the resource in the WIM file. */
73         u64 offset;
74
75         /* Uncompressed size of the resource in the WIM file.  Is the same as
76          * @size if the resource is uncompressed. */
77         u64 original_size;
78 };
79
80 /* Flags for the `flags' field of the struct resource_entry structure. */
81
82 /* I haven't seen this flag used in any of the WIMs I have examined.  I assume
83  * it means that there are no references to the stream, so the space is free.
84  * However, even after deleting files from a WIM mounted with `imagex.exe
85  * /mountrw', I could not see this flag being used.  Either way, we don't
86  * actually use this flag for anything. */
87 #define WIM_RESHDR_FLAG_FREE            0x01
88
89 /* Indicates that the stream is a metadata resource for a WIM image. */
90 #define WIM_RESHDR_FLAG_METADATA        0x02
91
92 /* Indicates that the stream is compressed. */
93 #define WIM_RESHDR_FLAG_COMPRESSED      0x04
94
95 /* I haven't seen this flag used in any of the WIMs I have examined.  Perhaps it
96  * means that a stream could possibly be split among multiple split WIM parts.
97  * However, `imagex.exe /split' does not seem to create any WIMs like this.
98  * Either way, we don't actually use this flag for anything.  */
99 #define WIM_RESHDR_FLAG_SPANNED         0x08
100
101
102 /* Header at the very beginning of the WIM file. */
103 struct wim_header {
104         /* Identifies the file as WIM file. Must be exactly
105          * {'M', 'S', 'W', 'I', 'M', 0, 0, 0}  */
106         //u8  magic[WIM_MAGIC_LEN];
107
108         /* size of WIM header in bytes. */
109         //u32 hdr_size;
110
111         /* Version of the WIM file.  M$ provides no documentation about exactly
112          * what this field affects about the file format, other than the fact
113          * that more recent versions have a higher value. */
114         //u32 version;
115
116         /* Bitwise OR of one or more of the WIM_HDR_FLAG_* defined below. */
117         u32 flags;
118
119         /* The size of the pieces that the uncompressed files were split up into
120          * when they were compressed.  This should be the same as
121          * WIM_CHUNK_SIZE.  M$ incorrectly documents this as "the size of the
122          * compressed .wim file in bytes".*/
123         //u32 chunk_size;
124
125         /* A unique identifier for the WIM file. */
126         u8  guid[WIM_GID_LEN];
127
128         /* Part number of the WIM file in a spanned set. */
129         u16 part_number;
130
131         /* Total number of parts in a spanned set. */
132         u16 total_parts;
133
134         /* Number of images in the WIM file. */
135         u32 image_count;
136
137         /* Location, size, and flags of the lookup table of the WIM. */
138         struct resource_entry lookup_table_res_entry;
139
140         /* Location, size, and flags for the XML data of the WIM. */
141         struct resource_entry xml_res_entry;
142
143         /* Location, size, and flags for the boot metadata.  This means the
144          * metadata resource for the image specified by boot_idx below.  Should
145          * be zeroed out if boot_idx is 0. */
146         struct resource_entry boot_metadata_res_entry;
147
148         /* The index of the bootable image in the WIM file. If 0, there are no
149          * bootable images available. */
150         u32 boot_idx;
151
152         /* The location of the optional integrity table used to verify the
153          * integrity WIM.  Zeroed out if there is no integrity table.*/
154         struct resource_entry integrity;
155
156         /* Reserved for future disuse */
157         //u8 unused[WIM_UNUSED_LEN];
158 };
159
160 /* Flags for the `flags' field of the struct wim_header: */
161
162 /* Reserved for future use by M$ */
163 #define WIM_HDR_FLAG_RESERVED           0x00000001
164
165 /* Files and metadata in the WIM are compressed. */
166 #define WIM_HDR_FLAG_COMPRESSION        0x00000002
167
168 /* WIM is read-only (we ignore this). */
169 #define WIM_HDR_FLAG_READONLY           0x00000004
170
171 /* Resource data specified by images in this WIM may be contained in a different
172  * WIM.  Or in other words, this WIM is part of a split WIM.  */
173 #define WIM_HDR_FLAG_SPANNED            0x00000008
174
175 /* The WIM contains resources only; no filesystem metadata.  We ignore this
176  * flag, as we look for file resources in all the WIMs anyway. */
177 #define WIM_HDR_FLAG_RESOURCE_ONLY      0x00000010
178
179 /* The WIM contains metadata only.  We ignore this flag.  Note that all the
180  * metadata resources for a split WIM should be in the first part. */
181 #define WIM_HDR_FLAG_METADATA_ONLY      0x00000020
182
183 /* Lock field to prevent multiple writers from writing the WIM concurrently.  We
184  * ignore this flag. */
185 #define WIM_HDR_FLAG_WRITE_IN_PROGRESS  0x00000040
186
187 /* Reparse point fixup ???
188  * This has something to do with absolute targets of reparse points / symbolic
189  * links but I don't know what.  We ignore this flag.  */
190 #define WIM_HDR_FLAG_RP_FIX             0x00000080
191
192 /* Unused, reserved flag for another compression type */
193 #define WIM_HDR_FLAG_COMPRESS_RESERVED  0x00010000
194
195 /* Resources within the WIM are compressed using "XPRESS" compression, which is
196  * a LZ77-based compression algorithm. */
197 #define WIM_HDR_FLAG_COMPRESS_XPRESS    0x00020000
198
199 /* Resources within the WIM are compressed using "LZX" compression.  This is also
200  * a LZ77-based algorithm. */
201 #define WIM_HDR_FLAG_COMPRESS_LZX       0x00040000
202
203 #ifdef WITH_NTFS_3G
204 struct _ntfs_volume;
205 #endif
206
207 /* Structure for security data.  Each image in the WIM file has its own security
208  * data. */
209 struct wim_security_data {
210         /* The total length of the security data, in bytes.  A typical size is
211          * 2048 bytes.  If there is no security data, though (as in the WIMs
212          * that wimlib writes, currently), it will be 8 bytes. */
213         u32 total_length;
214
215         /* The number of security descriptors in the array @descriptors, below.
216          * It is really an unsigned int, but it must fit into an int because the
217          * security ID's are signed.  (Not like you would ever have more than a
218          * few hundred security descriptors anyway). */
219         int32_t num_entries;
220
221         /* Array of sizes of the descriptors in the array @descriptors. */
222         u64 *sizes;
223
224         /* Array of descriptors. */
225         u8 **descriptors;
226
227         /* keep track of how many WIMs reference this security data (used when
228          * exporting images between WIMs) */
229         u32 refcnt;
230 };
231
232 struct inode_table;
233
234
235 /* Metadata resource for an image. */
236 struct image_metadata {
237         /* Pointer to the root dentry for the image. */
238         struct dentry    *root_dentry;
239
240         /* Pointer to the security data for the image. */
241         struct wim_security_data *security_data;
242
243         /* A pointer to the lookup table entry for this image's metadata
244          * resource. */
245         struct lookup_table_entry *metadata_lte;
246
247         struct hlist_head inode_list;
248
249         /* True if the filesystem of the image has been modified.  If this is
250          * the case, the memory for the filesystem is not freed when switching
251          * to a different WIM image. */
252         u8 modified : 1;
253
254         u8 has_been_mounted_rw : 1;
255 };
256
257 #define WIMLIB_RESOURCE_FLAG_RAW                0x1
258 #define WIMLIB_RESOURCE_FLAG_MULTITHREADED      0x2
259 #define WIMLIB_RESOURCE_FLAG_RECOMPRESS         0x4
260
261 /* The opaque structure exposed to the wimlib API. */
262 typedef struct WIMStruct {
263
264         /* A pointer to the file indicated by @filename, opened for reading. */
265         FILE *fp;
266
267 #ifdef WITH_FUSE
268         /* Extra file pointers to be used by concurrent readers */
269         FILE **fp_tab;
270         size_t num_allocated_fps;
271         pthread_mutex_t fp_tab_mutex;
272 #endif
273
274         /* FILE pointer for the WIM file that is being written. */
275         FILE *out_fp;
276
277         /* The name of the WIM file that has been opened. */
278         char *filename;
279
280         /* The lookup table for the WIM file. */
281         struct lookup_table *lookup_table;
282
283         /* Pointer to the XML data read from the WIM file. */
284         u8 *xml_data;
285
286         /* Information retrieved from the XML data, arranged
287          * in an orderly manner. */
288         struct wim_info *wim_info;
289
290         /* Array of the image metadata of length image_count.  Each image in the
291          * WIM has a image metadata associated with it. */
292         struct image_metadata *image_metadata;
293
294         /* The header of the WIM file. */
295         struct wim_header hdr;
296
297         /* Temporary fields */
298         union {
299                 bool write_metadata;
300                 void *private;
301         };
302 #ifdef WITH_NTFS_3G
303         struct _ntfs_volume *ntfs_vol;
304 #endif
305
306         /* The currently selected image, indexed starting at 1.  If not 0,
307          * subtract 1 from this to get the index of the current image in the
308          * image_metadata array. */
309         int current_image;
310
311         /* %true iff any images have been deleted from this WIM. */
312         bool deletion_occurred;
313 } WIMStruct;
314
315
316 /* Inline utility functions for WIMStructs. */
317
318 static inline struct dentry *wim_root_dentry(WIMStruct *w)
319 {
320         return w->image_metadata[w->current_image - 1].root_dentry;
321 }
322
323 static inline struct wim_security_data *
324 wim_security_data(WIMStruct *w)
325 {
326         return w->image_metadata[w->current_image - 1].security_data;
327 }
328 static inline const struct wim_security_data *
329 wim_const_security_data(const WIMStruct *w)
330 {
331         return w->image_metadata[w->current_image - 1].security_data;
332 }
333
334 static inline struct lookup_table_entry*
335 wim_metadata_lookup_table_entry(WIMStruct *w)
336 {
337         return w->image_metadata[w->current_image - 1].metadata_lte;
338 }
339
340 /* Nonzero if a struct resource_entry indicates a compressed resource. */
341 static inline int resource_is_compressed(const struct resource_entry *entry)
342 {
343         return (entry->flags & WIM_RESHDR_FLAG_COMPRESSED);
344 }
345
346 static inline struct image_metadata *
347 wim_get_current_image_metadata(WIMStruct *w)
348 {
349         return &w->image_metadata[w->current_image - 1];
350 }
351
352 struct pattern_list {
353         const char **pats;
354         size_t num_pats;
355         size_t num_allocated_pats;
356 };
357
358 struct capture_config {
359         struct pattern_list exclusion_list;
360         struct pattern_list exclusion_exception;
361         struct pattern_list compression_exclusion_list;
362         struct pattern_list alignment_list;
363         char *config_str;
364         char *prefix;
365         size_t prefix_len;
366 };
367
368 /* hardlink.c */
369
370 /* Hash table to find inodes, identified by their inode ID.
371  * */
372 struct inode_table {
373         /* Fields for the hash table */
374         struct hlist_head *array;
375         u64 num_entries;
376         u64 capacity;
377
378         /*
379          * Linked list of "extra" inodes.  These may be:
380          *
381          * - inodes with link count 1, which are all allowed to have 0 for their
382          *   inode number, meaning we cannot insert them into the hash table
383          *   before calling assign_inode_numbers().
384          *
385          * - Groups we create ourselves by splitting a nominal inode due to
386          *   inconsistencies in the dentries.  These inodes will share a inode
387          *   ID with some other inode until assign_inode_numbers() is called.
388          */
389         struct hlist_head extra_inodes;
390 };
391
392 extern int init_inode_table(struct inode_table *table, size_t capacity);
393 static inline void destroy_inode_table(struct inode_table *table)
394 {
395         FREE(table->array);
396 }
397 extern int inode_table_insert(struct dentry *dentry, void *__table);
398 extern u64 assign_inode_numbers(struct hlist_head *inode_list);
399 extern int fix_inodes(struct inode_table *table, struct hlist_head *inode_list);
400
401
402 /* header.c */
403 extern int read_header(FILE *fp, struct wim_header *hdr, int split_ok);
404 extern int write_header(const struct wim_header *hdr, FILE *out);
405 extern int init_header(struct wim_header *hdr, int ctype);
406
407 /* integrity.c */
408 extern int write_integrity_table(FILE *out,
409                                  struct resource_entry *integrity_res_entry,
410                                  off_t new_lookup_table_end,
411                                  off_t old_lookup_table_end,
412                                  wimlib_progress_func_t progress_func);
413
414 extern int check_wim_integrity(WIMStruct *w,
415                                wimlib_progress_func_t progress_func);
416
417 /* join.c */
418
419 extern int new_joined_lookup_table(WIMStruct *w,
420                                    WIMStruct **additional_swms,
421                                    unsigned num_additional_swms,
422                                    struct lookup_table **table_ret);
423
424 extern int verify_swm_set(WIMStruct *w,
425                           WIMStruct **additional_swms,
426                           unsigned num_additional_swms);
427 /* modify.c */
428 extern void destroy_image_metadata(struct image_metadata *imd,
429                                    struct lookup_table *lt);
430 extern bool exclude_path(const char *path,
431                          const struct capture_config *config,
432                          bool exclude_prefix);
433 extern int do_add_image(WIMStruct *w, const char *dir, const char *name,
434                         const char *config_str, size_t config_len,
435                         int flags,
436                         int (*capture_tree)(struct dentry **, const char *,
437                                      struct lookup_table *,
438                                      struct wim_security_data *,
439                                      const struct capture_config *,
440                                      int, void *),
441                         void *extra_arg,
442                         wimlib_progress_func_t progress_func);
443
444 /* ntfs-apply.c */
445
446 struct apply_args {
447         WIMStruct *w;
448         const char *target;
449         int extract_flags;
450         unsigned num_lutimes_warnings;
451         struct list_head *stream_list;
452         union wimlib_progress_info progress;
453 #ifdef WITH_NTFS_3G
454         struct _ntfs_volume *vol;
455 #endif
456         struct list_head empty_files;
457         wimlib_progress_func_t progress_func;
458 };
459
460 extern int wim_apply_dentry_ntfs(struct dentry *dentry, void *arg);
461 extern int wim_apply_dentry_timestamps(struct dentry *dentry, void *arg);
462
463 /* ntfs-capture.c */
464 extern int build_dentry_tree_ntfs(struct dentry **root_p,
465                                   const char *device,
466                                   struct lookup_table *lookup_table,
467                                   struct wim_security_data *sd,
468                                   const struct capture_config *config,
469                                   int add_image_flags,
470                                   wimlib_progress_func_t progress_func,
471                                   void *extra_arg);
472
473 /* resource.c */
474 extern const u8 *get_resource_entry(const u8 *p, struct resource_entry *entry);
475 extern u8 *put_resource_entry(u8 *p, const struct resource_entry *entry);
476
477 extern int read_uncompressed_resource(FILE *fp, u64 offset, u64 size, u8 buf[]);
478
479 extern int read_wim_resource(const struct lookup_table_entry *lte, u8 buf[],
480                              size_t size, u64 offset, int flags);
481
482 extern int read_full_wim_resource(const struct lookup_table_entry *lte,
483                                   u8 buf[], int flags);
484
485 extern int write_wim_resource(struct lookup_table_entry *lte,
486                               FILE *out_fp, int out_ctype,
487                               struct resource_entry *out_res_entry,
488                               int flags);
489
490 extern int extract_wim_resource_to_fd(const struct lookup_table_entry *lte,
491                                       int fd, u64 size);
492
493
494 extern int extract_full_wim_resource_to_fd(const struct lookup_table_entry *lte,
495                                            int fd);
496
497 extern int read_metadata_resource(WIMStruct *w,
498                                   struct image_metadata *image_metadata);
499
500
501 extern int write_dentry_resources(struct dentry *dentry, void *wim_p);
502 extern int copy_resource(struct lookup_table_entry *lte, void *w);
503 extern int write_metadata_resource(WIMStruct *w);
504
505
506 /* security.c */
507 int read_security_data(const u8 metadata_resource[],
508                 u64 metadata_resource_len, struct wim_security_data **sd_p);
509
510 void print_security_data(const struct wim_security_data *sd);
511 u8 *write_security_data(const struct wim_security_data *sd, u8 *p);
512 void free_security_data(struct wim_security_data *sd);
513
514 /* symlink.c */
515 ssize_t inode_readlink(const struct inode *inode, char *buf, size_t buf_len,
516                         const WIMStruct *w, int read_resource_flags);
517 extern void *make_symlink_reparse_data_buf(const char *symlink_target,
518                                            size_t *len_ret);
519 extern int inode_set_symlink(struct inode *inode,
520                              const char *target,
521                              struct lookup_table *lookup_table,
522                              struct lookup_table_entry **lte_ret);
523
524 /* wim.c */
525 extern WIMStruct *new_wim_struct();
526 extern int select_wim_image(WIMStruct *w, int image);
527 extern int wim_hdr_flags_compression_type(int wim_hdr_flags);
528 extern int for_image(WIMStruct *w, int image, int (*visitor)(WIMStruct *));
529 extern int open_wim_readable(WIMStruct *w, const char *path);
530 extern int open_wim_writable(WIMStruct *w, const char *path,
531                              bool trunc, bool readable);
532
533 /* Internal use only */
534 #define WIMLIB_WRITE_FLAG_NO_LOOKUP_TABLE       0x80000000
535 #define WIMLIB_WRITE_FLAG_REUSE_INTEGRITY_TABLE 0x40000000
536 #define WIMLIB_WRITE_FLAG_CHECKPOINT_AFTER_XML  0x20000000
537 #define WIMLIB_WRITE_MASK_PUBLIC                0x1fffffff
538
539 /* Internal use only */
540 #define WIMLIB_EXTRACT_FLAG_MULTI_IMAGE         0x80000000
541 #define WIMLIB_EXTRACT_FLAG_NO_STREAMS          0x40000000
542 #define WIMLIB_EXTRACT_MASK_PUBLIC              0x3fffffff
543
544
545 /* write.c */
546 extern int begin_write(WIMStruct *w, const char *path, int write_flags);
547
548 extern int finish_write(WIMStruct *w, int image, int write_flags,
549                         wimlib_progress_func_t progress_func);
550
551 #endif /* _WIMLIB_INTERNAL_H */
552