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
  91                                 != LZMA_VLI_VALUE_UNKNOWN)
  92                         coder->buffer[coder->buffer_size] |= 0x01;
  93
  94                 if (coder->metadata.total_size != LZMA_VLI_VALUE_UNKNOWN)
  95                         coder->buffer[coder->buffer_size] |= 0x02;
  96
  97                 if (coder->metadata.uncompressed_size
  98                                 != LZMA_VLI_VALUE_UNKNOWN)
  99                         coder->buffer[coder->buffer_size] |= 0x04;
 100
 101                 if (coder->index_count > 0)
 102                         coder->buffer[coder->buffer_size] |= 0x08;
 103
 104                 if (coder->metadata.extra != NULL)
 105                         coder->buffer[coder->buffer_size] |= 0x80;
 106
 107                 ++coder->buffer_size;
 108                 coder->sequence = SEQ_HEADER_METADATA_SIZE;
 109                 break;
 110
 111         case SEQ_HEADER_METADATA_SIZE:
 112                 if (coder->metadata.header_metadata_size
 113                                 != LZMA_VLI_VALUE_UNKNOWN)
 114                         write_vli(coder->metadata.header_metadata_size);
 115
 116                 coder->sequence = SEQ_TOTAL_SIZE;
 117                 break;
 118
 119         case SEQ_TOTAL_SIZE:
 120                 if (coder->metadata.total_size != LZMA_VLI_VALUE_UNKNOWN)
 121                         write_vli(coder->metadata.total_size);
 122
 123                 coder->sequence = SEQ_UNCOMPRESSED_SIZE;
 124                 break;
 125
 126         case SEQ_UNCOMPRESSED_SIZE:
 127                 if (coder->metadata.uncompressed_size
 128                                 != LZMA_VLI_VALUE_UNKNOWN)
 129                         write_vli(coder->metadata.uncompressed_size);
 130
 131                 coder->sequence = SEQ_INDEX_COUNT;
 132                 break;
 133
 134         case SEQ_INDEX_COUNT:
 135                 if (coder->index_count == 0) {
 136                         if (coder->metadata.extra == NULL) {
 137                                 coder->sequence = SEQ_END;
 138                                 return LZMA_STREAM_END;
 139                         }
 140
 141                         coder->sequence = SEQ_EXTRA_ID;
 142                         break;
 143                 }
 144
 145                 write_vli(coder->index_count);
 146                 coder->sequence = SEQ_INDEX_TOTAL;
 147                 break;
 148
 149         case SEQ_INDEX_TOTAL:
 150                 write_vli(coder->index_current->total_size);
 151
 152                 coder->index_current = coder->index_current->next;
 153                 if (coder->index_current == NULL) {
 154                         coder->index_current = coder->metadata.index;
 155                         coder->sequence = SEQ_INDEX_UNCOMPRESSED;
 156                 }
 157
 158                 break;
 159
 160         case SEQ_INDEX_UNCOMPRESSED:
 161                 write_vli(coder->index_current->uncompressed_size);
 162
 163                 coder->index_current = coder->index_current->next;
 164                 if (coder->index_current != NULL)
 165                         break;
 166
 167                 if (coder->metadata.extra != NULL) {
 168                         coder->sequence = SEQ_EXTRA_ID;
 169                         break;
 170                 }
 171
 172                 coder->sequence = SEQ_END;
 173                 return LZMA_STREAM_END;
 174
 175         case SEQ_EXTRA_ID: {
 176                 const lzma_ret ret = lzma_vli_encode(
 177                                 coder->metadata.extra->id, &coder->pos, 1,
 178                                 coder->buffer, &coder->buffer_size,
 179                                 LZMA_BUFFER_SIZE);
 180                 switch (ret) {
 181                 case LZMA_OK:
 182                         break;
 183
 184                 case LZMA_STREAM_END:
 185                         coder->pos = 0;
 186
 187                         // Handle the special ID 0.
 188                         if (coder->metadata.extra->id == 0) {
 189                                 coder->metadata.extra
 190                                                 = coder->metadata.extra->next;
 191                                 if (coder->metadata.extra == NULL) {
 192                                         coder->sequence = SEQ_END;
 193                                         return LZMA_STREAM_END;
 194                                 }
 195
 196                                 coder->sequence = SEQ_EXTRA_ID;
 197
 198                         } else {
 199                                 coder->sequence = SEQ_EXTRA_SIZE;
 200                         }
 201
 202                         break;
 203
 204                 default:
 205                         return ret;
 206                 }
 207
 208                 break;
 209         }
 210
 211         case SEQ_EXTRA_SIZE:
 212                 if (coder->metadata.extra->size >= (lzma_vli)(SIZE_MAX))
 213                         return LZMA_HEADER_ERROR;
 214
 215                 write_vli(coder->metadata.extra->size);
 216                 coder->sequence = SEQ_EXTRA_DATA;
 217                 break;
 218
 219         case SEQ_EXTRA_DATA:
 220                 bufcpy(coder->metadata.extra->data, &coder->pos,
 221                                 coder->metadata.extra->size,
 222                                 coder->buffer, &coder->buffer_size,
 223                                 LZMA_BUFFER_SIZE);
 224
 225                 if ((size_t)(coder->metadata.extra->size) == coder->pos) {
 226                         coder->metadata.extra = coder->metadata.extra->next;
 227                         if (coder->metadata.extra == NULL) {
 228                                 coder->sequence = SEQ_END;
 229                                 return LZMA_STREAM_END;
 230                         }
 231
 232                         coder->pos = 0;
 233                         coder->sequence = SEQ_EXTRA_ID;
 234                 }
 235
 236                 break;
 237
 238         case SEQ_END:
 239                 // Everything is encoded. Let the compression code finish
 240                 // its work now.
 241                 return LZMA_STREAM_END;
 242         }
 243
 244         return LZMA_OK;
 245 }
 246
 247
 248 static lzma_ret
 249 metadata_encode(lzma_coder *coder, lzma_allocator *allocator,
 250                 const uint8_t *restrict in lzma_attribute((unused)),
 251                 size_t *restrict in_pos lzma_attribute((unused)),
 252                 size_t in_size lzma_attribute((unused)), uint8_t *restrict out,
 253                 size_t *restrict out_pos, size_t out_size,
 254                 lzma_action action lzma_attribute((unused)))
 255 {
 256         while (!coder->end_was_reached) {
 257                 // Flush coder->buffer if it isn't empty.
 258                 if (coder->buffer_size > 0) {
 259                         const lzma_ret ret = coder->block_encoder.code(
 260                                         coder->block_encoder.coder, allocator,
 261                                         coder->buffer, &coder->buffer_pos,
 262                                         coder->buffer_size,
 263                                         out, out_pos, out_size, LZMA_RUN);
 264                         if (coder->buffer_pos < coder->buffer_size
 265                                         || ret != LZMA_OK)
 266                                 return ret;
 267
 268                         coder->buffer_pos = 0;
 269                         coder->buffer_size = 0;
 270                 }
 271
 272                 const lzma_ret ret = process(coder);
 273
 274                 switch (ret) {
 275                 case LZMA_OK:
 276                         break;
 277
 278                 case LZMA_STREAM_END:
 279                         coder->end_was_reached = true;
 280                         break;
 281
 282                 default:
 283                         return ret;
 284                 }
 285         }
 286
 287         // Finish
 288         return coder->block_encoder.code(coder->block_encoder.coder, allocator,
 289                         coder->buffer, &coder->buffer_pos, coder->buffer_size,
 290                         out, out_pos, out_size, LZMA_FINISH);
 291 }
 292
 293
 294 static void
 295 metadata_encoder_end(lzma_coder *coder, lzma_allocator *allocator)
 296 {
 297         lzma_next_coder_end(&coder->block_encoder, allocator);
 298         lzma_free(coder, allocator);
 299         return;
 300 }
 301
 302
 303 static lzma_ret
 304 metadata_encoder_init(lzma_next_coder *next, lzma_allocator *allocator,
 305                 lzma_options_block *options, const lzma_metadata *metadata)
 306 {
 307         if (options == NULL || metadata == NULL)
 308                 return LZMA_PROG_ERROR;
 309
 310         if (next->coder == NULL) {
 311                 next->coder = lzma_alloc(sizeof(lzma_coder), allocator);
 312                 if (next->coder == NULL)
 313                         return LZMA_MEM_ERROR;
 314
 315                 next->code = &metadata_encode;
 316                 next->end = &metadata_encoder_end;
 317                 next->coder->block_encoder = LZMA_NEXT_CODER_INIT;
 318         }
 319
 320         next->coder->sequence = SEQ_FLAGS;
 321         next->coder->pos = 0;
 322         next->coder->metadata = *metadata;
 323         next->coder->index_count = 0;
 324         next->coder->index_current = metadata->index;
 325         next->coder->end_was_reached = false;
 326         next->coder->buffer_pos = 0;
 327         next->coder->buffer_size = 0;
 328
 329         // Count and validate the Index Records.
 330         {
 331                 const lzma_index *i = metadata->index;
 332                 while (i != NULL) {
 333                         if (i->total_size > LZMA_VLI_VALUE_MAX
 334                                         || i->uncompressed_size
 335                                                 > LZMA_VLI_VALUE_MAX)
 336                                 return LZMA_PROG_ERROR;
 337
 338                         ++next->coder->index_count;
 339                         i = i->next;
 340                 }
 341         }
 342
 343         // Initialize the Block encoder.
 344         return lzma_block_encoder_init(
 345                         &next->coder->block_encoder, allocator, options);
 346 }
 347
 348
 349 extern lzma_ret
 350 lzma_metadata_encoder_init(lzma_next_coder *next, lzma_allocator *allocator,
 351                 lzma_options_block *options, const lzma_metadata *metadata)
 352 {
 353         lzma_next_coder_init(metadata_encoder_init, next, allocator,
 354                         options, metadata);
 355 }
 356
 357
 358 extern LZMA_API lzma_ret
 359 lzma_metadata_encoder(lzma_stream *strm, lzma_options_block *options,
 360                 const lzma_metadata *metadata)
 361 {
 362         lzma_next_strm_init(strm, metadata_encoder_init, options, metadata);
 363
 364         strm->internal->supported_actions[LZMA_FINISH] = true;
 365
 366         return LZMA_OK;
 367 }
 368
 369
 370 extern LZMA_API lzma_vli
 371 lzma_metadata_size(const lzma_metadata *metadata)
 372 {
 373         lzma_vli size = 1; // Metadata Flags
 374
 375         // Validate header_metadata_size, total_size, and uncompressed_size.
 376         if (!lzma_vli_is_valid(metadata->header_metadata_size)
 377                         || !lzma_vli_is_valid(metadata->total_size)
 378                         || !lzma_vli_is_valid(metadata->uncompressed_size))
 379                 return 0;
 380
 381         // Add the sizes of these three fields.
 382         if (metadata->header_metadata_size != LZMA_VLI_VALUE_UNKNOWN)
 383                 size += lzma_vli_size(metadata->header_metadata_size);
 384
 385         if (metadata->total_size != LZMA_VLI_VALUE_UNKNOWN)
 386                 size += lzma_vli_size(metadata->total_size);
 387
 388         if (metadata->uncompressed_size != LZMA_VLI_VALUE_UNKNOWN)
 389                 size += lzma_vli_size(metadata->uncompressed_size);
 390
 391         // Index
 392         if (metadata->index != NULL) {
 393                 const lzma_index *i = metadata->index;
 394                 size_t count = 1;
 395
 396                 do {
 397                         const size_t x = lzma_vli_size(i->total_size);
 398                         const size_t y = lzma_vli_size(i->uncompressed_size);
 399                         if (x == 0 || y == 0)
 400                                 return 0;
 401
 402                         size += x + y;
 403                         ++count;
 404                         i = i->next;
 405
 406                 } while (i != NULL);
 407
 408                 const size_t tmp = lzma_vli_size(count);
 409                 if (tmp == 0)
 410                         return 0;
 411
 412                 size += tmp;
 413         }
 414
 415         // Extra
 416         {
 417                 const lzma_extra *e = metadata->extra;
 418                 while (e != NULL) {
 419                         // Validate the numbers.
 420                         if (e->id > LZMA_VLI_VALUE_MAX
 421                                         || e->size >= (lzma_vli)(SIZE_MAX))
 422                                 return 0;
 423
 424                         // Add the sizes.
 425                         size += lzma_vli_size(e->id);
 426                         if (e->id != 0) {
 427                                 size += lzma_vli_size(e->size);
 428                                 size += e->size;
 429                         }
 430
 431                         e = e->next;
 432                 }
 433         }
 434
 435         return size;
 436 }