contrib/libarchive/libarchive/archive_read_support_filter_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 #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->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
  96 static int
  97 rpm_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
 136 static int
 137 rpm_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
 160 static ssize_t
 161 rpm_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                                                     "Unrecoginized 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
 279 static int
 280 rpm_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