bfd/compress.c

   1 /* Compressed section support (intended for debug sections).
   2    Copyright (C) 2008-2019 Free Software Foundation, Inc.
   3
   4    This file is part of BFD, the Binary File Descriptor library.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20
  21 #include "sysdep.h"
  22 #include <zlib.h>
  23 #include "bfd.h"
  24 #include "libbfd.h"
  25 #include "safe-ctype.h"
  26
  27 #define MAX_COMPRESSION_HEADER_SIZE 24
  28
  29 static bfd_boolean
  30 decompress_contents (bfd_byte *compressed_buffer,
  31                      bfd_size_type compressed_size,
  32                      bfd_byte *uncompressed_buffer,
  33                      bfd_size_type uncompressed_size)
  34 {
  35   z_stream strm;
  36   int rc;
  37
  38   /* It is possible the section consists of several compressed
  39      buffers concatenated together, so we uncompress in a loop.  */
  40   /* PR 18313: The state field in the z_stream structure is supposed
  41      to be invisible to the user (ie us), but some compilers will
  42      still complain about it being used without initialisation.  So
  43      we first zero the entire z_stream structure and then set the fields
  44      that we need.  */
  45   memset (& strm, 0, sizeof strm);
  46   strm.avail_in = compressed_size;
  47   strm.next_in = (Bytef*) compressed_buffer;
  48   strm.avail_out = uncompressed_size;
  49
  50   BFD_ASSERT (Z_OK == 0);
  51   rc = inflateInit (&strm);
  52   while (strm.avail_in > 0 && strm.avail_out > 0)
  53     {
  54       if (rc != Z_OK)
  55         break;
  56       strm.next_out = ((Bytef*) uncompressed_buffer
  57                        + (uncompressed_size - strm.avail_out));
  58       rc = inflate (&strm, Z_FINISH);
  59       if (rc != Z_STREAM_END)
  60         break;
  61       rc = inflateReset (&strm);
  62     }
  63   rc |= inflateEnd (&strm);
  64   return rc == Z_OK && strm.avail_out == 0;
  65 }
  66
  67 /* Compress data of the size specified in @var{uncompressed_size}
  68    and pointed to by @var{uncompressed_buffer} using zlib and store
  69    as the contents field.  This function assumes the contents
  70    field was allocated using bfd_malloc() or equivalent.
  71
  72    Return the uncompressed size if the full section contents is
  73    compressed successfully.  Otherwise return 0.  */
  74
  75 static bfd_size_type
  76 bfd_compress_section_contents (bfd *abfd, sec_ptr sec,
  77                                bfd_byte *uncompressed_buffer,
  78                                bfd_size_type uncompressed_size)
  79 {
  80   uLong compressed_size;
  81   bfd_byte *buffer;
  82   bfd_size_type buffer_size;
  83   bfd_boolean decompress;
  84   int zlib_size = 0;
  85   int orig_compression_header_size;
  86   bfd_size_type orig_uncompressed_size;
  87   unsigned int orig_uncompressed_alignment_pow;
  88   int header_size = bfd_get_compression_header_size (abfd, NULL);
  89   bfd_boolean compressed
  90     = bfd_is_section_compressed_with_header (abfd, sec,
  91                                              &orig_compression_header_size,
  92                                              &orig_uncompressed_size,
  93                                              &orig_uncompressed_alignment_pow);
  94
  95   /* Either ELF compression header or the 12-byte, "ZLIB" + 8-byte size,
  96      overhead in .zdebug* section.  */
  97   if (!header_size)
  98      header_size = 12;
  99
 100   if (compressed)
 101     {
 102       /* We shouldn't decompress unsupported compressed section.  */
 103       if (orig_compression_header_size < 0)
 104         abort ();
 105
 106       /* Different compression schemes.  Just move the compressed section
 107          contents to the right position. */
 108       if (orig_compression_header_size == 0)
 109         {
 110           /* Convert it from .zdebug* section.  Get the uncompressed
 111              size first.  We need to subtract the 12-byte overhead in
 112              .zdebug* section.  Set orig_compression_header_size to
 113              the 12-bye overhead.  */
 114           orig_compression_header_size = 12;
 115           zlib_size = uncompressed_size - 12;
 116         }
 117       else
 118         {
 119           /* Convert it to .zdebug* section.  */
 120           zlib_size = uncompressed_size - orig_compression_header_size;
 121         }
 122
 123       /* Add the header size.  */
 124       compressed_size = zlib_size + header_size;
 125     }
 126   else
 127     compressed_size = compressBound (uncompressed_size) + header_size;
 128
 129   /* Uncompress if it leads to smaller size.  */
 130   if (compressed && compressed_size > orig_uncompressed_size)
 131     {
 132       decompress = TRUE;
 133       buffer_size = orig_uncompressed_size;
 134     }
 135   else
 136     {
 137       decompress = FALSE;
 138       buffer_size = compressed_size;
 139     }
 140   buffer = (bfd_byte *) bfd_alloc (abfd, buffer_size);
 141   if (buffer == NULL)
 142     return 0;
 143
 144   if (compressed)
 145     {
 146       sec->size = orig_uncompressed_size;
 147       if (decompress)
 148         {
 149           if (!decompress_contents (uncompressed_buffer
 150                                     + orig_compression_header_size,
 151                                     zlib_size, buffer, buffer_size))
 152             {
 153               bfd_set_error (bfd_error_bad_value);
 154               bfd_release (abfd, buffer);
 155               return 0;
 156             }
 157           free (uncompressed_buffer);
 158           bfd_set_section_alignment (abfd, sec,
 159                                      orig_uncompressed_alignment_pow);
 160
 161           sec->contents = buffer;
 162           sec->compress_status = COMPRESS_SECTION_DONE;
 163           return orig_uncompressed_size;
 164         }
 165       else
 166         {
 167           bfd_update_compression_header (abfd, buffer, sec);
 168           memmove (buffer + header_size,
 169                    uncompressed_buffer + orig_compression_header_size,
 170                    zlib_size);
 171         }
 172     }
 173   else
 174     {
 175       if (compress ((Bytef*) buffer + header_size,
 176                     &compressed_size,
 177                     (const Bytef*) uncompressed_buffer,
 178                     uncompressed_size) != Z_OK)
 179         {
 180           bfd_release (abfd, buffer);
 181           bfd_set_error (bfd_error_bad_value);
 182           return 0;
 183         }
 184
 185       compressed_size += header_size;
 186       /* PR binutils/18087: If compression didn't make the section smaller,
 187          just keep it uncompressed.  */
 188       if (compressed_size < uncompressed_size)
 189         bfd_update_compression_header (abfd, buffer, sec);
 190       else
 191         {
 192           /* NOTE: There is a small memory leak here since
 193              uncompressed_buffer is malloced and won't be freed.  */
 194           bfd_release (abfd, buffer);
 195           sec->contents = uncompressed_buffer;
 196           sec->compress_status = COMPRESS_SECTION_NONE;
 197           return uncompressed_size;
 198         }
 199     }
 200
 201   free (uncompressed_buffer);
 202   sec->contents = buffer;
 203   sec->size = compressed_size;
 204   sec->compress_status = COMPRESS_SECTION_DONE;
 205
 206   return uncompressed_size;
 207 }
 208
 209 /*
 210 FUNCTION
 211         bfd_get_full_section_contents
 212
 213 SYNOPSIS
 214         bfd_boolean bfd_get_full_section_contents
 215           (bfd *abfd, asection *section, bfd_byte **ptr);
 216
 217 DESCRIPTION
 218         Read all data from @var{section} in BFD @var{abfd}, decompress
 219         if needed, and store in @var{*ptr}.  If @var{*ptr} is NULL,
 220         return @var{*ptr} with memory malloc'd by this function.
 221
 222         Return @code{TRUE} if the full section contents is retrieved
 223         successfully.  If the section has no contents then this function
 224         returns @code{TRUE} but @var{*ptr} is set to NULL.
 225 */
 226
 227 bfd_boolean
 228 bfd_get_full_section_contents (bfd *abfd, sec_ptr sec, bfd_byte **ptr)
 229 {
 230   bfd_size_type sz;
 231   bfd_byte *p = *ptr;
 232   bfd_boolean ret;
 233   bfd_size_type save_size;
 234   bfd_size_type save_rawsize;
 235   bfd_byte *compressed_buffer;
 236   unsigned int compression_header_size;
 237
 238   if (abfd->direction != write_direction && sec->rawsize != 0)
 239     sz = sec->rawsize;
 240   else
 241     sz = sec->size;
 242   if (sz == 0)
 243     {
 244       *ptr = NULL;
 245       return TRUE;
 246     }
 247
 248   switch (sec->compress_status)
 249     {
 250     case COMPRESS_SECTION_NONE:
 251       if (p == NULL)
 252         {
 253           ufile_ptr filesize = bfd_get_file_size (abfd);
 254           if (filesize > 0
 255               && filesize < sz
 256               /* The MMO file format supports its own special compression
 257                  technique, but it uses COMPRESS_SECTION_NONE when loading
 258                  a section's contents.  */
 259               && bfd_get_flavour (abfd) != bfd_target_mmo_flavour)
 260             {
 261               /* PR 24708: Avoid attempts to allocate a ridiculous amount
 262                  of memory.  */
 263               bfd_set_error (bfd_error_no_memory);
 264               _bfd_error_handler
 265                 /* xgettext:c-format */
 266                 (_("error: %pB(%pA) section size (%#" PRIx64 " bytes) is larger than file size (%#" PRIx64 " bytes)"),
 267                  abfd, sec, (uint64_t) sz, (uint64_t) filesize);
 268               return FALSE;
 269             }
 270           p = (bfd_byte *) bfd_malloc (sz);
 271           if (p == NULL)
 272             {
 273               /* PR 20801: Provide a more helpful error message.  */
 274               if (bfd_get_error () == bfd_error_no_memory)
 275                 _bfd_error_handler
 276                   /* xgettext:c-format */
 277                   (_("error: %pB(%pA) is too large (%#" PRIx64 " bytes)"),
 278                   abfd, sec, (uint64_t) sz);
 279               return FALSE;
 280             }
 281         }
 282
 283       if (!bfd_get_section_contents (abfd, sec, p, 0, sz))
 284         {
 285           if (*ptr != p)
 286             free (p);
 287           return FALSE;
 288         }
 289       *ptr = p;
 290       return TRUE;
 291
 292     case DECOMPRESS_SECTION_SIZED:
 293       /* Read in the full compressed section contents.  */
 294       compressed_buffer = (bfd_byte *) bfd_malloc (sec->compressed_size);
 295       if (compressed_buffer == NULL)
 296         return FALSE;
 297       save_rawsize = sec->rawsize;
 298       save_size = sec->size;
 299       /* Clear rawsize, set size to compressed size and set compress_status
 300          to COMPRESS_SECTION_NONE.  If the compressed size is bigger than
 301          the uncompressed size, bfd_get_section_contents will fail.  */
 302       sec->rawsize = 0;
 303       sec->size = sec->compressed_size;
 304       sec->compress_status = COMPRESS_SECTION_NONE;
 305       ret = bfd_get_section_contents (abfd, sec, compressed_buffer,
 306                                       0, sec->compressed_size);
 307       /* Restore rawsize and size.  */
 308       sec->rawsize = save_rawsize;
 309       sec->size = save_size;
 310       sec->compress_status = DECOMPRESS_SECTION_SIZED;
 311       if (!ret)
 312         goto fail_compressed;
 313
 314       if (p == NULL)
 315         p = (bfd_byte *) bfd_malloc (sz);
 316       if (p == NULL)
 317         goto fail_compressed;
 318
 319       compression_header_size = bfd_get_compression_header_size (abfd, sec);
 320       if (compression_header_size == 0)
 321         /* Set header size to the zlib header size if it is a
 322            SHF_COMPRESSED section.  */
 323         compression_header_size = 12;
 324       if (!decompress_contents (compressed_buffer + compression_header_size,
 325                                 sec->compressed_size - compression_header_size, p, sz))
 326         {
 327           bfd_set_error (bfd_error_bad_value);
 328           if (p != *ptr)
 329             free (p);
 330         fail_compressed:
 331           free (compressed_buffer);
 332           return FALSE;
 333         }
 334
 335       free (compressed_buffer);
 336       *ptr = p;
 337       return TRUE;
 338
 339     case COMPRESS_SECTION_DONE:
 340       if (sec->contents == NULL)
 341         return FALSE;
 342       if (p == NULL)
 343         {
 344           p = (bfd_byte *) bfd_malloc (sz);
 345           if (p == NULL)
 346             return FALSE;
 347           *ptr = p;
 348         }
 349       /* PR 17512; file: 5bc29788.  */
 350       if (p != sec->contents)
 351         memcpy (p, sec->contents, sz);
 352       return TRUE;
 353
 354     default:
 355       abort ();
 356     }
 357 }
 358
 359 /*
 360 FUNCTION
 361         bfd_cache_section_contents
 362
 363 SYNOPSIS
 364         void bfd_cache_section_contents
 365           (asection *sec, void *contents);
 366
 367 DESCRIPTION
 368         Stash @var(contents) so any following reads of @var(sec) do
 369         not need to decompress again.
 370 */
 371
 372 void
 373 bfd_cache_section_contents (asection *sec, void *contents)
 374 {
 375   if (sec->compress_status == DECOMPRESS_SECTION_SIZED)
 376     sec->compress_status = COMPRESS_SECTION_DONE;
 377   sec->contents = contents;
 378   sec->flags |= SEC_IN_MEMORY;
 379 }
 380
 381 /*
 382 FUNCTION
 383         bfd_is_section_compressed_with_header
 384
 385 SYNOPSIS
 386         bfd_boolean bfd_is_section_compressed_with_header
 387           (bfd *abfd, asection *section,
 388           int *compression_header_size_p,
 389           bfd_size_type *uncompressed_size_p,
 390           unsigned int *uncompressed_alignment_power_p);
 391
 392 DESCRIPTION
 393         Return @code{TRUE} if @var{section} is compressed.  Compression
 394         header size is returned in @var{compression_header_size_p},
 395         uncompressed size is returned in @var{uncompressed_size_p}
 396         and the uncompressed data alignement power is returned in
 397         @var{uncompressed_align_pow_p}.  If compression is
 398         unsupported, compression header size is returned with -1
 399         and uncompressed size is returned with 0.
 400 */
 401
 402 bfd_boolean
 403 bfd_is_section_compressed_with_header (bfd *abfd, sec_ptr sec,
 404                                        int *compression_header_size_p,
 405                                        bfd_size_type *uncompressed_size_p,
 406                                        unsigned int *uncompressed_align_pow_p)
 407 {
 408   bfd_byte header[MAX_COMPRESSION_HEADER_SIZE];
 409   int compression_header_size;
 410   int header_size;
 411   unsigned int saved = sec->compress_status;
 412   bfd_boolean compressed;
 413
 414   *uncompressed_align_pow_p = 0;
 415
 416   compression_header_size = bfd_get_compression_header_size (abfd, sec);
 417   if (compression_header_size > MAX_COMPRESSION_HEADER_SIZE)
 418     abort ();
 419   header_size = compression_header_size ? compression_header_size : 12;
 420
 421   /* Don't decompress the section.  */
 422   sec->compress_status = COMPRESS_SECTION_NONE;
 423
 424   /* Read the header.  */
 425   if (bfd_get_section_contents (abfd, sec, header, 0, header_size))
 426     {
 427       if (compression_header_size == 0)
 428         /* In this case, it should be "ZLIB" followed by the uncompressed
 429            section size, 8 bytes in big-endian order.  */
 430         compressed = CONST_STRNEQ ((char*) header , "ZLIB");
 431       else
 432         compressed = TRUE;
 433     }
 434   else
 435     compressed = FALSE;
 436
 437   *uncompressed_size_p = sec->size;
 438   if (compressed)
 439     {
 440       if (compression_header_size != 0)
 441         {
 442           if (!bfd_check_compression_header (abfd, header, sec,
 443                                              uncompressed_size_p,
 444                                              uncompressed_align_pow_p))
 445             compression_header_size = -1;
 446         }
 447       /* Check for the pathalogical case of a debug string section that
 448          contains the string ZLIB.... as the first entry.  We assume that
 449          no uncompressed .debug_str section would ever be big enough to
 450          have the first byte of its (big-endian) size be non-zero.  */
 451       else if (strcmp (sec->name, ".debug_str") == 0
 452                && ISPRINT (header[4]))
 453         compressed = FALSE;
 454       else
 455         *uncompressed_size_p = bfd_getb64 (header + 4);
 456     }
 457
 458   /* Restore compress_status.  */
 459   sec->compress_status = saved;
 460   *compression_header_size_p = compression_header_size;
 461   return compressed;
 462 }
 463
 464 /*
 465 FUNCTION
 466         bfd_is_section_compressed
 467
 468 SYNOPSIS
 469         bfd_boolean bfd_is_section_compressed
 470           (bfd *abfd, asection *section);
 471
 472 DESCRIPTION
 473         Return @code{TRUE} if @var{section} is compressed.
 474 */
 475
 476 bfd_boolean
 477 bfd_is_section_compressed (bfd *abfd, sec_ptr sec)
 478 {
 479   int compression_header_size;
 480   bfd_size_type uncompressed_size;
 481   unsigned int uncompressed_align_power;
 482   return (bfd_is_section_compressed_with_header (abfd, sec,
 483                                                  &compression_header_size,
 484                                                  &uncompressed_size,
 485                                                  &uncompressed_align_power)
 486           && compression_header_size >= 0
 487           && uncompressed_size > 0);
 488 }
 489
 490 /*
 491 FUNCTION
 492         bfd_init_section_decompress_status
 493
 494 SYNOPSIS
 495         bfd_boolean bfd_init_section_decompress_status
 496           (bfd *abfd, asection *section);
 497
 498 DESCRIPTION
 499         Record compressed section size, update section size with
 500         decompressed size and set compress_status to
 501         DECOMPRESS_SECTION_SIZED.
 502
 503         Return @code{FALSE} if the section is not a valid compressed
 504         section.  Otherwise, return @code{TRUE}.
 505 */
 506
 507 bfd_boolean
 508 bfd_init_section_decompress_status (bfd *abfd, sec_ptr sec)
 509 {
 510   bfd_byte header[MAX_COMPRESSION_HEADER_SIZE];
 511   int compression_header_size;
 512   int header_size;
 513   bfd_size_type uncompressed_size;
 514   unsigned int uncompressed_alignment_power = 0;
 515
 516   compression_header_size = bfd_get_compression_header_size (abfd, sec);
 517   if (compression_header_size > MAX_COMPRESSION_HEADER_SIZE)
 518     abort ();
 519   header_size = compression_header_size ? compression_header_size : 12;
 520
 521   /* Read the header.  */
 522   if (sec->rawsize != 0
 523       || sec->contents != NULL
 524       || sec->compress_status != COMPRESS_SECTION_NONE
 525       || !bfd_get_section_contents (abfd, sec, header, 0, header_size))
 526     {
 527       bfd_set_error (bfd_error_invalid_operation);
 528       return FALSE;
 529     }
 530
 531   if (compression_header_size == 0)
 532     {
 533       /* In this case, it should be "ZLIB" followed by the uncompressed
 534          section size, 8 bytes in big-endian order.  */
 535       if (! CONST_STRNEQ ((char*) header, "ZLIB"))
 536         {
 537           bfd_set_error (bfd_error_wrong_format);
 538           return FALSE;
 539         }
 540       uncompressed_size = bfd_getb64 (header + 4);
 541     }
 542   else if (!bfd_check_compression_header (abfd, header, sec,
 543                                           &uncompressed_size,
 544                                           &uncompressed_alignment_power))
 545     {
 546       bfd_set_error (bfd_error_wrong_format);
 547       return FALSE;
 548     }
 549
 550   sec->compressed_size = sec->size;
 551   sec->size = uncompressed_size;
 552   bfd_set_section_alignment (abfd, sec, uncompressed_alignment_power);
 553   sec->compress_status = DECOMPRESS_SECTION_SIZED;
 554
 555   return TRUE;
 556 }
 557
 558 /*
 559 FUNCTION
 560         bfd_init_section_compress_status
 561
 562 SYNOPSIS
 563         bfd_boolean bfd_init_section_compress_status
 564           (bfd *abfd, asection *section);
 565
 566 DESCRIPTION
 567         If open for read, compress section, update section size with
 568         compressed size and set compress_status to COMPRESS_SECTION_DONE.
 569
 570         Return @code{FALSE} if the section is not a valid compressed
 571         section.  Otherwise, return @code{TRUE}.
 572 */
 573
 574 bfd_boolean
 575 bfd_init_section_compress_status (bfd *abfd, sec_ptr sec)
 576 {
 577   bfd_size_type uncompressed_size;
 578   bfd_byte *uncompressed_buffer;
 579
 580   /* Error if not opened for read.  */
 581   if (abfd->direction != read_direction
 582       || sec->size == 0
 583       || sec->rawsize != 0
 584       || sec->contents != NULL
 585       || sec->compress_status != COMPRESS_SECTION_NONE)
 586     {
 587       bfd_set_error (bfd_error_invalid_operation);
 588       return FALSE;
 589     }
 590
 591   /* Read in the full section contents and compress it.  */
 592   uncompressed_size = sec->size;
 593   uncompressed_buffer = (bfd_byte *) bfd_malloc (uncompressed_size);
 594   /* PR 21431 */
 595   if (uncompressed_buffer == NULL)
 596     return FALSE;
 597
 598   if (!bfd_get_section_contents (abfd, sec, uncompressed_buffer,
 599                                  0, uncompressed_size))
 600     return FALSE;
 601
 602   uncompressed_size = bfd_compress_section_contents (abfd, sec,
 603                                                      uncompressed_buffer,
 604                                                      uncompressed_size);
 605   return uncompressed_size != 0;
 606 }
 607
 608 /*
 609 FUNCTION
 610         bfd_compress_section
 611
 612 SYNOPSIS
 613         bfd_boolean bfd_compress_section
 614           (bfd *abfd, asection *section, bfd_byte *uncompressed_buffer);
 615
 616 DESCRIPTION
 617         If open for write, compress section, update section size with
 618         compressed size and set compress_status to COMPRESS_SECTION_DONE.
 619
 620         Return @code{FALSE} if compression fail.  Otherwise, return
 621         @code{TRUE}.
 622 */
 623
 624 bfd_boolean
 625 bfd_compress_section (bfd *abfd, sec_ptr sec, bfd_byte *uncompressed_buffer)
 626 {
 627   bfd_size_type uncompressed_size = sec->size;
 628
 629   /* Error if not opened for write.  */
 630   if (abfd->direction != write_direction
 631       || uncompressed_size == 0
 632       || uncompressed_buffer == NULL
 633       || sec->contents != NULL
 634       || sec->compressed_size != 0
 635       || sec->compress_status != COMPRESS_SECTION_NONE)
 636     {
 637       bfd_set_error (bfd_error_invalid_operation);
 638       return FALSE;
 639     }
 640
 641   /* Compress it.  */
 642   return bfd_compress_section_contents (abfd, sec, uncompressed_buffer,
 643                                         uncompressed_size) != 0;
 644 }