bfd/compress.c

   1 /* Compressed section support (intended for debug sections).
   2    Copyright (C) 2008-2017 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   int header_size = bfd_get_compression_header_size (abfd, NULL);
  88   bfd_boolean compressed
  89     = bfd_is_section_compressed_with_header (abfd, sec,
  90                                              &orig_compression_header_size,
  91                                              &orig_uncompressed_size);
  92
  93   /* Either ELF compression header or the 12-byte, "ZLIB" + 8-byte size,
  94      overhead in .zdebug* section.  */
  95   if (!header_size)
  96      header_size = 12;
  97
  98   if (compressed)
  99     {
 100       /* We shouldn't decompress unsupported compressed section.  */
 101       if (orig_compression_header_size < 0)
 102         abort ();
 103
 104       /* Different compression schemes.  Just move the compressed section
 105          contents to the right position. */
 106       if (orig_compression_header_size == 0)
 107         {
 108           /* Convert it from .zdebug* section.  Get the uncompressed
 109              size first.  We need to substract the 12-byte overhead in
 110              .zdebug* section.  Set orig_compression_header_size to
 111              the 12-bye overhead.  */
 112           orig_compression_header_size = 12;
 113           zlib_size = uncompressed_size - 12;
 114         }
 115       else
 116         {
 117           /* Convert it to .zdebug* section.  */
 118           zlib_size = uncompressed_size - orig_compression_header_size;
 119         }
 120
 121       /* Add the header size.  */
 122       compressed_size = zlib_size + header_size;
 123     }
 124   else
 125     compressed_size = compressBound (uncompressed_size) + header_size;
 126
 127   /* Uncompress if it leads to smaller size.  */
 128   if (compressed && compressed_size > orig_uncompressed_size)
 129     {
 130       decompress = TRUE;
 131       buffer_size = orig_uncompressed_size;
 132     }
 133   else
 134     {
 135       decompress = FALSE;
 136       buffer_size = compressed_size;
 137     }
 138   buffer = (bfd_byte *) bfd_alloc (abfd, buffer_size);
 139   if (buffer == NULL)
 140     return 0;
 141
 142   if (compressed)
 143     {
 144       sec->size = orig_uncompressed_size;
 145       if (decompress)
 146         {
 147           if (!decompress_contents (uncompressed_buffer
 148                                     + orig_compression_header_size,
 149                                     zlib_size, buffer, buffer_size))
 150             {
 151               bfd_set_error (bfd_error_bad_value);
 152               bfd_release (abfd, buffer);
 153               return 0;
 154             }
 155           free (uncompressed_buffer);
 156           sec->contents = buffer;
 157           sec->compress_status = COMPRESS_SECTION_DONE;
 158           return orig_uncompressed_size;
 159         }
 160       else
 161         {
 162           bfd_update_compression_header (abfd, buffer, sec);
 163           memmove (buffer + header_size,
 164                    uncompressed_buffer + orig_compression_header_size,
 165                    zlib_size);
 166         }
 167     }
 168   else
 169     {
 170       if (compress ((Bytef*) buffer + header_size,
 171                     &compressed_size,
 172                     (const Bytef*) uncompressed_buffer,
 173                     uncompressed_size) != Z_OK)
 174         {
 175           bfd_release (abfd, buffer);
 176           bfd_set_error (bfd_error_bad_value);
 177           return 0;
 178         }
 179
 180       compressed_size += header_size;
 181       /* PR binutils/18087: If compression didn't make the section smaller,
 182          just keep it uncompressed.  */
 183       if (compressed_size < uncompressed_size)
 184         bfd_update_compression_header (abfd, buffer, sec);
 185       else
 186         {
 187           /* NOTE: There is a small memory leak here since
 188              uncompressed_buffer is malloced and won't be freed.  */
 189           bfd_release (abfd, buffer);
 190           sec->contents = uncompressed_buffer;
 191           sec->compress_status = COMPRESS_SECTION_NONE;
 192           return uncompressed_size;
 193         }
 194     }
 195
 196   free (uncompressed_buffer);
 197   sec->contents = buffer;
 198   sec->size = compressed_size;
 199   sec->compress_status = COMPRESS_SECTION_DONE;
 200
 201   return uncompressed_size;
 202 }
 203
 204 /*
 205 FUNCTION
 206         bfd_get_full_section_contents
 207
 208 SYNOPSIS
 209         bfd_boolean bfd_get_full_section_contents
 210           (bfd *abfd, asection *section, bfd_byte **ptr);
 211
 212 DESCRIPTION
 213         Read all data from @var{section} in BFD @var{abfd}, decompress
 214         if needed, and store in @var{*ptr}.  If @var{*ptr} is NULL,
 215         return @var{*ptr} with memory malloc'd by this function.
 216
 217         Return @code{TRUE} if the full section contents is retrieved
 218         successfully.  If the section has no contents then this function
 219         returns @code{TRUE} but @var{*ptr} is set to NULL.
 220 */
 221
 222 bfd_boolean
 223 bfd_get_full_section_contents (bfd *abfd, sec_ptr sec, bfd_byte **ptr)
 224 {
 225   bfd_size_type sz;
 226   bfd_byte *p = *ptr;
 227   bfd_boolean ret;
 228   bfd_size_type save_size;
 229   bfd_size_type save_rawsize;
 230   bfd_byte *compressed_buffer;
 231   unsigned int compression_header_size;
 232
 233   if (abfd->direction != write_direction && sec->rawsize != 0)
 234     sz = sec->rawsize;
 235   else
 236     sz = sec->size;
 237   if (sz == 0)
 238     {
 239       *ptr = NULL;
 240       return TRUE;
 241     }
 242   else if (bfd_get_file_size (abfd) > 0
 243            && sz > (bfd_size_type) bfd_get_file_size (abfd))
 244     {
 245       *ptr = NULL;
 246       return FALSE;
 247     }
 248
 249   switch (sec->compress_status)
 250     {
 251     case COMPRESS_SECTION_NONE:
 252       if (p == NULL)
 253         {
 254           p = (bfd_byte *) bfd_malloc (sz);
 255           if (p == NULL)
 256             {
 257               /* PR 20801: Provide a more helpful error message.  */
 258               if (bfd_get_error () == bfd_error_no_memory)
 259                 _bfd_error_handler
 260                   /* xgettext:c-format */
 261                   (_("error: %B(%A) is too large (%#lx bytes)"),
 262                   abfd, sec, (long) sz);
 263             return FALSE;
 264             }
 265         }
 266
 267       if (!bfd_get_section_contents (abfd, sec, p, 0, sz))
 268         {
 269           if (*ptr != p)
 270             free (p);
 271           return FALSE;
 272         }
 273       *ptr = p;
 274       return TRUE;
 275
 276     case DECOMPRESS_SECTION_SIZED:
 277       /* Read in the full compressed section contents.  */
 278       compressed_buffer = (bfd_byte *) bfd_malloc (sec->compressed_size);
 279       if (compressed_buffer == NULL)
 280         return FALSE;
 281       save_rawsize = sec->rawsize;
 282       save_size = sec->size;
 283       /* Clear rawsize, set size to compressed size and set compress_status
 284          to COMPRESS_SECTION_NONE.  If the compressed size is bigger than
 285          the uncompressed size, bfd_get_section_contents will fail.  */
 286       sec->rawsize = 0;
 287       sec->size = sec->compressed_size;
 288       sec->compress_status = COMPRESS_SECTION_NONE;
 289       ret = bfd_get_section_contents (abfd, sec, compressed_buffer,
 290                                       0, sec->compressed_size);
 291       /* Restore rawsize and size.  */
 292       sec->rawsize = save_rawsize;
 293       sec->size = save_size;
 294       sec->compress_status = DECOMPRESS_SECTION_SIZED;
 295       if (!ret)
 296         goto fail_compressed;
 297
 298       if (p == NULL)
 299         p = (bfd_byte *) bfd_malloc (sz);
 300       if (p == NULL)
 301         goto fail_compressed;
 302
 303       compression_header_size = bfd_get_compression_header_size (abfd, sec);
 304       if (compression_header_size == 0)
 305         /* Set header size to the zlib header size if it is a
 306            SHF_COMPRESSED section.  */
 307         compression_header_size = 12;
 308       if (!decompress_contents (compressed_buffer + compression_header_size,
 309                                 sec->compressed_size - compression_header_size, p, sz))
 310         {
 311           bfd_set_error (bfd_error_bad_value);
 312           if (p != *ptr)
 313             free (p);
 314         fail_compressed:
 315           free (compressed_buffer);
 316           return FALSE;
 317         }
 318
 319       free (compressed_buffer);
 320       *ptr = p;
 321       return TRUE;
 322
 323     case COMPRESS_SECTION_DONE:
 324       if (sec->contents == NULL)
 325         return FALSE;
 326       if (p == NULL)
 327         {
 328           p = (bfd_byte *) bfd_malloc (sz);
 329           if (p == NULL)
 330             return FALSE;
 331           *ptr = p;
 332         }
 333       /* PR 17512; file: 5bc29788.  */
 334       if (p != sec->contents)
 335         memcpy (p, sec->contents, sz);
 336       return TRUE;
 337
 338     default:
 339       abort ();
 340     }
 341 }
 342
 343 /*
 344 FUNCTION
 345         bfd_cache_section_contents
 346
 347 SYNOPSIS
 348         void bfd_cache_section_contents
 349           (asection *sec, void *contents);
 350
 351 DESCRIPTION
 352         Stash @var(contents) so any following reads of @var(sec) do
 353         not need to decompress again.
 354 */
 355
 356 void
 357 bfd_cache_section_contents (asection *sec, void *contents)
 358 {
 359   if (sec->compress_status == DECOMPRESS_SECTION_SIZED)
 360     sec->compress_status = COMPRESS_SECTION_DONE;
 361   sec->contents = contents;
 362   sec->flags |= SEC_IN_MEMORY;
 363 }
 364
 365 /*
 366 FUNCTION
 367         bfd_is_section_compressed_with_header
 368
 369 SYNOPSIS
 370         bfd_boolean bfd_is_section_compressed_with_header
 371           (bfd *abfd, asection *section,
 372           int *compression_header_size_p,
 373           bfd_size_type *uncompressed_size_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} and
 378         uncompressed size is returned in @var{uncompressed_size_p}.  If
 379         compression is unsupported, compression header size is returned
 380         with -1 and uncompressed size is returned with 0.
 381 */
 382
 383 bfd_boolean
 384 bfd_is_section_compressed_with_header (bfd *abfd, sec_ptr sec,
 385                                        int *compression_header_size_p,
 386                                        bfd_size_type *uncompressed_size_p)
 387 {
 388   bfd_byte header[MAX_COMPRESSION_HEADER_SIZE];
 389   int compression_header_size;
 390   int header_size;
 391   unsigned int saved = sec->compress_status;
 392   bfd_boolean compressed;
 393
 394   compression_header_size = bfd_get_compression_header_size (abfd, sec);
 395   if (compression_header_size > MAX_COMPRESSION_HEADER_SIZE)
 396     abort ();
 397   header_size = compression_header_size ? compression_header_size : 12;
 398
 399   /* Don't decompress the section.  */
 400   sec->compress_status = COMPRESS_SECTION_NONE;
 401
 402   /* Read the header.  */
 403   if (bfd_get_section_contents (abfd, sec, header, 0, header_size))
 404     {
 405       if (compression_header_size == 0)
 406         /* In this case, it should be "ZLIB" followed by the uncompressed
 407            section size, 8 bytes in big-endian order.  */
 408         compressed = CONST_STRNEQ ((char*) header , "ZLIB");
 409       else
 410         compressed = TRUE;
 411     }
 412   else
 413     compressed = FALSE;
 414
 415   *uncompressed_size_p = sec->size;
 416   if (compressed)
 417     {
 418       if (compression_header_size != 0)
 419         {
 420           if (!bfd_check_compression_header (abfd, header, sec,
 421                                              uncompressed_size_p))
 422             compression_header_size = -1;
 423         }
 424       /* Check for the pathalogical case of a debug string section that
 425          contains the string ZLIB.... as the first entry.  We assume that
 426          no uncompressed .debug_str section would ever be big enough to
 427          have the first byte of its (big-endian) size be non-zero.  */
 428       else if (strcmp (sec->name, ".debug_str") == 0
 429                && ISPRINT (header[4]))
 430         compressed = FALSE;
 431       else
 432         *uncompressed_size_p = bfd_getb64 (header + 4);
 433     }
 434
 435   /* Restore compress_status.  */
 436   sec->compress_status = saved;
 437   *compression_header_size_p = compression_header_size;
 438   return compressed;
 439 }
 440
 441 /*
 442 FUNCTION
 443         bfd_is_section_compressed
 444
 445 SYNOPSIS
 446         bfd_boolean bfd_is_section_compressed
 447           (bfd *abfd, asection *section);
 448
 449 DESCRIPTION
 450         Return @code{TRUE} if @var{section} is compressed.
 451 */
 452
 453 bfd_boolean
 454 bfd_is_section_compressed (bfd *abfd, sec_ptr sec)
 455 {
 456   int compression_header_size;
 457   bfd_size_type uncompressed_size;
 458   return (bfd_is_section_compressed_with_header (abfd, sec,
 459                                                  &compression_header_size,
 460                                                  &uncompressed_size)
 461           && compression_header_size >= 0
 462           && uncompressed_size > 0);
 463 }
 464
 465 /*
 466 FUNCTION
 467         bfd_init_section_decompress_status
 468
 469 SYNOPSIS
 470         bfd_boolean bfd_init_section_decompress_status
 471           (bfd *abfd, asection *section);
 472
 473 DESCRIPTION
 474         Record compressed section size, update section size with
 475         decompressed size and set compress_status to
 476         DECOMPRESS_SECTION_SIZED.
 477
 478         Return @code{FALSE} if the section is not a valid compressed
 479         section.  Otherwise, return @code{TRUE}.
 480 */
 481
 482 bfd_boolean
 483 bfd_init_section_decompress_status (bfd *abfd, sec_ptr sec)
 484 {
 485   bfd_byte header[MAX_COMPRESSION_HEADER_SIZE];
 486   int compression_header_size;
 487   int header_size;
 488   bfd_size_type uncompressed_size;
 489
 490   compression_header_size = bfd_get_compression_header_size (abfd, sec);
 491   if (compression_header_size > MAX_COMPRESSION_HEADER_SIZE)
 492     abort ();
 493   header_size = compression_header_size ? compression_header_size : 12;
 494
 495   /* Read the header.  */
 496   if (sec->rawsize != 0
 497       || sec->contents != NULL
 498       || sec->compress_status != COMPRESS_SECTION_NONE
 499       || !bfd_get_section_contents (abfd, sec, header, 0, header_size))
 500     {
 501       bfd_set_error (bfd_error_invalid_operation);
 502       return FALSE;
 503     }
 504
 505   if (compression_header_size == 0)
 506     {
 507       /* In this case, it should be "ZLIB" followed by the uncompressed
 508          section size, 8 bytes in big-endian order.  */
 509       if (! CONST_STRNEQ ((char*) header, "ZLIB"))
 510         {
 511           bfd_set_error (bfd_error_wrong_format);
 512           return FALSE;
 513         }
 514       uncompressed_size = bfd_getb64 (header + 4);
 515     }
 516   else if (!bfd_check_compression_header (abfd, header, sec,
 517                                          &uncompressed_size))
 518     {
 519       bfd_set_error (bfd_error_wrong_format);
 520       return FALSE;
 521     }
 522
 523   sec->compressed_size = sec->size;
 524   sec->size = uncompressed_size;
 525   sec->compress_status = DECOMPRESS_SECTION_SIZED;
 526
 527   return TRUE;
 528 }
 529
 530 /*
 531 FUNCTION
 532         bfd_init_section_compress_status
 533
 534 SYNOPSIS
 535         bfd_boolean bfd_init_section_compress_status
 536           (bfd *abfd, asection *section);
 537
 538 DESCRIPTION
 539         If open for read, compress section, update section size with
 540         compressed size and set compress_status to COMPRESS_SECTION_DONE.
 541
 542         Return @code{FALSE} if the section is not a valid compressed
 543         section.  Otherwise, return @code{TRUE}.
 544 */
 545
 546 bfd_boolean
 547 bfd_init_section_compress_status (bfd *abfd, sec_ptr sec)
 548 {
 549   bfd_size_type uncompressed_size;
 550   bfd_byte *uncompressed_buffer;
 551
 552   /* Error if not opened for read.  */
 553   if (abfd->direction != read_direction
 554       || sec->size == 0
 555       || sec->rawsize != 0
 556       || sec->contents != NULL
 557       || sec->compress_status != COMPRESS_SECTION_NONE)
 558     {
 559       bfd_set_error (bfd_error_invalid_operation);
 560       return FALSE;
 561     }
 562
 563   /* Read in the full section contents and compress it.  */
 564   uncompressed_size = sec->size;
 565   uncompressed_buffer = (bfd_byte *) bfd_malloc (uncompressed_size);
 566   /* PR 21431 */
 567   if (uncompressed_buffer == NULL)
 568     return FALSE;
 569
 570   if (!bfd_get_section_contents (abfd, sec, uncompressed_buffer,
 571                                  0, uncompressed_size))
 572     return FALSE;
 573
 574   uncompressed_size = bfd_compress_section_contents (abfd, sec,
 575                                                      uncompressed_buffer,
 576                                                      uncompressed_size);
 577   return uncompressed_size != 0;
 578 }
 579
 580 /*
 581 FUNCTION
 582         bfd_compress_section
 583
 584 SYNOPSIS
 585         bfd_boolean bfd_compress_section
 586           (bfd *abfd, asection *section, bfd_byte *uncompressed_buffer);
 587
 588 DESCRIPTION
 589         If open for write, compress section, update section size with
 590         compressed size and set compress_status to COMPRESS_SECTION_DONE.
 591
 592         Return @code{FALSE} if compression fail.  Otherwise, return
 593         @code{TRUE}.
 594 */
 595
 596 bfd_boolean
 597 bfd_compress_section (bfd *abfd, sec_ptr sec, bfd_byte *uncompressed_buffer)
 598 {
 599   bfd_size_type uncompressed_size = sec->size;
 600
 601   /* Error if not opened for write.  */
 602   if (abfd->direction != write_direction
 603       || uncompressed_size == 0
 604       || uncompressed_buffer == NULL
 605       || sec->contents != NULL
 606       || sec->compressed_size != 0
 607       || sec->compress_status != COMPRESS_SECTION_NONE)
 608     {
 609       bfd_set_error (bfd_error_invalid_operation);
 610       return FALSE;
 611     }
 612
 613   /* Compress it.  */
 614   return bfd_compress_section_contents (abfd, sec, uncompressed_buffer,
 615                                         uncompressed_size) != 0;
 616 }