bfd/compress.c

   1 /* Compressed section support (intended for debug sections).
   2    Copyright (C) 2008-2018 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           p = (bfd_byte *) bfd_malloc (sz);
 254           if (p == NULL)
 255             {
 256               /* PR 20801: Provide a more helpful error message.  */
 257               if (bfd_get_error () == bfd_error_no_memory)
 258                 _bfd_error_handler
 259                   /* xgettext:c-format */
 260                   (_("error: %pB(%pA) is too large (%#" PRIx64 " bytes)"),
 261                   abfd, sec, (uint64_t) sz);
 262               return FALSE;
 263             }
 264         }
 265
 266       if (!bfd_get_section_contents (abfd, sec, p, 0, sz))
 267         {
 268           if (*ptr != p)
 269             free (p);
 270           return FALSE;
 271         }
 272       *ptr = p;
 273       return TRUE;
 274
 275     case DECOMPRESS_SECTION_SIZED:
 276       /* Read in the full compressed section contents.  */
 277       compressed_buffer = (bfd_byte *) bfd_malloc (sec->compressed_size);
 278       if (compressed_buffer == NULL)
 279         return FALSE;
 280       save_rawsize = sec->rawsize;
 281       save_size = sec->size;
 282       /* Clear rawsize, set size to compressed size and set compress_status
 283          to COMPRESS_SECTION_NONE.  If the compressed size is bigger than
 284          the uncompressed size, bfd_get_section_contents will fail.  */
 285       sec->rawsize = 0;
 286       sec->size = sec->compressed_size;
 287       sec->compress_status = COMPRESS_SECTION_NONE;
 288       ret = bfd_get_section_contents (abfd, sec, compressed_buffer,
 289                                       0, sec->compressed_size);
 290       /* Restore rawsize and size.  */
 291       sec->rawsize = save_rawsize;
 292       sec->size = save_size;
 293       sec->compress_status = DECOMPRESS_SECTION_SIZED;
 294       if (!ret)
 295         goto fail_compressed;
 296
 297       if (p == NULL)
 298         p = (bfd_byte *) bfd_malloc (sz);
 299       if (p == NULL)
 300         goto fail_compressed;
 301
 302       compression_header_size = bfd_get_compression_header_size (abfd, sec);
 303       if (compression_header_size == 0)
 304         /* Set header size to the zlib header size if it is a
 305            SHF_COMPRESSED section.  */
 306         compression_header_size = 12;
 307       if (!decompress_contents (compressed_buffer + compression_header_size,
 308                                 sec->compressed_size - compression_header_size, p, sz))
 309         {
 310           bfd_set_error (bfd_error_bad_value);
 311           if (p != *ptr)
 312             free (p);
 313         fail_compressed:
 314           free (compressed_buffer);
 315           return FALSE;
 316         }
 317
 318       free (compressed_buffer);
 319       *ptr = p;
 320       return TRUE;
 321
 322     case COMPRESS_SECTION_DONE:
 323       if (sec->contents == NULL)
 324         return FALSE;
 325       if (p == NULL)
 326         {
 327           p = (bfd_byte *) bfd_malloc (sz);
 328           if (p == NULL)
 329             return FALSE;
 330           *ptr = p;
 331         }
 332       /* PR 17512; file: 5bc29788.  */
 333       if (p != sec->contents)
 334         memcpy (p, sec->contents, sz);
 335       return TRUE;
 336
 337     default:
 338       abort ();
 339     }
 340 }
 341
 342 /*
 343 FUNCTION
 344         bfd_cache_section_contents
 345
 346 SYNOPSIS
 347         void bfd_cache_section_contents
 348           (asection *sec, void *contents);
 349
 350 DESCRIPTION
 351         Stash @var(contents) so any following reads of @var(sec) do
 352         not need to decompress again.
 353 */
 354
 355 void
 356 bfd_cache_section_contents (asection *sec, void *contents)
 357 {
 358   if (sec->compress_status == DECOMPRESS_SECTION_SIZED)
 359     sec->compress_status = COMPRESS_SECTION_DONE;
 360   sec->contents = contents;
 361   sec->flags |= SEC_IN_MEMORY;
 362 }
 363
 364 /*
 365 FUNCTION
 366         bfd_is_section_compressed_with_header
 367
 368 SYNOPSIS
 369         bfd_boolean bfd_is_section_compressed_with_header
 370           (bfd *abfd, asection *section,
 371           int *compression_header_size_p,
 372           bfd_size_type *uncompressed_size_p,
 373           unsigned int *uncompressed_alignment_power_p);
 374
 375 DESCRIPTION
 376         Return @code{TRUE} if @var{section} is compressed.  Compression
 377         header size is returned in @var{compression_header_size_p},
 378         uncompressed size is returned in @var{uncompressed_size_p}
 379         and the uncompressed data alignement power is returned in
 380         @var{uncompressed_align_pow_p}.  If compression is
 381         unsupported, compression header size is returned with -1
 382         and uncompressed size is returned with 0.
 383 */
 384
 385 bfd_boolean
 386 bfd_is_section_compressed_with_header (bfd *abfd, sec_ptr sec,
 387                                        int *compression_header_size_p,
 388                                        bfd_size_type *uncompressed_size_p,
 389                                        unsigned int *uncompressed_align_pow_p)
 390 {
 391   bfd_byte header[MAX_COMPRESSION_HEADER_SIZE];
 392   int compression_header_size;
 393   int header_size;
 394   unsigned int saved = sec->compress_status;
 395   bfd_boolean compressed;
 396
 397   compression_header_size = bfd_get_compression_header_size (abfd, sec);
 398   if (compression_header_size > MAX_COMPRESSION_HEADER_SIZE)
 399     abort ();
 400   header_size = compression_header_size ? compression_header_size : 12;
 401
 402   /* Don't decompress the section.  */
 403   sec->compress_status = COMPRESS_SECTION_NONE;
 404
 405   /* Read the header.  */
 406   if (bfd_get_section_contents (abfd, sec, header, 0, header_size))
 407     {
 408       if (compression_header_size == 0)
 409         /* In this case, it should be "ZLIB" followed by the uncompressed
 410            section size, 8 bytes in big-endian order.  */
 411         compressed = CONST_STRNEQ ((char*) header , "ZLIB");
 412       else
 413         compressed = TRUE;
 414     }
 415   else
 416     compressed = FALSE;
 417
 418   *uncompressed_size_p = sec->size;
 419   if (compressed)
 420     {
 421       if (compression_header_size != 0)
 422         {
 423           if (!bfd_check_compression_header (abfd, header, sec,
 424                                              uncompressed_size_p,
 425                                              uncompressed_align_pow_p))
 426             compression_header_size = -1;
 427         }
 428       /* Check for the pathalogical case of a debug string section that
 429          contains the string ZLIB.... as the first entry.  We assume that
 430          no uncompressed .debug_str section would ever be big enough to
 431          have the first byte of its (big-endian) size be non-zero.  */
 432       else if (strcmp (sec->name, ".debug_str") == 0
 433                && ISPRINT (header[4]))
 434         compressed = FALSE;
 435       else
 436         *uncompressed_size_p = bfd_getb64 (header + 4);
 437     }
 438
 439   /* Restore compress_status.  */
 440   sec->compress_status = saved;
 441   *compression_header_size_p = compression_header_size;
 442   return compressed;
 443 }
 444
 445 /*
 446 FUNCTION
 447         bfd_is_section_compressed
 448
 449 SYNOPSIS
 450         bfd_boolean bfd_is_section_compressed
 451           (bfd *abfd, asection *section);
 452
 453 DESCRIPTION
 454         Return @code{TRUE} if @var{section} is compressed.
 455 */
 456
 457 bfd_boolean
 458 bfd_is_section_compressed (bfd *abfd, sec_ptr sec)
 459 {
 460   int compression_header_size;
 461   bfd_size_type uncompressed_size;
 462   unsigned int uncompressed_align_power;
 463   return (bfd_is_section_compressed_with_header (abfd, sec,
 464                                                  &compression_header_size,
 465                                                  &uncompressed_size,
 466                                                  &uncompressed_align_power)
 467           && compression_header_size >= 0
 468           && uncompressed_size > 0);
 469 }
 470
 471 /*
 472 FUNCTION
 473         bfd_init_section_decompress_status
 474
 475 SYNOPSIS
 476         bfd_boolean bfd_init_section_decompress_status
 477           (bfd *abfd, asection *section);
 478
 479 DESCRIPTION
 480         Record compressed section size, update section size with
 481         decompressed size and set compress_status to
 482         DECOMPRESS_SECTION_SIZED.
 483
 484         Return @code{FALSE} if the section is not a valid compressed
 485         section.  Otherwise, return @code{TRUE}.
 486 */
 487
 488 bfd_boolean
 489 bfd_init_section_decompress_status (bfd *abfd, sec_ptr sec)
 490 {
 491   bfd_byte header[MAX_COMPRESSION_HEADER_SIZE];
 492   int compression_header_size;
 493   int header_size;
 494   bfd_size_type uncompressed_size;
 495   unsigned int uncompressed_alignment_power = 0;
 496
 497   compression_header_size = bfd_get_compression_header_size (abfd, sec);
 498   if (compression_header_size > MAX_COMPRESSION_HEADER_SIZE)
 499     abort ();
 500   header_size = compression_header_size ? compression_header_size : 12;
 501
 502   /* Read the header.  */
 503   if (sec->rawsize != 0
 504       || sec->contents != NULL
 505       || sec->compress_status != COMPRESS_SECTION_NONE
 506       || !bfd_get_section_contents (abfd, sec, header, 0, header_size))
 507     {
 508       bfd_set_error (bfd_error_invalid_operation);
 509       return FALSE;
 510     }
 511
 512   if (compression_header_size == 0)
 513     {
 514       /* In this case, it should be "ZLIB" followed by the uncompressed
 515          section size, 8 bytes in big-endian order.  */
 516       if (! CONST_STRNEQ ((char*) header, "ZLIB"))
 517         {
 518           bfd_set_error (bfd_error_wrong_format);
 519           return FALSE;
 520         }
 521       uncompressed_size = bfd_getb64 (header + 4);
 522     }
 523   else if (!bfd_check_compression_header (abfd, header, sec,
 524                                           &uncompressed_size,
 525                                           &uncompressed_alignment_power))
 526     {
 527       bfd_set_error (bfd_error_wrong_format);
 528       return FALSE;
 529     }
 530
 531   sec->compressed_size = sec->size;
 532   sec->size = uncompressed_size;
 533   bfd_set_section_alignment (abfd, sec, uncompressed_alignment_power);
 534   sec->compress_status = DECOMPRESS_SECTION_SIZED;
 535
 536   return TRUE;
 537 }
 538
 539 /*
 540 FUNCTION
 541         bfd_init_section_compress_status
 542
 543 SYNOPSIS
 544         bfd_boolean bfd_init_section_compress_status
 545           (bfd *abfd, asection *section);
 546
 547 DESCRIPTION
 548         If open for read, compress section, update section size with
 549         compressed size and set compress_status to COMPRESS_SECTION_DONE.
 550
 551         Return @code{FALSE} if the section is not a valid compressed
 552         section.  Otherwise, return @code{TRUE}.
 553 */
 554
 555 bfd_boolean
 556 bfd_init_section_compress_status (bfd *abfd, sec_ptr sec)
 557 {
 558   bfd_size_type uncompressed_size;
 559   bfd_byte *uncompressed_buffer;
 560
 561   /* Error if not opened for read.  */
 562   if (abfd->direction != read_direction
 563       || sec->size == 0
 564       || sec->rawsize != 0
 565       || sec->contents != NULL
 566       || sec->compress_status != COMPRESS_SECTION_NONE)
 567     {
 568       bfd_set_error (bfd_error_invalid_operation);
 569       return FALSE;
 570     }
 571
 572   /* Read in the full section contents and compress it.  */
 573   uncompressed_size = sec->size;
 574   uncompressed_buffer = (bfd_byte *) bfd_malloc (uncompressed_size);
 575   /* PR 21431 */
 576   if (uncompressed_buffer == NULL)
 577     return FALSE;
 578
 579   if (!bfd_get_section_contents (abfd, sec, uncompressed_buffer,
 580                                  0, uncompressed_size))
 581     return FALSE;
 582
 583   uncompressed_size = bfd_compress_section_contents (abfd, sec,
 584                                                      uncompressed_buffer,
 585                                                      uncompressed_size);
 586   return uncompressed_size != 0;
 587 }
 588
 589 /*
 590 FUNCTION
 591         bfd_compress_section
 592
 593 SYNOPSIS
 594         bfd_boolean bfd_compress_section
 595           (bfd *abfd, asection *section, bfd_byte *uncompressed_buffer);
 596
 597 DESCRIPTION
 598         If open for write, compress section, update section size with
 599         compressed size and set compress_status to COMPRESS_SECTION_DONE.
 600
 601         Return @code{FALSE} if compression fail.  Otherwise, return
 602         @code{TRUE}.
 603 */
 604
 605 bfd_boolean
 606 bfd_compress_section (bfd *abfd, sec_ptr sec, bfd_byte *uncompressed_buffer)
 607 {
 608   bfd_size_type uncompressed_size = sec->size;
 609
 610   /* Error if not opened for write.  */
 611   if (abfd->direction != write_direction
 612       || uncompressed_size == 0
 613       || uncompressed_buffer == NULL
 614       || sec->contents != NULL
 615       || sec->compressed_size != 0
 616       || sec->compress_status != COMPRESS_SECTION_NONE)
 617     {
 618       bfd_set_error (bfd_error_invalid_operation);
 619       return FALSE;
 620     }
 621
 622   /* Compress it.  */
 623   return bfd_compress_section_contents (abfd, sec, uncompressed_buffer,
 624                                         uncompressed_size) != 0;
 625 }