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