Import libarchive 2.0.28.
[dragonfly.git] / contrib / libarchive-2.0 / libarchive / archive_read_support_compression_none.c
1 /*-
2  * Copyright (c) 2003-2007 Tim Kientzle
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "archive_platform.h"
27 __FBSDID("$FreeBSD: src/lib/libarchive/archive_read_support_compression_none.c,v 1.16 2007/04/05 05:18:16 kientzle Exp $");
28
29 #ifdef HAVE_ERRNO_H
30 #include <errno.h>
31 #endif
32 #ifdef HAVE_LIMITS_H
33 #include <limits.h>
34 #endif
35 #ifdef HAVE_STDLIB_H
36 #include <stdlib.h>
37 #endif
38 #ifdef HAVE_STRING_H
39 #include <string.h>
40 #endif
41 #ifdef HAVE_UNISTD_H
42 #include <unistd.h>
43 #endif
44
45 #include "archive.h"
46 #include "archive_private.h"
47 #include "archive_read_private.h"
48
49 struct archive_decompress_none {
50         char            *buffer;
51         size_t           buffer_size;
52         char            *next;          /* Current read location. */
53         size_t           avail;         /* Bytes in my buffer. */
54         const void      *client_buff;   /* Client buffer information. */
55         size_t           client_total;
56         const char      *client_next;
57         size_t           client_avail;
58         char             end_of_file;
59         char             fatal;
60 };
61
62 /*
63  * Size of internal buffer used for combining short reads.  This is
64  * also an upper limit on the size of a read request.  Recall,
65  * however, that we can (and will!) return blocks of data larger than
66  * this.  The read semantics are: you ask for a minimum, I give you a
67  * pointer to my best-effort match and tell you how much data is
68  * there.  It could be less than you asked for, it could be much more.
69  * For example, a client might use mmap() to "read" the entire file as
70  * a single block.  In that case, I will return that entire block to
71  * my clients.
72  */
73 #define BUFFER_SIZE     65536
74
75 #define minimum(a, b) (a < b ? a : b)
76
77 static int      archive_decompressor_none_bid(const void *, size_t);
78 static int      archive_decompressor_none_finish(struct archive_read *);
79 static int      archive_decompressor_none_init(struct archive_read *,
80                     const void *, size_t);
81 static ssize_t  archive_decompressor_none_read_ahead(struct archive_read *,
82                     const void **, size_t);
83 static ssize_t  archive_decompressor_none_read_consume(struct archive_read *,
84                     size_t);
85 static off_t    archive_decompressor_none_skip(struct archive_read *, off_t);
86
87 int
88 archive_read_support_compression_none(struct archive *_a)
89 {
90         struct archive_read *a = (struct archive_read *)_a;
91         return (__archive_read_register_compression(a,
92                     archive_decompressor_none_bid,
93                     archive_decompressor_none_init));
94 }
95
96 /*
97  * Try to detect an "uncompressed" archive.
98  */
99 static int
100 archive_decompressor_none_bid(const void *buff, size_t len)
101 {
102         (void)buff;
103         (void)len;
104
105         return (1); /* Default: We'll take it if noone else does. */
106 }
107
108 static int
109 archive_decompressor_none_init(struct archive_read *a, const void *buff, size_t n)
110 {
111         struct archive_decompress_none  *state;
112
113         a->archive.compression_code = ARCHIVE_COMPRESSION_NONE;
114         a->archive.compression_name = "none";
115
116         state = (struct archive_decompress_none *)malloc(sizeof(*state));
117         if (!state) {
118                 archive_set_error(&a->archive, ENOMEM, "Can't allocate input data");
119                 return (ARCHIVE_FATAL);
120         }
121         memset(state, 0, sizeof(*state));
122
123         state->buffer_size = BUFFER_SIZE;
124         state->buffer = (char *)malloc(state->buffer_size);
125         state->next = state->buffer;
126         if (state->buffer == NULL) {
127                 free(state);
128                 archive_set_error(&a->archive, ENOMEM, "Can't allocate input buffer");
129                 return (ARCHIVE_FATAL);
130         }
131
132         /* Save reference to first block of data. */
133         state->client_buff = buff;
134         state->client_total = n;
135         state->client_next = state->client_buff;
136         state->client_avail = state->client_total;
137
138         a->compression_data = state;
139         a->compression_read_ahead = archive_decompressor_none_read_ahead;
140         a->compression_read_consume = archive_decompressor_none_read_consume;
141         a->compression_skip = archive_decompressor_none_skip;
142         a->compression_finish = archive_decompressor_none_finish;
143
144         return (ARCHIVE_OK);
145 }
146
147 /*
148  * We just pass through pointers to the client buffer if we can.
149  * If the client buffer is short, then we copy stuff to our internal
150  * buffer to combine reads.
151  */
152 static ssize_t
153 archive_decompressor_none_read_ahead(struct archive_read *a, const void **buff,
154     size_t min)
155 {
156         struct archive_decompress_none *state;
157         ssize_t bytes_read;
158
159         state = (struct archive_decompress_none *)a->compression_data;
160         if (state->fatal)
161                 return (-1);
162
163         /*
164          * Don't make special efforts to handle requests larger than
165          * the copy buffer.
166          */
167         if (min > state->buffer_size)
168                 min = state->buffer_size;
169
170         /*
171          * Try to satisfy the request directly from the client
172          * buffer.  We can do this if all of the data in the copy
173          * buffer was copied from the current client buffer.  This
174          * also covers the case where the copy buffer is empty and
175          * the client buffer has all the data we need.
176          */
177         if (state->client_total >= state->client_avail + state->avail
178             && state->client_avail + state->avail >= min) {
179                 state->client_avail += state->avail;
180                 state->client_next -= state->avail;
181                 state->avail = 0;
182                 state->next = state->buffer;
183                 *buff = state->client_next;
184                 return (state->client_avail);
185         }
186
187         /*
188          * If we can't use client buffer, we'll have to use copy buffer.
189          */
190
191         /* Move data forward in copy buffer if necessary. */
192         if (state->next > state->buffer &&
193             state->next + min > state->buffer + state->buffer_size) {
194                 if (state->avail > 0)
195                         memmove(state->buffer, state->next, state->avail);
196                 state->next = state->buffer;
197         }
198
199         /* Collect data in copy buffer to fulfill request. */
200         while (state->avail < min) {
201                 /* Copy data from client buffer to our copy buffer. */
202                 if (state->client_avail > 0) {
203                         /* First estimate: copy to fill rest of buffer. */
204                         size_t tocopy = (state->buffer + state->buffer_size)
205                             - (state->next + state->avail);
206                         /* Don't copy more than is available. */
207                         if (tocopy > state->client_avail)
208                                 tocopy = state->client_avail;
209                         memcpy(state->next + state->avail, state->client_next,
210                             tocopy);
211                         state->client_next += tocopy;
212                         state->client_avail -= tocopy;
213                         state->avail += tocopy;
214                 } else {
215                         /* There is no more client data: fetch more. */
216                         /*
217                          * It seems to me that const void ** and const
218                          * char ** should be compatible, but they
219                          * aren't, hence the cast.
220                          */
221                         bytes_read = (a->client_reader)(&a->archive,
222                             a->client_data, &state->client_buff);
223                         if (bytes_read < 0) {           /* Read error. */
224                                 state->client_total = state->client_avail = 0;
225                                 state->client_next = state->client_buff = NULL;
226                                 state->fatal = 1;
227                                 return (-1);
228                         }
229                         if (bytes_read == 0) {          /* End-of-file. */
230                                 state->client_total = state->client_avail = 0;
231                                 state->client_next = state->client_buff = NULL;
232                                 state->end_of_file = 1;
233                                 break;
234                         }
235                         a->archive.raw_position += bytes_read;
236                         state->client_total = bytes_read;
237                         state->client_avail = state->client_total;
238                         state->client_next = state->client_buff;
239                 }
240         }
241
242         *buff = state->next;
243         return (state->avail);
244 }
245
246 /*
247  * Mark the appropriate data as used.  Note that the request here will
248  * often be much smaller than the size of the previous read_ahead
249  * request.
250  */
251 static ssize_t
252 archive_decompressor_none_read_consume(struct archive_read *a, size_t request)
253 {
254         struct archive_decompress_none *state;
255
256         state = (struct archive_decompress_none *)a->compression_data;
257         if (state->avail > 0) {
258                 /* Read came from copy buffer. */
259                 state->next += request;
260                 state->avail -= request;
261         } else {
262                 /* Read came from client buffer. */
263                 state->client_next += request;
264                 state->client_avail -= request;
265         }
266         a->archive.file_position += request;
267         return (request);
268 }
269
270 /*
271  * Skip forward by exactly the requested bytes or else return
272  * ARCHIVE_FATAL.  Note that this differs from the contract for
273  * read_ahead, which does not guarantee a minimum count.
274  */
275 static off_t
276 archive_decompressor_none_skip(struct archive_read *a, off_t request)
277 {
278         struct archive_decompress_none *state;
279         off_t bytes_skipped, total_bytes_skipped = 0;
280         size_t min;
281
282         state = (struct archive_decompress_none *)a->compression_data;
283         if (state->fatal)
284                 return (-1);
285         /*
286          * If there is data in the buffers already, use that first.
287          */
288         if (state->avail > 0) {
289                 min = minimum(request, (off_t)state->avail);
290                 bytes_skipped = archive_decompressor_none_read_consume(a, min);
291                 request -= bytes_skipped;
292                 total_bytes_skipped += bytes_skipped;
293         }
294         if (state->client_avail > 0) {
295                 min = minimum(request, (off_t)state->client_avail);
296                 bytes_skipped = archive_decompressor_none_read_consume(a, min);
297                 request -= bytes_skipped;
298                 total_bytes_skipped += bytes_skipped;
299         }
300         if (request == 0)
301                 return (total_bytes_skipped);
302         /*
303          * If a client_skipper was provided, try that first.
304          */
305 #if ARCHIVE_API_VERSION < 2
306         if ((a->client_skipper != NULL) && (request < SSIZE_MAX)) {
307 #else
308         if (a->client_skipper != NULL) {
309 #endif
310                 bytes_skipped = (a->client_skipper)(&a->archive,
311                     a->client_data, request);
312                 if (bytes_skipped < 0) {        /* error */
313                         state->client_total = state->client_avail = 0;
314                         state->client_next = state->client_buff = NULL;
315                         state->fatal = 1;
316                         return (bytes_skipped);
317                 }
318                 total_bytes_skipped += bytes_skipped;
319                 a->archive.file_position += bytes_skipped;
320                 request -= bytes_skipped;
321                 state->client_next = state->client_buff;
322                 a->archive.raw_position += bytes_skipped;
323                 state->client_avail = state->client_total = 0;
324         }
325         /*
326          * Note that client_skipper will usually not satisfy the
327          * full request (due to low-level blocking concerns),
328          * so even if client_skipper is provided, we may still
329          * have to use ordinary reads to finish out the request.
330          */
331         while (request > 0) {
332                 const void* dummy_buffer;
333                 ssize_t bytes_read;
334                 bytes_read = archive_decompressor_none_read_ahead(a,
335                     &dummy_buffer, request);
336                 if (bytes_read < 0)
337                         return (bytes_read);
338                 if (bytes_read == 0) {
339                         /* We hit EOF before we satisfied the skip request. */
340                         archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
341                             "Truncated input file (need to skip %jd bytes)",
342                             (intmax_t)request);
343                         return (ARCHIVE_FATAL);
344                 }
345                 min = (size_t)(minimum(bytes_read, request));
346                 bytes_read = archive_decompressor_none_read_consume(a, min);
347                 total_bytes_skipped += bytes_read;
348                 request -= bytes_read;
349         }
350         return (total_bytes_skipped);
351 }
352
353 static int
354 archive_decompressor_none_finish(struct archive_read *a)
355 {
356         struct archive_decompress_none  *state;
357
358         state = (struct archive_decompress_none *)a->compression_data;
359         free(state->buffer);
360         free(state);
361         a->compression_data = NULL;
362         if (a->client_closer != NULL)
363                 return ((a->client_closer)(&a->archive, a->client_data));
364         return (ARCHIVE_OK);
365 }