Refactor headers
[wimlib] / src / export_image.c
1 /*
2  * export_image.c
3  */
4
5 /*
6  * Copyright (C) 2012, 2013 Eric Biggers
7  *
8  * This file is part of wimlib, a library for working with WIM files.
9  *
10  * wimlib is free software; you can redistribute it and/or modify it under the
11  * terms of the GNU General Public License as published by the Free
12  * Software Foundation; either version 3 of the License, or (at your option)
13  * any later version.
14  *
15  * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY
16  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
17  * A PARTICULAR PURPOSE. See the GNU General Public License for more
18  * details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with wimlib; if not, see http://www.gnu.org/licenses/.
22  */
23
24 #ifdef HAVE_CONFIG_H
25 #  include "config.h"
26 #endif
27
28 #include "wimlib.h"
29 #include "wimlib/dentry.h"
30 #include "wimlib/error.h"
31 #include "wimlib/lookup_table.h"
32 #include "wimlib/metadata.h"
33 #include "wimlib/swm.h"
34 #include "wimlib/xml.h"
35
36 static int
37 inode_allocate_needed_ltes(struct wim_inode *inode,
38                            struct wim_lookup_table *src_lookup_table,
39                            struct wim_lookup_table *dest_lookup_table,
40                            struct list_head *lte_list_head)
41 {
42         struct wim_lookup_table_entry *src_lte, *dest_lte;
43         unsigned i;
44
45         inode_unresolve_ltes(inode);
46         for (i = 0; i <= inode->i_num_ads; i++) {
47                 src_lte = inode_stream_lte_unresolved(inode, i,
48                                                       src_lookup_table);
49                 if (src_lte && src_lte->out_refcnt == 0) {
50                         src_lte->out_refcnt = 1;
51                         dest_lte = inode_stream_lte_unresolved(inode, i,
52                                                                dest_lookup_table);
53                         if (!dest_lte) {
54                                 dest_lte = clone_lookup_table_entry(src_lte);
55                                 if (!dest_lte)
56                                         return WIMLIB_ERR_NOMEM;
57                                 list_add_tail(&dest_lte->export_stream_list,
58                                               lte_list_head);
59                         }
60                 }
61         }
62         return 0;
63 }
64
65 static void
66 inode_move_ltes_to_table(struct wim_inode *inode,
67                          struct wim_lookup_table *src_lookup_table,
68                          struct wim_lookup_table *dest_lookup_table,
69                          struct list_head *lte_list_head)
70 {
71         struct wim_lookup_table_entry *src_lte, *dest_lte;
72         unsigned i;
73
74         for (i = 0; i <= inode->i_num_ads; i++) {
75                 src_lte = inode_stream_lte_unresolved(inode, i, src_lookup_table);
76                 if (src_lte) {
77                         dest_lte = inode_stream_lte_unresolved(inode, i,
78                                                                dest_lookup_table);
79                         if (!dest_lte) {
80                                 struct list_head *next;
81
82                                 wimlib_assert(!list_empty(lte_list_head));
83                                 next = lte_list_head->next;
84                                 list_del(next);
85                                 dest_lte = container_of(next,
86                                                         struct wim_lookup_table_entry,
87                                                         export_stream_list);
88                                 dest_lte->part_number = 1;
89                                 dest_lte->refcnt = 0;
90                                 wimlib_assert(hashes_equal(dest_lte->hash, src_lte->hash));
91                                 lookup_table_insert(dest_lookup_table, dest_lte);
92                         }
93                         dest_lte->refcnt += inode->i_nlink;
94                 }
95         }
96 }
97
98 /*
99  * Exports an image, or all the images, from a WIM file, into another WIM file.
100  */
101 WIMLIBAPI int
102 wimlib_export_image(WIMStruct *src_wim,
103                     int src_image,
104                     WIMStruct *dest_wim,
105                     const tchar *dest_name,
106                     const tchar *dest_description,
107                     int export_flags,
108                     WIMStruct **additional_swms,
109                     unsigned num_additional_swms,
110                     wimlib_progress_func_t progress_func)
111 {
112         int ret;
113         struct wim_image_metadata *src_imd;
114         struct list_head lte_list_head;
115         struct wim_inode *inode;
116
117         if (dest_wim->hdr.total_parts != 1) {
118                 ERROR("Exporting an image to a split WIM is "
119                       "unsupported");
120                 return WIMLIB_ERR_SPLIT_UNSUPPORTED;
121         }
122
123         if (src_image == WIMLIB_ALL_IMAGES) {
124                 if (src_wim->hdr.image_count > 1) {
125
126                         /* multi-image export. */
127
128                         if ((export_flags & WIMLIB_EXPORT_FLAG_BOOT) &&
129                               (src_wim->hdr.boot_idx == 0))
130                         {
131                                 /* Specifying the boot flag on a multi-image
132                                  * source WIM makes the boot index default to
133                                  * the bootable image in the source WIM.  It is
134                                  * an error if there is no such bootable image.
135                                  * */
136                                 ERROR("Cannot specify `boot' flag when "
137                                       "exporting multiple images from a WIM "
138                                       "with no bootable images");
139                                 return WIMLIB_ERR_INVALID_PARAM;
140                         }
141                         if (dest_name || dest_description) {
142                                 ERROR("Image name or image description was "
143                                       "specified, but we are exporting "
144                                       "multiple images");
145                                 return WIMLIB_ERR_INVALID_PARAM;
146                         }
147                         for (int i = 1; i <= src_wim->hdr.image_count; i++) {
148                                 int new_flags = export_flags;
149
150                                 if (i != src_wim->hdr.boot_idx)
151                                         new_flags &= ~WIMLIB_EXPORT_FLAG_BOOT;
152
153                                 ret = wimlib_export_image(src_wim, i, dest_wim,
154                                                           NULL, NULL,
155                                                           new_flags,
156                                                           additional_swms,
157                                                           num_additional_swms,
158                                                           progress_func);
159                                 if (ret)
160                                         return ret;
161                         }
162                         return 0;
163                 } else if (src_wim->hdr.image_count == 1) {
164                         src_image = 1;
165                 } else {
166                         return 0;
167                 }
168         }
169
170         if (!dest_name) {
171                 dest_name = wimlib_get_image_name(src_wim, src_image);
172                 DEBUG("Using name `%"TS"' for source image %d",
173                       dest_name, src_image);
174         }
175
176         if (!dest_description) {
177                 dest_description = wimlib_get_image_description(src_wim,
178                                                                 src_image);
179                 DEBUG("Using description `%"TS"' for source image %d",
180                       dest_description, src_image);
181         }
182
183         DEBUG("Exporting image %d from `%"TS"'", src_image, src_wim->filename);
184
185         if (wimlib_image_name_in_use(dest_wim, dest_name)) {
186                 ERROR("There is already an image named `%"TS"' in the "
187                       "destination WIM", dest_name);
188                 return WIMLIB_ERR_IMAGE_NAME_COLLISION;
189         }
190
191         ret = verify_swm_set(src_wim, additional_swms, num_additional_swms);
192         if (ret)
193                 return ret;
194
195         ret = wim_checksum_unhashed_streams(src_wim);
196         if (ret)
197                 return ret;
198         ret = wim_checksum_unhashed_streams(dest_wim);
199         if (ret)
200                 return ret;
201
202         if (num_additional_swms)
203                 merge_lookup_tables(src_wim, additional_swms, num_additional_swms);
204
205         ret = select_wim_image(src_wim, src_image);
206         if (ret) {
207                 ERROR("Could not select image %d from the WIM `%"TS"' "
208                       "to export it", src_image, src_wim->filename);
209                 goto out;
210         }
211
212         /* Pre-allocate the new lookup table entries that will be needed.  This
213          * way, it's not possible to run out of memory part-way through
214          * modifying the lookup table of the destination WIM. */
215         for_lookup_table_entry(src_wim->lookup_table, lte_zero_out_refcnt, NULL);
216         src_imd = wim_get_current_image_metadata(src_wim);
217         INIT_LIST_HEAD(&lte_list_head);
218         image_for_each_inode(inode, src_imd) {
219                 ret = inode_allocate_needed_ltes(inode,
220                                                  src_wim->lookup_table,
221                                                  dest_wim->lookup_table,
222                                                  &lte_list_head);
223                 if (ret)
224                         goto out_free_ltes;
225         }
226
227         ret = xml_export_image(src_wim->wim_info, src_image,
228                                &dest_wim->wim_info, dest_name,
229                                dest_description);
230         if (ret)
231                 goto out_free_ltes;
232
233         ret = append_image_metadata(dest_wim, src_imd);
234         if (ret)
235                 goto out_xml_delete_image;
236
237         /* The `struct image_metadata' is now referenced by both the @src_wim
238          * and the @dest_wim. */
239         src_imd->refcnt++;
240         src_imd->modified = 1;
241
242         /* All memory allocations have been taken care of, so it's no longer
243          * possible for this function to fail.  Go ahead and update the lookup
244          * table of the destination WIM and the boot index, if needed. */
245         image_for_each_inode(inode, src_imd) {
246                 inode_move_ltes_to_table(inode,
247                                          src_wim->lookup_table,
248                                          dest_wim->lookup_table,
249                                          &lte_list_head);
250         }
251
252         if (export_flags & WIMLIB_EXPORT_FLAG_BOOT)
253                 dest_wim->hdr.boot_idx = dest_wim->hdr.image_count;
254         if (src_wim->hdr.flags & WIM_HDR_FLAG_RP_FIX)
255         {
256                 /* Set the reparse point fixup flag on the destination WIM if
257                  * the flag is set on the source WIM. */
258                 dest_wim->hdr.flags |= WIM_HDR_FLAG_RP_FIX;
259         }
260         ret = 0;
261         goto out;
262 out_xml_delete_image:
263         xml_delete_image(&dest_wim->wim_info, dest_wim->hdr.image_count + 1);
264 out_free_ltes:
265         {
266                 struct wim_lookup_table_entry *lte, *tmp;
267                 list_for_each_entry_safe(lte, tmp, &lte_list_head, export_stream_list)
268                         free_lookup_table_entry(lte);
269         }
270 out:
271         if (num_additional_swms)
272                 unmerge_lookup_table(src_wim);
273         return ret;
274 }