]> pd.if.org Git - zpackage/blob - lib/uncompress.c
move blake2 out of subdirectory
[zpackage] / lib / uncompress.c
1 #include <stdio.h>
2 #include <sys/types.h>
3 #include <sys/stat.h>
4 #include <fcntl.h>
5 #include <unistd.h>
6 #include <errno.h>
7 #include <string.h>
8 #include <stdlib.h>
9 #include <assert.h>
10
11 #include <sys/mman.h>
12
13 #include "lzma.h"
14
15 ssize_t zpm_uncompress_cb(void *buf, size_t bufsize, void *cbdata,
16                 int (*cb)(void *ud, void *buf, size_t bufsize)) {
17         lzma_stream s = LZMA_STREAM_INIT;
18         lzma_stream *strm;
19         ssize_t bytes = 0;
20         
21         uint8_t outbuf[BUFSIZ];
22
23         int ret;
24
25         strm = &s;
26
27         ret = lzma_stream_decoder(strm, UINT64_MAX, 0);
28         /* The only reasonable error here is LZMA_MEM_ERROR. */
29         if (ret != LZMA_OK) {
30                 fprintf(stderr, "%s", ret == LZMA_MEM_ERROR ? strerror(ENOMEM)
31                                 : "Internal error (bug)");
32                 return -1;
33         }
34
35         strm->avail_in = bufsize;
36         strm->next_in = buf;
37         strm->avail_out = BUFSIZ;
38         strm->next_out = outbuf;
39
40         lzma_action action = LZMA_RUN;
41
42         while (1) {
43                 ret = lzma_code(strm, action);
44
45                 // Write and check write error before checking decoder error.
46                 // This way as much data as possible gets written to output
47                 // even if decoder detected an error.
48                 if (strm->avail_out == 0 || ret != LZMA_OK) {
49                         size_t avail = BUFSIZ - strm->avail_out;
50                         ssize_t written = 0;
51                         uint8_t *start;
52
53                         start = outbuf;
54
55                         while (avail > 0) {
56                                 written = cb(cbdata, outbuf, avail);
57                                 if (written == -1) {
58                                         /* Wouldn't be a surprise if writing to
59                                          * stderr would fail too but at least
60                                          * try to show an error message.
61                                          */
62                                         return -1;
63                                 }
64                                 avail -= written;
65                                 start += written;
66                                 bytes += written;
67                         }
68
69                         strm->next_out = outbuf;
70                         strm->avail_out = BUFSIZ;
71                 }
72
73                 if (ret != LZMA_OK) {
74                         if (ret == LZMA_STREAM_END) {
75                                 // lzma_stream_decoder() already guarantees
76                                 // that there's no trailing garbage.
77                                 assert(strm->avail_in == 0);
78                                 //assert(action == LZMA_FINISH);
79                                 lzma_end(strm);
80                                 return bytes;
81                         }
82
83                         lzma_end(strm);
84                         const char *msg;
85                         switch (ret) {
86                                 case LZMA_MEM_ERROR:
87                                         msg = strerror(ENOMEM);
88                                         break;
89
90                                 case LZMA_FORMAT_ERROR:
91                                         msg = "File format not recognized";
92                                         break;
93
94                                 case LZMA_OPTIONS_ERROR:
95                                         // FIXME: Better message?
96                                         msg = "Unsupported compression options";
97                                         break;
98
99                                 case LZMA_DATA_ERROR:
100                                         msg = "File is corrupt";
101                                         break;
102
103                                 case LZMA_BUF_ERROR:
104                                         msg = "Unexpected end of input";
105                                         break;
106
107                                 default:
108                                         msg = "Internal error (bug)";
109                                         break;
110                         }
111
112                         fprintf(stderr, "zpmuncompress: %s\n", msg);
113                         return -1;
114                 }
115         }
116
117 }
118
119 ssize_t uncompresslzma(void *buf, size_t bufsize, int out) {
120         lzma_stream s = LZMA_STREAM_INIT;
121         lzma_stream *strm;
122         ssize_t bytes = 0;
123         
124         uint8_t outbuf[BUFSIZ];
125
126         int ret;
127
128         strm = &s;
129
130         ret = lzma_stream_decoder(strm, UINT64_MAX, 0);
131         /* The only reasonable error here is LZMA_MEM_ERROR. */
132         if (ret != LZMA_OK) {
133                 fprintf(stderr, "%s", ret == LZMA_MEM_ERROR ? strerror(ENOMEM)
134                                 : "Internal error (bug)");
135                 return -1;
136         }
137
138         strm->avail_in = bufsize;
139         strm->next_in = buf;
140         strm->avail_out = BUFSIZ;
141         strm->next_out = outbuf;
142
143         lzma_action action = LZMA_RUN;
144
145         while (1) {
146                 ret = lzma_code(strm, action);
147
148                 // Write and check write error before checking decoder error.
149                 // This way as much data as possible gets written to output
150                 // even if decoder detected an error.
151                 if (strm->avail_out == 0 || ret != LZMA_OK) {
152                         size_t avail = BUFSIZ - strm->avail_out;
153                         ssize_t written = 0;
154                         uint8_t *start;
155
156                         start = outbuf;
157
158                         while (avail > 0) {
159                                 written = write(out, outbuf, avail);
160                                 if (written == -1) {
161                                         /* Wouldn't be a surprise if writing to
162                                          * stderr would fail too but at least
163                                          * try to show an error message.
164                                          */
165                                         fprintf(stderr, "Cannot write to output"
166                                                         " file stream: %s",
167                                                         strerror(errno));
168                                         return -1;
169                                 }
170                                 avail -= written;
171                                 start += written;
172                                 bytes += written;
173                         }
174
175                         strm->next_out = outbuf;
176                         strm->avail_out = BUFSIZ;
177                 }
178
179                 if (ret != LZMA_OK) {
180                         if (ret == LZMA_STREAM_END) {
181                                 // lzma_stream_decoder() already guarantees
182                                 // that there's no trailing garbage.
183                                 assert(strm->avail_in == 0);
184                                 //assert(action == LZMA_FINISH);
185                                 lzma_end(strm);
186                                 return bytes;
187                         }
188
189                         lzma_end(strm);
190                         const char *msg;
191                         switch (ret) {
192                                 case LZMA_MEM_ERROR:
193                                         msg = strerror(ENOMEM);
194                                         break;
195
196                                 case LZMA_FORMAT_ERROR:
197                                         msg = "File format not recognized";
198                                         break;
199
200                                 case LZMA_OPTIONS_ERROR:
201                                         // FIXME: Better message?
202                                         msg = "Unsupported compression options";
203                                         break;
204
205                                 case LZMA_DATA_ERROR:
206                                         msg = "File is corrupt";
207                                         break;
208
209                                 case LZMA_BUF_ERROR:
210                                         msg = "Unexpected end of input";
211                                         break;
212
213                                 default:
214                                         msg = "Internal error (bug)";
215                                         break;
216                         }
217
218                         fprintf(stderr, "zpmuncompress: %s\n", msg);
219                         return -1;
220                 }
221         }
222 }