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