bfd/compress.c

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