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->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