src/liblzma/common/metadata_encoder.c

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //
   3 /// \file       metadata_encoder.c
   4 /// \brief      Encodes metadata to be stored into Metadata Blocks
   5 //
   6 //  Copyright (C) 2007 Lasse Collin
   7 //
   8 //  This library is free software; you can redistribute it and/or
   9 //  modify it under the terms of the GNU Lesser General Public
  10 //  License as published by the Free Software Foundation; either
  11 //  version 2.1 of the License, or (at your option) any later version.
  12 //
  13 //  This library is distributed in the hope that it will be useful,
  14 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 //  Lesser General Public License for more details.
  17 //
  18 ///////////////////////////////////////////////////////////////////////////////
  19
  20 #include "metadata_encoder.h"
  21 #include "block_encoder.h"
  22
  23
  24 struct lzma_coder_s {
  25         enum {
  26                 SEQ_FLAGS,
  27                 SEQ_HEADER_METADATA_SIZE,
  28                 SEQ_TOTAL_SIZE,
  29                 SEQ_UNCOMPRESSED_SIZE,
  30                 SEQ_INDEX_COUNT,
  31                 SEQ_INDEX_TOTAL,
  32                 SEQ_INDEX_UNCOMPRESSED,
  33                 SEQ_EXTRA_ID,
  34                 SEQ_EXTRA_SIZE,
  35                 SEQ_EXTRA_DATA,
  36                 SEQ_END,
  37         } sequence;
  38
  39         /// Position in variable-length integers
  40         size_t pos;
  41
  42         /// Local copy of the Metadata structure. Note that we keep
  43         /// a copy only of the main structure, not Index or Extra Records.
  44         lzma_metadata metadata;
  45
  46         /// Number of Records in Index
  47         size_t index_count;
  48
  49         /// Index Record currently being processed
  50         const lzma_index *index_current;
  51
  52         /// Block encoder for the encoded Metadata
  53         lzma_next_coder block_encoder;
  54
  55         /// True once everything except compression has been done.
  56         bool end_was_reached;
  57
  58         /// buffer[buffer_pos] is the first byte that needs to be compressed.
  59         size_t buffer_pos;
  60
  61         /// buffer[buffer_size] is the next position where a byte will be
  62         /// written by process().
  63         size_t buffer_size;
  64
  65         /// Temporary buffer to which encoded Metadata is written before
  66         /// it is compressed.
  67         uint8_t buffer[LZMA_BUFFER_SIZE];
  68 };
  69
  70
  71 #define write_vli(num) \
  72 do { \
  73         const lzma_ret ret = lzma_vli_encode(num, &coder->pos, 1, \
  74                         coder->buffer, &coder->buffer_size, \
  75                         LZMA_BUFFER_SIZE); \
  76         if (ret != LZMA_STREAM_END) \
  77                 return ret; \
  78         coder->pos = 0; \
  79 } while (0)
  80
  81
  82 static lzma_ret
  83 process(lzma_coder *coder)
  84 {
  85         while (coder->buffer_size < LZMA_BUFFER_SIZE)
  86         switch (coder->sequence) {
  87         case SEQ_FLAGS:
  88                 coder->buffer[coder->buffer_size] = 0;
  89
  90                 if (coder->metadata.header_metadata_size != 0)
  91                         coder->buffer[coder->buffer_size] |= 0x01;
  92
  93                 if (coder->metadata.total_size != LZMA_VLI_VALUE_UNKNOWN)
  94                         coder->buffer[coder->buffer_size] |= 0x02;
  95
  96                 if (coder->metadata.uncompressed_size
  97                                 != LZMA_VLI_VALUE_UNKNOWN)
  98                         coder->buffer[coder->buffer_size] |= 0x04;
  99
 100                 if (coder->index_count > 0)
 101                         coder->buffer[coder->buffer_size] |= 0x08;
 102
 103                 if (coder->metadata.extra != NULL)
 104                         coder->buffer[coder->buffer_size] |= 0x80;
 105
 106                 ++coder->buffer_size;
 107                 coder->sequence = SEQ_HEADER_METADATA_SIZE;
 108                 break;
 109
 110         case SEQ_HEADER_METADATA_SIZE:
 111                 if (coder->metadata.header_metadata_size != 0)
 112                         write_vli(coder->metadata.header_metadata_size);
 113
 114                 coder->sequence = SEQ_TOTAL_SIZE;
 115                 break;
 116
 117         case SEQ_TOTAL_SIZE:
 118                 if (coder->metadata.total_size != LZMA_VLI_VALUE_UNKNOWN)
 119                         write_vli(coder->metadata.total_size);
 120
 121                 coder->sequence = SEQ_UNCOMPRESSED_SIZE;
 122                 break;
 123
 124         case SEQ_UNCOMPRESSED_SIZE:
 125                 if (coder->metadata.uncompressed_size
 126                                 != LZMA_VLI_VALUE_UNKNOWN)
 127                         write_vli(coder->metadata.uncompressed_size);
 128
 129                 coder->sequence = SEQ_INDEX_COUNT;
 130                 break;
 131
 132         case SEQ_INDEX_COUNT:
 133                 if (coder->index_count == 0) {
 134                         if (coder->metadata.extra == NULL) {
 135                                 coder->sequence = SEQ_END;
 136                                 return LZMA_STREAM_END;
 137                         }
 138
 139                         coder->sequence = SEQ_EXTRA_ID;
 140                         break;
 141                 }
 142
 143                 write_vli(coder->index_count);
 144                 coder->sequence = SEQ_INDEX_TOTAL;
 145                 break;
 146
 147         case SEQ_INDEX_TOTAL:
 148                 write_vli(coder->index_current->total_size);
 149
 150                 coder->index_current = coder->index_current->next;
 151                 if (coder->index_current == NULL) {
 152                         coder->index_current = coder->metadata.index;
 153                         coder->sequence = SEQ_INDEX_UNCOMPRESSED;
 154                 }
 155
 156                 break;
 157
 158         case SEQ_INDEX_UNCOMPRESSED:
 159                 write_vli(coder->index_current->uncompressed_size);
 160
 161                 coder->index_current = coder->index_current->next;
 162                 if (coder->index_current != NULL)
 163                         break;
 164
 165                 if (coder->metadata.extra != NULL) {
 166                         coder->sequence = SEQ_EXTRA_ID;
 167                         break;
 168                 }
 169
 170                 coder->sequence = SEQ_END;
 171                 return LZMA_STREAM_END;
 172
 173         case SEQ_EXTRA_ID: {
 174                 const lzma_ret ret = lzma_vli_encode(
 175                                 coder->metadata.extra->id, &coder->pos, 1,
 176                                 coder->buffer, &coder->buffer_size,
 177                                 LZMA_BUFFER_SIZE);
 178                 switch (ret) {
 179                 case LZMA_OK:
 180                         break;
 181
 182                 case LZMA_STREAM_END:
 183                         coder->pos = 0;
 184
 185                         // Handle the special ID 0.
 186                         if (coder->metadata.extra->id == 0) {
 187                                 coder->metadata.extra
 188                                                 = coder->metadata.extra->next;
 189                                 if (coder->metadata.extra == NULL) {
 190                                         coder->sequence = SEQ_END;
 191                                         return LZMA_STREAM_END;
 192                                 }
 193
 194                                 coder->sequence = SEQ_EXTRA_ID;
 195
 196                         } else {
 197                                 coder->sequence = SEQ_EXTRA_SIZE;
 198                         }
 199
 200                         break;
 201
 202                 default:
 203                         return ret;
 204                 }
 205
 206                 break;
 207         }
 208
 209         case SEQ_EXTRA_SIZE:
 210                 if (coder->metadata.extra->size >= (lzma_vli)(SIZE_MAX))
 211                         return LZMA_HEADER_ERROR;
 212
 213                 write_vli(coder->metadata.extra->size);
 214                 coder->sequence = SEQ_EXTRA_DATA;
 215                 break;
 216
 217         case SEQ_EXTRA_DATA:
 218                 bufcpy(coder->metadata.extra->data, &coder->pos,
 219                                 coder->metadata.extra->size,
 220                                 coder->buffer, &coder->buffer_size,
 221                                 LZMA_BUFFER_SIZE);
 222
 223                 if ((size_t)(coder->metadata.extra->size) == coder->pos) {
 224                         coder->metadata.extra = coder->metadata.extra->next;
 225                         if (coder->metadata.extra == NULL) {
 226                                 coder->sequence = SEQ_END;
 227                                 return LZMA_STREAM_END;
 228                         }
 229
 230                         coder->pos = 0;
 231                         coder->sequence = SEQ_EXTRA_ID;
 232                 }
 233
 234                 break;
 235
 236         case SEQ_END:
 237                 // Everything is encoded. Let the compression code finish
 238                 // its work now.
 239                 return LZMA_STREAM_END;
 240         }
 241
 242         return LZMA_OK;
 243 }
 244
 245
 246 static lzma_ret
 247 metadata_encode(lzma_coder *coder, lzma_allocator *allocator,
 248                 const uint8_t *restrict in lzma_attribute((unused)),
 249                 size_t *restrict in_pos lzma_attribute((unused)),
 250                 size_t in_size lzma_attribute((unused)), uint8_t *restrict out,
 251                 size_t *restrict out_pos, size_t out_size,
 252                 lzma_action action lzma_attribute((unused)))
 253 {
 254         while (!coder->end_was_reached) {
 255                 // Flush coder->buffer if it isn't empty.
 256                 if (coder->buffer_size > 0) {
 257                         const lzma_ret ret = coder->block_encoder.code(
 258                                         coder->block_encoder.coder, allocator,
 259                                         coder->buffer, &coder->buffer_pos,
 260                                         coder->buffer_size,
 261                                         out, out_pos, out_size, LZMA_RUN);
 262                         if (coder->buffer_pos < coder->buffer_size
 263                                         || ret != LZMA_OK)
 264                                 return ret;
 265
 266                         coder->buffer_pos = 0;
 267                         coder->buffer_size = 0;
 268                 }
 269
 270                 const lzma_ret ret = process(coder);
 271
 272                 switch (ret) {
 273                 case LZMA_OK:
 274                         break;
 275
 276                 case LZMA_STREAM_END:
 277                         coder->end_was_reached = true;
 278                         break;
 279
 280                 default:
 281                         return ret;
 282                 }
 283         }
 284
 285         // Finish
 286         return coder->block_encoder.code(coder->block_encoder.coder, allocator,
 287                         coder->buffer, &coder->buffer_pos, coder->buffer_size,
 288                         out, out_pos, out_size, LZMA_FINISH);
 289 }
 290
 291
 292 static void
 293 metadata_encoder_end(lzma_coder *coder, lzma_allocator *allocator)
 294 {
 295         lzma_next_coder_end(&coder->block_encoder, allocator);
 296         lzma_free(coder, allocator);
 297         return;
 298 }
 299
 300
 301 static lzma_ret
 302 metadata_encoder_init(lzma_next_coder *next, lzma_allocator *allocator,
 303                 lzma_options_block *options, const lzma_metadata *metadata)
 304 {
 305         if (options == NULL || metadata == NULL)
 306                 return LZMA_PROG_ERROR;
 307
 308         if (next->coder == NULL) {
 309                 next->coder = lzma_alloc(sizeof(lzma_coder), allocator);
 310                 if (next->coder == NULL)
 311                         return LZMA_MEM_ERROR;
 312
 313                 next->code = &metadata_encode;
 314                 next->end = &metadata_encoder_end;
 315                 next->coder->block_encoder = LZMA_NEXT_CODER_INIT;
 316         }
 317
 318         next->coder->sequence = SEQ_FLAGS;
 319         next->coder->pos = 0;
 320         next->coder->metadata = *metadata;
 321         next->coder->index_count = 0;
 322         next->coder->index_current = metadata->index;
 323         next->coder->end_was_reached = false;
 324         next->coder->buffer_pos = 0;
 325         next->coder->buffer_size = 0;
 326
 327         // Count and validate the Index Records.
 328         {
 329                 const lzma_index *i = metadata->index;
 330                 while (i != NULL) {
 331                         if (i->total_size > LZMA_VLI_VALUE_MAX
 332                                         || i->uncompressed_size
 333                                                 > LZMA_VLI_VALUE_MAX)
 334                                 return LZMA_PROG_ERROR;
 335
 336                         ++next->coder->index_count;
 337                         i = i->next;
 338                 }
 339         }
 340
 341         // Initialize the Block encoder.
 342         return lzma_block_encoder_init(
 343                         &next->coder->block_encoder, allocator, options);
 344 }
 345
 346
 347 extern lzma_ret
 348 lzma_metadata_encoder_init(lzma_next_coder *next, lzma_allocator *allocator,
 349                 lzma_options_block *options, const lzma_metadata *metadata)
 350 {
 351         lzma_next_coder_init(metadata_encoder_init, next, allocator,
 352                         options, metadata);
 353 }
 354
 355
 356 extern LZMA_API lzma_ret
 357 lzma_metadata_encoder(lzma_stream *strm, lzma_options_block *options,
 358                 const lzma_metadata *metadata)
 359 {
 360         lzma_next_strm_init(strm, metadata_encoder_init, options, metadata);
 361
 362         strm->internal->supported_actions[LZMA_FINISH] = true;
 363
 364         return LZMA_OK;
 365 }
 366
 367
 368 extern LZMA_API lzma_vli
 369 lzma_metadata_size(const lzma_metadata *metadata)
 370 {
 371         lzma_vli size = 1; // Metadata Flags
 372
 373         // Validate header_metadata_size, total_size, and uncompressed_size.
 374         if (metadata->header_metadata_size > LZMA_VLI_VALUE_MAX
 375                         || !lzma_vli_is_valid(metadata->total_size)
 376                         || metadata->total_size == 0
 377                         || !lzma_vli_is_valid(metadata->uncompressed_size))
 378                 return 0;
 379
 380         // Add the sizes of these three fields.
 381         if (metadata->header_metadata_size != 0)
 382                 size += lzma_vli_size(metadata->header_metadata_size);
 383
 384         if (metadata->total_size != LZMA_VLI_VALUE_UNKNOWN)
 385                 size += lzma_vli_size(metadata->total_size);
 386
 387         if (metadata->uncompressed_size != LZMA_VLI_VALUE_UNKNOWN)
 388                 size += lzma_vli_size(metadata->uncompressed_size);
 389
 390         // Index
 391         if (metadata->index != NULL) {
 392                 const lzma_index *i = metadata->index;
 393                 size_t count = 1;
 394
 395                 do {
 396                         const size_t x = lzma_vli_size(i->total_size);
 397                         const size_t y = lzma_vli_size(i->uncompressed_size);
 398                         if (x == 0 || y == 0)
 399                                 return 0;
 400
 401                         size += x + y;
 402                         ++count;
 403                         i = i->next;
 404
 405                 } while (i != NULL);
 406
 407                 const size_t tmp = lzma_vli_size(count);
 408                 if (tmp == 0)
 409                         return 0;
 410
 411                 size += tmp;
 412         }
 413
 414         // Extra
 415         {
 416                 const lzma_extra *e = metadata->extra;
 417                 while (e != NULL) {
 418                         // Validate the numbers.
 419                         if (e->id > LZMA_VLI_VALUE_MAX
 420                                         || e->size >= (lzma_vli)(SIZE_MAX))
 421                                 return 0;
 422
 423                         // Add the sizes.
 424                         size += lzma_vli_size(e->id);
 425                         if (e->id != 0) {
 426                                 size += lzma_vli_size(e->size);
 427                                 size += e->size;
 428                         }
 429
 430                         e = e->next;
 431                 }
 432         }
 433
 434         return size;
 435 }