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