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