1 ///////////////////////////////////////////////////////////////////////////////
2 //
3 /// \file 02_decompress.c
4 /// \brief Decompress .xz files to stdout
5 ///
6 /// Usage: ./02_decompress INPUT_FILES... > OUTFILE
7 ///
8 /// Example: ./02_decompress foo.xz bar.xz > foobar
9 //
10 // Author: Lasse Collin
11 //
12 // This file has been put into the public domain.
13 // You can do whatever you want with this file.
14 //
15 ///////////////////////////////////////////////////////////////////////////////
16
17 #include <stdbool.h>
18 #include <stdlib.h>
19 #include <stdio.h>
20 #include <string.h>
21 #include <errno.h>
22 #include <lzma.h>
23
24
25 static bool
init_decoder(lzma_stream * strm)26 init_decoder(lzma_stream *strm)
27 {
28 // Initialize a .xz decoder. The decoder supports a memory usage limit
29 // and a set of flags.
30 //
31 // The memory usage of the decompressor depends on the settings used
32 // to compress a .xz file. It can vary from less than a megabyte to
33 // a few gigabytes, but in practice (at least for now) it rarely
34 // exceeds 65 MiB because that's how much memory is required to
35 // decompress files created with "xz -9". Settings requiring more
36 // memory take extra effort to use and don't (at least for now)
37 // provide significantly better compression in most cases.
38 //
39 // Memory usage limit is useful if it is important that the
40 // decompressor won't consume gigabytes of memory. The need
41 // for limiting depends on the application. In this example,
42 // no memory usage limiting is used. This is done by setting
43 // the limit to UINT64_MAX.
44 //
45 // The .xz format allows concatenating compressed files as is:
46 //
47 // echo foo | xz > foobar.xz
48 // echo bar | xz >> foobar.xz
49 //
50 // When decompressing normal standalone .xz files, LZMA_CONCATENATED
51 // should always be used to support decompression of concatenated
52 // .xz files. If LZMA_CONCATENATED isn't used, the decoder will stop
53 // after the first .xz stream. This can be useful when .xz data has
54 // been embedded inside another file format.
55 //
56 // Flags other than LZMA_CONCATENATED are supported too, and can
57 // be combined with bitwise-or. See lzma/container.h
58 // (src/liblzma/api/lzma/container.h in the source package or e.g.
59 // /usr/include/lzma/container.h depending on the install prefix)
60 // for details.
61 lzma_ret ret = lzma_stream_decoder(
62 strm, UINT64_MAX, LZMA_CONCATENATED);
63
64 // Return successfully if the initialization went fine.
65 if (ret == LZMA_OK)
66 return true;
67
68 // Something went wrong. The possible errors are documented in
69 // lzma/container.h (src/liblzma/api/lzma/container.h in the source
70 // package or e.g. /usr/include/lzma/container.h depending on the
71 // install prefix).
72 //
73 // Note that LZMA_MEMLIMIT_ERROR is never possible here. If you
74 // specify a very tiny limit, the error will be delayed until
75 // the first headers have been parsed by a call to lzma_code().
76 const char *msg;
77 switch (ret) {
78 case LZMA_MEM_ERROR:
79 msg = "Memory allocation failed";
80 break;
81
82 case LZMA_OPTIONS_ERROR:
83 msg = "Unsupported decompressor flags";
84 break;
85
86 default:
87 // This is most likely LZMA_PROG_ERROR indicating a bug in
88 // this program or in liblzma. It is inconvenient to have a
89 // separate error message for errors that should be impossible
90 // to occur, but knowing the error code is important for
91 // debugging. That's why it is good to print the error code
92 // at least when there is no good error message to show.
93 msg = "Unknown error, possibly a bug";
94 break;
95 }
96
97 fprintf(stderr, "Error initializing the decoder: %s (error code %u)\n",
98 msg, ret);
99 return false;
100 }
101
102
103 static bool
decompress(lzma_stream * strm,const char * inname,FILE * infile,FILE * outfile)104 decompress(lzma_stream *strm, const char *inname, FILE *infile, FILE *outfile)
105 {
106 // When LZMA_CONCATENATED flag was used when initializing the decoder,
107 // we need to tell lzma_code() when there will be no more input.
108 // This is done by setting action to LZMA_FINISH instead of LZMA_RUN
109 // in the same way as it is done when encoding.
110 //
111 // When LZMA_CONCATENATED isn't used, there is no need to use
112 // LZMA_FINISH to tell when all the input has been read, but it
113 // is still OK to use it if you want. When LZMA_CONCATENATED isn't
114 // used, the decoder will stop after the first .xz stream. In that
115 // case some unused data may be left in strm->next_in.
116 lzma_action action = LZMA_RUN;
117
118 uint8_t inbuf[BUFSIZ];
119 uint8_t outbuf[BUFSIZ];
120
121 strm->next_in = NULL;
122 strm->avail_in = 0;
123 strm->next_out = outbuf;
124 strm->avail_out = sizeof(outbuf);
125
126 while (true) {
127 if (strm->avail_in == 0 && !feof(infile)) {
128 strm->next_in = inbuf;
129 strm->avail_in = fread(inbuf, 1, sizeof(inbuf),
130 infile);
131
132 if (ferror(infile)) {
133 fprintf(stderr, "%s: Read error: %s\n",
134 inname, strerror(errno));
135 return false;
136 }
137
138 // Once the end of the input file has been reached,
139 // we need to tell lzma_code() that no more input
140 // will be coming. As said before, this isn't required
141 // if the LZMA_CONCATENATED flag isn't used when
142 // initializing the decoder.
143 if (feof(infile))
144 action = LZMA_FINISH;
145 }
146
147 lzma_ret ret = lzma_code(strm, action);
148
149 if (strm->avail_out == 0 || ret == LZMA_STREAM_END) {
150 size_t write_size = sizeof(outbuf) - strm->avail_out;
151
152 if (fwrite(outbuf, 1, write_size, outfile)
153 != write_size) {
154 fprintf(stderr, "Write error: %s\n",
155 strerror(errno));
156 return false;
157 }
158
159 strm->next_out = outbuf;
160 strm->avail_out = sizeof(outbuf);
161 }
162
163 if (ret != LZMA_OK) {
164 // Once everything has been decoded successfully, the
165 // return value of lzma_code() will be LZMA_STREAM_END.
166 //
167 // It is important to check for LZMA_STREAM_END. Do not
168 // assume that getting ret != LZMA_OK would mean that
169 // everything has gone well or that when you aren't
170 // getting more output it must have successfully
171 // decoded everything.
172 if (ret == LZMA_STREAM_END)
173 return true;
174
175 // It's not LZMA_OK nor LZMA_STREAM_END,
176 // so it must be an error code. See lzma/base.h
177 // (src/liblzma/api/lzma/base.h in the source package
178 // or e.g. /usr/include/lzma/base.h depending on the
179 // install prefix) for the list and documentation of
180 // possible values. Many values listen in lzma_ret
181 // enumeration aren't possible in this example, but
182 // can be made possible by enabling memory usage limit
183 // or adding flags to the decoder initialization.
184 const char *msg;
185 switch (ret) {
186 case LZMA_MEM_ERROR:
187 msg = "Memory allocation failed";
188 break;
189
190 case LZMA_FORMAT_ERROR:
191 // .xz magic bytes weren't found.
192 msg = "The input is not in the .xz format";
193 break;
194
195 case LZMA_OPTIONS_ERROR:
196 // For example, the headers specify a filter
197 // that isn't supported by this liblzma
198 // version (or it hasn't been enabled when
199 // building liblzma, but no-one sane does
200 // that unless building liblzma for an
201 // embedded system). Upgrading to a newer
202 // liblzma might help.
203 //
204 // Note that it is unlikely that the file has
205 // accidentally became corrupt if you get this
206 // error. The integrity of the .xz headers is
207 // always verified with a CRC32, so
208 // unintentionally corrupt files can be
209 // distinguished from unsupported files.
210 msg = "Unsupported compression options";
211 break;
212
213 case LZMA_DATA_ERROR:
214 msg = "Compressed file is corrupt";
215 break;
216
217 case LZMA_BUF_ERROR:
218 // Typically this error means that a valid
219 // file has got truncated, but it might also
220 // be a damaged part in the file that makes
221 // the decoder think the file is truncated.
222 // If you prefer, you can use the same error
223 // message for this as for LZMA_DATA_ERROR.
224 msg = "Compressed file is truncated or "
225 "otherwise corrupt";
226 break;
227
228 default:
229 // This is most likely LZMA_PROG_ERROR.
230 msg = "Unknown error, possibly a bug";
231 break;
232 }
233
234 fprintf(stderr, "%s: Decoder error: "
235 "%s (error code %u)\n",
236 inname, msg, ret);
237 return false;
238 }
239 }
240 }
241
242
243 extern int
main(int argc,char ** argv)244 main(int argc, char **argv)
245 {
246 if (argc <= 1) {
247 fprintf(stderr, "Usage: %s FILES...\n", argv[0]);
248 return EXIT_FAILURE;
249 }
250
251 lzma_stream strm = LZMA_STREAM_INIT;
252
253 bool success = true;
254
255 // Try to decompress all files.
256 for (int i = 1; i < argc; ++i) {
257 if (!init_decoder(&strm)) {
258 // Decoder initialization failed. There's no point
259 // to retry it so we need to exit.
260 success = false;
261 break;
262 }
263
264 FILE *infile = fopen(argv[i], "rb");
265
266 if (infile == NULL) {
267 fprintf(stderr, "%s: Error opening the "
268 "input file: %s\n",
269 argv[i], strerror(errno));
270 success = false;
271 } else {
272 success &= decompress(&strm, argv[i], infile, stdout);
273 fclose(infile);
274 }
275 }
276
277 // Free the memory allocated for the decoder. This only needs to be
278 // done after the last file.
279 lzma_end(&strm);
280
281 if (fclose(stdout)) {
282 fprintf(stderr, "Write error: %s\n", strerror(errno));
283 success = false;
284 }
285
286 return success ? EXIT_SUCCESS : EXIT_FAILURE;
287 }
288