Import libarchive-2.8.4.
[dragonfly.git] / contrib / libarchive / libarchive / archive_read_support_compression_rpm.c
1 /*-
2  * Copyright (c) 2009 Michihiro NAKAJIMA
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
28 #ifdef HAVE_ERRNO_H
29 #include <errno.h>
30 #endif
31 #ifdef HAVE_STDLIB_H
32 #include <stdlib.h>
33 #endif
34
35 #include "archive.h"
36 #include "archive_endian.h"
37 #include "archive_private.h"
38 #include "archive_read_private.h"
39
40 struct rpm {
41         int64_t          total_in;
42         size_t           hpos;
43         size_t           hlen;
44         unsigned char    header[16];
45         enum {
46                 ST_LEAD,        /* Skipping 'Lead' section. */
47                 ST_HEADER,      /* Reading 'Header' section;
48                                  * first 16 bytes. */
49                 ST_HEADER_DATA, /* Skipping 'Header' section. */
50                 ST_PADDING,     /* Skipping padding data after the
51                                  * 'Header' section. */
52                 ST_ARCHIVE      /* Reading 'Archive' section. */
53         }                state;
54         int              first_header;
55 };
56 #define RPM_LEAD_SIZE   96      /* Size of 'Lead' section. */
57
58 static int      rpm_bidder_bid(struct archive_read_filter_bidder *,
59                     struct archive_read_filter *);
60 static int      rpm_bidder_init(struct archive_read_filter *);
61
62 static ssize_t  rpm_filter_read(struct archive_read_filter *,
63                     const void **);
64 static int      rpm_filter_close(struct archive_read_filter *);
65
66 int
67 archive_read_support_compression_rpm(struct archive *_a)
68 {
69         struct archive_read *a = (struct archive_read *)_a;
70         struct archive_read_filter_bidder *bidder;
71
72         bidder = __archive_read_get_bidder(a);
73         archive_clear_error(_a);
74         if (bidder == NULL)
75                 return (ARCHIVE_FATAL);
76
77         bidder->data = NULL;
78         bidder->bid = rpm_bidder_bid;
79         bidder->init = rpm_bidder_init;
80         bidder->options = NULL;
81         bidder->free = NULL;
82         return (ARCHIVE_OK);
83 }
84
85 static int
86 rpm_bidder_bid(struct archive_read_filter_bidder *self,
87     struct archive_read_filter *filter)
88 {
89         const unsigned char *b;
90         ssize_t avail;
91         int bits_checked;
92
93         (void)self; /* UNUSED */
94
95         b = __archive_read_filter_ahead(filter, 8, &avail);
96         if (b == NULL)
97                 return (0);
98
99         bits_checked = 0;
100         /*
101          * Verify Header Magic Bytes : 0xed 0xab 0xee 0xdb
102          */
103         if (b[0] != 0xed)
104                 return (0);
105         bits_checked += 8;
106         if (b[1] != 0xab)
107                 return (0);
108         bits_checked += 8;
109         if (b[2] != 0xee)
110                 return (0);
111         bits_checked += 8;
112         if (b[3] != 0xdb)
113                 return (0);
114         bits_checked += 8;
115         /*
116          * Check major version.
117          */
118         if (b[4] != 3 && b[4] != 4)
119                 return (0);
120         bits_checked += 8;
121         /*
122          * Check package type; binary or source.
123          */
124         if (b[6] != 0)
125                 return (0);
126         bits_checked += 8;
127         if (b[7] != 0 && b[7] != 1)
128                 return (0);
129         bits_checked += 8;
130
131         return (bits_checked);
132 }
133
134 static int
135 rpm_bidder_init(struct archive_read_filter *self)
136 {
137         struct rpm   *rpm;
138
139         self->code = ARCHIVE_COMPRESSION_RPM;
140         self->name = "rpm";
141         self->read = rpm_filter_read;
142         self->skip = NULL; /* not supported */
143         self->close = rpm_filter_close;
144
145         rpm = (struct rpm *)calloc(sizeof(*rpm), 1);
146         if (rpm == NULL) {
147                 archive_set_error(&self->archive->archive, ENOMEM,
148                     "Can't allocate data for rpm");
149                 return (ARCHIVE_FATAL);
150         }
151
152         self->data = rpm;
153         rpm->state = ST_LEAD;
154
155         return (ARCHIVE_OK);
156 }
157
158 static ssize_t
159 rpm_filter_read(struct archive_read_filter *self, const void **buff)
160 {
161         struct rpm *rpm;
162         const unsigned char *b;
163         ssize_t avail_in, total;
164         size_t used, n;
165         uint32_t section;
166         uint32_t bytes;
167
168         rpm = (struct rpm *)self->data;
169         *buff = NULL;
170         total = avail_in = 0;
171         b = NULL;
172         used = 0;
173         do {
174                 if (b == NULL) {
175                         b = __archive_read_filter_ahead(self->upstream, 1,
176                             &avail_in);
177                         if (b == NULL) {
178                                 if (avail_in < 0)
179                                         return (ARCHIVE_FATAL);
180                                 else
181                                         break;
182                         }
183                 }
184
185                 switch (rpm->state) {
186                 case ST_LEAD:
187                         if (rpm->total_in + avail_in < RPM_LEAD_SIZE)
188                                 used += avail_in;
189                         else {
190                                 n = RPM_LEAD_SIZE - rpm->total_in;
191                                 used += n;
192                                 b += n;
193                                 rpm->state = ST_HEADER;
194                                 rpm->hpos = 0;
195                                 rpm->hlen = 0;
196                                 rpm->first_header = 1;
197                         }
198                         break;
199                 case ST_HEADER:
200                         n = 16 - rpm->hpos;
201                         if (n > avail_in - used)
202                                 n = avail_in - used;
203                         memcpy(rpm->header+rpm->hpos, b, n);
204                         b += n;
205                         used += n;
206                         rpm->hpos += n;
207
208                         if (rpm->hpos == 16) {
209                                 if (rpm->header[0] != 0x8e ||
210                                     rpm->header[1] != 0xad ||
211                                     rpm->header[2] != 0xe8 ||
212                                     rpm->header[3] != 0x01) {
213                                         if (rpm->first_header) {
214                                                 archive_set_error(
215                                                     &self->archive->archive,
216                                                     ARCHIVE_ERRNO_FILE_FORMAT,
217                                                     "Unrecoginized rpm header");
218                                                 return (ARCHIVE_FATAL);
219                                         }
220                                         rpm->state = ST_ARCHIVE;
221                                         *buff = rpm->header;
222                                         total = rpm->hpos;
223                                         break;
224                                 }
225                                 /* Calculate 'Header' length. */
226                                 section = archive_be32dec(rpm->header+8);
227                                 bytes = archive_be32dec(rpm->header+12);
228                                 rpm->hlen = 16 + section * 16 + bytes;
229                                 rpm->state = ST_HEADER_DATA;
230                                 rpm->first_header = 0;
231                         }
232                         break;
233                 case ST_HEADER_DATA:
234                         n = rpm->hlen - rpm->hpos;
235                         if (n > avail_in - used)
236                                 n = avail_in - used;
237                         b += n;
238                         used += n;
239                         rpm->hpos += n;
240                         if (rpm->hpos == rpm->hlen)
241                                 rpm->state = ST_PADDING;
242                         break;
243                 case ST_PADDING:
244                         while (used < (size_t)avail_in) {
245                                 if (*b != 0) {
246                                         /* Read next header. */
247                                         rpm->state = ST_HEADER;
248                                         rpm->hpos = 0;
249                                         rpm->hlen = 0;
250                                         break;
251                                 }
252                                 b++;
253                                 used++;
254                         }
255                         break;
256                 case ST_ARCHIVE:
257                         *buff = b;
258                         total = avail_in;
259                         used = avail_in;
260                         break;
261                 }
262                 if (used == (size_t)avail_in) {
263                         rpm->total_in += used;
264                         __archive_read_filter_consume(self->upstream, used);
265                         b = NULL;
266                         used = 0;
267                 }
268         } while (total == 0 && avail_in > 0);
269
270         if (used > 0 && b != NULL) {
271                 rpm->total_in += used;
272                 __archive_read_filter_consume(self->upstream, used);
273         }
274         return (total);
275 }
276
277 static int
278 rpm_filter_close(struct archive_read_filter *self)
279 {
280         struct rpm *rpm;
281
282         rpm = (struct rpm *)self->data;
283         free(rpm);
284
285         return (ARCHIVE_OK);
286 }
287